Make Dream QA responses story-led

dream_customs/pipeline.py

@@ -19,6 +19,8 @@ from dream_customs.render import render_pact_card, render_today_tip_card
 from dream_customs.safety import needs_escalation, safety_note
 from dream_customs.schema import CustomsSession, DreamIntake, DreamQAState, EvidenceItem, PactCard, TimelineEvent, TodayTipCard
 
+MAX_DREAM_DECOMPOSITION_QUESTIONS = 3
+
 
 def _normalize_language(language: str = "en") -> str:
     return "zh" if language == "zh" else "en"
@@ -108,6 +110,12 @@ _ZH_ANCHOR_MARKERS = [
     "掉进海",
     "海里",
     "海",
+    "前任发消息",
+    "发消息又消失",
+    "发消息",
+    "消息",
+    "前任",
+    "消失",
     "小孩找不到家",
     "小孩",
     "找不到家",
@@ -210,6 +218,12 @@ _ZH_TO_EN_PHRASES = {
     "掉进海": "falling into the sea",
     "海里": "sea",
     "海": "sea",
+    "前任发消息": "former partner sending a message",
+    "发消息又消失": "message that disappeared",
+    "发消息": "sending a message",
+    "消息": "message",
+    "前任": "former partner",
+    "消失": "disappearing",
     "小孩找不到家": "child unable to find home",
     "小孩": "child",
     "找不到家": "unable to find home",
@@ -304,6 +318,44 @@ _ZH_TO_EN_PHRASES = {
     "梦境": "dream",
 }
 
+_EN_TO_ZH_PHRASES = {
+    "a simple sketch of a person standing on wavy": "海浪上的小人",
+    "simple sketch of a person standing on wavy": "海浪上的小人",
+    "person standing on wavy": "海浪上的小人",
+    "wavy lines representing water": "海浪",
+    "wavy lines": "海浪",
+    "wavy": "海浪",
+    "a dreamlike representation of a sea under night": "夜晚的海",
+    "dreamlike representation of a sea": "夜晚的海",
+    "sea under night": "夜晚的海",
+    "dark sea dream": "漆黑的海",
+    "dark sea": "漆黑的海",
+    "wavy water": "海浪",
+    "waves": "海浪",
+    "wave": "海浪",
+    "sea": "海",
+    "crescent moon": "月牙",
+    "moon": "月亮",
+    "stick figure": "小人",
+    "melted elevator buttons": "融化的电梯按钮",
+    "melted elevator button": "融化的电梯按钮",
+    "elevator buttons": "电梯按钮",
+    "elevator button": "电梯按钮",
+    "elevator doors": "电梯门",
+    "elevator": "电梯",
+    "button": "按钮",
+    "floor 14": "数字 14",
+    "number 14": "数字 14",
+    "lost child at subway station": "地铁站里迷路的小孩",
+    "lost child at subway": "地铁里迷路的小孩",
+    "subway station": "地铁站",
+    "subway": "地铁",
+    "child figure": "小孩",
+    "child": "小孩",
+    "home": "回家的方向",
+    "arrow": "箭头",
+}
+
 
 def _dedupe_preserve_order(items: List[str]) -> List[str]:
     seen = set()
@@ -462,10 +514,23 @@ def _english_anchor_text(text: str) -> str:
     return clean
 
 
+def _zh_anchor_text(text: str) -> str:
+    clean = re.sub(r"\s+", " ", (text or "").strip(" .,:;!?\"'()[]{}"))
+    if not clean:
+        return ""
+    lowered = clean.lower()
+    for source, target in sorted(_EN_TO_ZH_PHRASES.items(), key=lambda item: len(item[0]), reverse=True):
+        if source in lowered:
+            return target
+    if re.search(r"[A-Za-z]", clean) and not re.search(r"[\u4e00-\u9fff]", clean):
+        return ""
+    return clean
+
+
 def _anchors_for_language(intake: DreamIntake, language: str = "en") -> List[str]:
     anchors = _extract_dream_anchors(intake)
     if _is_zh(language):
-        return anchors
+        return _dedupe_preserve_order([anchor for anchor in (_zh_anchor_text(anchor) for anchor in anchors) if anchor])
     localized = [_english_anchor_text(anchor) for anchor in anchors]
     return _dedupe_preserve_order([anchor for anchor in localized if anchor])
 
@@ -514,6 +579,103 @@ def _secondary_anchor(intake: DreamIntake, language: str = "en") -> str:
     return anchors[1] if len(anchors) > 1 else _primary_anchor(intake, language)
 
 
+def _story_text(intake: DreamIntake, answers: str = "") -> str:
+    return "\n".join(
+        part
+        for part in [
+            intake.dream_text,
+            intake.voice_transcript,
+            " ".join(intake.visual_clues),
+            intake.mood,
+            intake.main_question,
+            intake.uncertainty,
+            intake.user_context,
+            answers or "",
+        ]
+        if part and part.strip()
+    ).lower()
+
+
+def _contains_any(text: str, terms: List[str]) -> bool:
+    return any(term in text for term in terms)
+
+
+def _dream_theme(intake: DreamIntake, answers: str = "") -> str:
+    text = _story_text(intake, answers)
+    if _contains_any(text, ["小孩", "child", "找不到家", "lost", "home", "回家", "地铁", "subway"]):
+        return "lost_home"
+    if _contains_any(text, ["海", "海浪", "水", "月牙", "moon", "sea", "wave", "water", "dark sea"]):
+        return "dark_water"
+    if _contains_any(text, ["电梯", "按钮", "14", "elevator", "button", "floor"]):
+        return "stuck_elevator"
+    if _contains_any(text, ["图书馆", "楼梯", "便签", "call home", "library", "staircase", "sticky note"]):
+        return "library_signal"
+    if _contains_any(text, ["前任", "消息", "消失", "former partner", "ex", "message", "disappear"]):
+        return "message_loss"
+    if _contains_any(text, ["追", "被追", "chase", "chased", "running away"]):
+        return "chased"
+    if _contains_any(text, ["考试", "作业", "教室", "老师", "exam", "assignment", "classroom", "teacher", "homework"]):
+        return "school_pressure"
+    if _contains_any(text, ["路牌", "两条路", "大雾", "找不到路", "sign", "two roads", "fog", "lost road"]):
+        return "road_choice"
+    return "open"
+
+
+def _join_anchors(anchors: List[str], language: str = "en", limit: int = 3) -> str:
+    visible = [anchor for anchor in anchors[:limit] if anchor]
+    if not visible:
+        return "梦境片段" if _is_zh(language) else "dream fragments"
+    if _is_zh(language):
+        return "、".join(visible)
+    if len(visible) == 1:
+        return visible[0]
+    return ", ".join(visible[:-1]) + f", and {visible[-1]}"
+
+
+def _story_anchor_phrase(intake: DreamIntake, anchors: List[str], language: str = "en", answers: str = "") -> str:
+    theme = _dream_theme(intake, answers)
+    if _is_zh(language):
+        themed = {
+            "lost_home": "地铁站里迷路的小孩和回家的方向",
+            "dark_water": "夜晚的海、海浪和月牙下的小人",
+            "stuck_elevator": "电梯、融化的按钮和数字 14",
+            "library_signal": "旧图书馆、红色楼梯和那张便签",
+            "message_loss": "那条消息、前任和突然消失",
+            "chased": "森林、白色猫和空白路牌",
+            "school_pressure": "教室、作业和来不及交上的感觉",
+            "road_choice": "雾里的路牌和两条路",
+        }
+    else:
+        themed = {
+            "lost_home": "the lost child, the subway, and the way home",
+            "dark_water": "the dark water, the waves, and the small figure under the moon",
+            "stuck_elevator": "the elevator, the melted button, and floor 14",
+            "library_signal": "the old library, the red staircase, and the note",
+            "message_loss": "the message, the former partner, and the disappearance",
+            "chased": "the chase, the call for help, and the missing route",
+            "school_pressure": "the classroom, the assignment, and the late feeling",
+            "road_choice": "the foggy sign and the two roads",
+        }
+    if theme == "chased" and anchors:
+        return _join_anchors(anchors, language)
+    return themed.get(theme) or _join_anchors(anchors, language)
+
+
+def _answer_snippet(answers: str, language: str = "en") -> str:
+    lines = [
+        line.strip()
+        for line in (answers or "").splitlines()
+        if line.strip() and not _is_skip_answer(line, language)
+    ]
+    if not lines:
+        return ""
+    clean = re.sub(r"\s+", " ", lines[-1]).strip(" ：:「」\"'()[]{}")
+    if _is_zh(language):
+        return clean[:34].rstrip("，。；、 ")
+    words = clean.split()
+    return " ".join(words[:14])
+
+
 def _anchor_with_article(anchor: str) -> str:
     clean = (anchor or "").strip()
     if clean.lower().startswith(("the ", "a ", "an ")):
@@ -543,9 +705,314 @@ def _summary_from_intake(intake: DreamIntake, language: str = "en") -> str:
     return f"你梦见{clean}"
 
 
+def _user_supplied_text(intake: DreamIntake, answers: str = "", include_mood: bool = False) -> str:
+    parts = [
+        intake.dream_text,
+        intake.voice_transcript,
+        intake.main_question,
+        intake.uncertainty,
+        intake.user_context,
+        answers or "",
+    ]
+    if include_mood:
+        parts.append(intake.mood)
+    return "\n".join(part.strip() for part in parts if part and part.strip())
+
+
+def _question_sentence_candidates(text: str) -> List[str]:
+    pieces = re.split(r"[。！？!?\n\r]+|(?<=\.)\s+|[，,；;]", text or "")
+    return [piece.strip(" ：:「」\"'()[]{}") for piece in pieces if piece.strip()]
+
+
+def _clean_user_question(text: str, language: str = "en") -> str:
+    clean = re.sub(r"\s+", " ", (text or "").strip(" ：:「」\"'()[]{}"))
+    if not clean:
+        return ""
+    if _is_zh(language):
+        clean = re.sub(r"^(我)?(醒来后)?(最)?(想知道|想问|在想|担心|害怕)[：:，,\s]*", "", clean)
+        clean = re.sub(r"^(只)?想知道[：:，,\s]*", "", clean)
+        clean = clean.strip(" ：:「」\"'()[]{}")
+        return clean if clean.endswith(("?", "？")) else f"{clean}？"
+    clean = re.sub(
+        r"^(i\s+)?(woke\s+up\s+)?(want\s+to\s+know|wonder|am\s+wondering|need\s+to\s+know|worry|fear)\s*(if|whether|why|what|how)?\s*",
+        lambda match: (match.group(4) or "").strip() + " ",
+        clean,
+        flags=re.IGNORECASE,
+    ).strip()
+    clean = clean[0].upper() + clean[1:] if clean else ""
+    if clean and not clean.endswith("?") and re.match(r"^(why|what|how|does|do|did|is|am|are|can|could|should|would)\b", clean, re.IGNORECASE):
+        clean += "?"
+    return clean
+
+
+def _extract_explicit_user_question(intake: DreamIntake, answers: str = "", language: str = "en") -> str:
+    if intake.main_question.strip():
+        return _clean_user_question(intake.main_question, language)
+    text = _user_supplied_text(intake, answers)
+    if _is_zh(language):
+        markers = (
+            "为什么",
+            "是不是",
+            "会不会",
+            "怎么办",
+            "我该",
+            "能不能",
+            "代表",
+            "说明",
+            "预兆",
+            "征兆",
+            "想知道",
+            "想问",
+            "撑不住",
+            "走出来",
+            "这么难受",
+        )
+    else:
+        markers = (
+            "why",
+            "what should",
+            "how should",
+            "does this mean",
+            "do i",
+            "am i",
+            "is this",
+            "could this",
+            "can this",
+            "should i",
+            "i wonder",
+            "want to know",
+            "not coping",
+            "cope",
+            "a sign",
+            "omen",
+        )
+    for sentence in _question_sentence_candidates(text):
+        lowered = sentence.lower()
+        if _is_skip_answer(sentence, language):
+            continue
+        if any(marker in lowered for marker in markers):
+            return _clean_user_question(sentence, language)
+    return ""
+
+
+def _emotion_labels_from_text(text: str, language: str = "en") -> List[str]:
+    lowered = (text or "").lower()
+    if _is_zh(language):
+        groups = [
+            ("害怕", ["害怕", "吓", "恐惧", "心慌", "心跳很快", "惊醒"]),
+            ("压力", ["压力", "撑不住", "扛不住", "崩溃", "压垮", "焦虑", "太累", "疲惫"]),
+            ("难过", ["难过", "难受", "伤心", "失落", "想哭", "委屈", "孤独"]),
+            ("自责", ["自责", "内疚", "愧疚", "后悔", "责怪自己"]),
+            ("需要安慰", ["安慰", "被安慰", "抱抱", "关心", "陪陪", "鸡汤"]),
+        ]
+    else:
+        groups = [
+            ("fear", ["scared", "afraid", "terrified", "panic", "panicked", "frightened"]),
+            ("pressure", ["overwhelmed", "not coping", "can't cope", "cannot cope", "burned out", "too much", "anxious"]),
+            ("sadness", ["sad", "grief", "hurt", "lonely", "heartbroken", "upset"]),
+            ("guilt", ["guilty", "ashamed", "blame myself", "regret"]),
+            ("comfort", ["comfort", "reassurance", "not productivity", "not advice", "not a pep talk"]),
+        ]
+    labels: List[str] = []
+    for label, terms in groups:
+        if any(term in lowered for term in terms):
+            labels.append(label)
+    return _dedupe_preserve_order(labels)
+
+
+def _emotion_phrase(labels: List[str], language: str = "en") -> str:
+    if not labels:
+        return "这个感受" if _is_zh(language) else "this feeling"
+    if _is_zh(language):
+        return "、".join(labels)
+    if len(labels) == 1:
+        return labels[0]
+    return ", ".join(labels[:-1]) + f", and {labels[-1]}"
+
+
+def _needs_comfort(text: str, language: str = "en") -> bool:
+    lowered = (text or "").lower()
+    if _is_zh(language):
+        return any(term in lowered for term in ["安慰", "被安慰", "抱抱", "关心", "别催", "不是鸡汤"])
+    return any(term in lowered for term in ["comfort", "reassurance", "not productivity", "not a pep talk", "not advice"])
+
+
+def _should_use_emotion_led_response(intake: DreamIntake, answers: str, language: str = "en") -> bool:
+    user_text = _user_supplied_text(intake, answers)
+    explicit_question = _extract_explicit_user_question(intake, answers, language)
+    labels = _emotion_labels_from_text(user_text, language)
+    if _is_low_context_intake(intake) and _is_skip_answer(answers, language) and not explicit_question and not _needs_comfort(user_text, language):
+        return False
+    return bool(explicit_question or labels or _needs_comfort(user_text, language))
+
+
+def _direct_question_reassurance(question: str, labels: List[str], language: str = "en") -> str:
+    lowered = (question or "").lower()
+    if _is_zh(language):
+        if any(term in lowered for term in ["撑不住", "扛不住", "崩溃"]):
+            return "它不等于你一定撑不住了；更像是在提醒你，最近的压力已经值得被认真照顾。"
+        if "走出来" in lowered:
+            return "它不急着证明你有没有走出来；更像是在说明这段难受还需要一点被看见的时间。"
+        if any(term in lowered for term in ["预兆", "征兆", "坏事", "会不会发生"]):
+            return "它不适合被当作预兆；我们先把它当作醒来后仍在身体里的担心来照顾。"
+        if any(term in lowered for term in ["我是不是", "是不是我"]):
+            return "它不是给你贴标签的证据；它更像是在把一个需要被接住的感受放到你面前。"
+        if "为什么" in lowered or "这么难受" in lowered:
+            return "这么难受不是你反应过度；梦可能只是把还没放下的感受放大给你看。"
+        emotion = _emotion_phrase(labels, language)
+        return f"你提到的{emotion}不是小事，它值得先被接住，而不是立刻被解释掉。"
+    if any(term in lowered for term in ["not coping", "cope", "coping", "falling apart"]):
+        return "This does not prove you are failing to cope; it may be showing that your pressure deserves care before answers."
+    if "sign" in lowered or "omen" in lowered or "bad will happen" in lowered:
+        return "This is safer to treat as a fear to care for, not as evidence that something bad will happen."
+    if "am i" in lowered or "does this mean i" in lowered:
+        return "This dream is not evidence for a label about you; it is one feeling asking to be met gently."
+    if "why" in lowered:
+        return "The ache makes sense; the dream may be enlarging a feeling that has not had enough room yet."
+    emotion = _emotion_phrase(labels, language)
+    return f"The {emotion} you named deserves to be met first, not explained away too quickly."
+
+
+def _emotion_led_interpretation(intake: DreamIntake, answers: str, anchors: List[str], language: str = "en") -> str:
+    if not _should_use_emotion_led_response(intake, answers, language):
+        return ""
+    question = _extract_explicit_user_question(intake, answers, language)
+    labels = _emotion_labels_from_text(_user_supplied_text(intake, answers), language)
+    emotion = _emotion_phrase(labels, language)
+    anchor = _story_anchor_phrase(intake, anchors, language, answers)
+    direct = _direct_question_reassurance(question, labels, language)
+    if _is_zh(language):
+        opener = f"你问的是「{question}」。" if question else ""
+        return (
+            f"{opener}{direct} 第一层，先承认醒来后的{emotion}是真实的，不需要被责怪。"
+            f"第二层，梦里的「{anchor}」也许把这种感受变成了一个可以看的画面。"
+            "第三层，今天不急着找唯一答案，先给自己一个能站稳的小支点。"
+        )
+    opener = f"You asked, \"{question}\" " if question else ""
+    return (
+        f"{opener}{direct} First, let the {emotion} be real without blaming yourself. "
+        f"Second, the {_anchor_with_article(anchor)} may be the dream's concrete shape for that feeling. "
+        "Third, for today the goal is not to solve the whole dream, but to give yourself one steadier place to stand."
+    )
+
+
+def _emotion_led_today_tip(intake: DreamIntake, answers: str, anchors: List[str], language: str = "en") -> str:
+    if not _should_use_emotion_led_response(intake, answers, language):
+        return ""
+    if _has_prophecy_frame(_user_supplied_text(intake, answers)):
+        return ""
+    theme = _dream_theme(intake, answers)
+    anchor = _story_anchor_phrase(intake, anchors, language, answers)
+    answer_snippet = _answer_snippet(answers, language)
+    if _is_zh(language):
+        if theme == "lost_home":
+            extra = f"如果刚才的回答里「{answer_snippet}」最重，就从它开始。" if answer_snippet else ""
+            return (
+                f"今天先顺着「{anchor}」照顾那种需要被带路的感觉，而不是急着解释梦的含义。"
+                f"{extra}给今天补一个很小的“路标”：问一个人、查一个入口，或写下下一站在哪里。"
+            )
+        if theme == "dark_water":
+            return (
+                f"今天先把「{anchor}」当成醒来后还在身体里的浪，不当成危险证明。"
+                "先选一个让自己回到岸边的动作：开灯、洗脸、发一句“我醒来有点慌，先缓一下”。"
+            )
+        if theme == "stuck_elevator":
+            return (
+                f"今天不要逼自己抵达所有楼层；先把「{anchor}」变成一个只按一次的按钮。"
+                "只确认当前最卡的一层是什么，再允许自己停在那里做一个很小动作。"
+            )
+        if theme == "library_signal":
+            return (
+                f"今天把「{anchor}」当成一张提醒你回到安定处的便签。"
+                "不用立刻整理完整答案，只挑一个让你有“回家感”的人、物或角落，靠近它五分钟。"
+            )
+        if theme == "message_loss":
+            return (
+                f"今天先把「{anchor}」看成一段还没被好好收起的联系。"
+                "不用真的发出去，先写一封不发送的回信，让那句没说完的话有地方停靠。"
+            )
+        return (
+            f"今天的小建议是：先别把「{anchor}」解释成结论；把它当成梦递过来的线索，"
+            "问问它在替你保护哪一种感受，再给那种感受一个很小的照顾动作。"
+        )
+    if theme == "lost_home":
+        extra = f" If your answer points to \"{answer_snippet}\", start there." if answer_snippet else ""
+        return (
+            f"For today, treat {anchor} as a need for guidance, not as a verdict about you.{extra} "
+            "Add one tiny wayfinding marker: ask one person, check one entrance, or name the next stop."
+        )
+    if theme == "dark_water":
+        return (
+            f"For today, treat {anchor} as a wave still in your body, not proof of danger. "
+            "Choose one shore-like action: turn on a light, wash your face, or tell someone you woke up unsettled."
+        )
+    if theme == "stuck_elevator":
+        return (
+            f"For today, do not make yourself reach every floor. Let {anchor} become one button: "
+            "name the stuck floor, then do only one small action there."
+        )
+    if theme == "library_signal":
+        return (
+            f"For today, treat {anchor} like a note pointing you back to steadiness. "
+            "Pick one person, place, or object that feels like home and spend five minutes near it."
+        )
+    if theme == "message_loss":
+        return (
+            f"For today, treat {anchor} as an unfinished contact, not a demand to reopen everything. "
+            "Write one unsent reply so the unsaid sentence has somewhere to rest."
+        )
+    return (
+        f"For today, do not turn {anchor} into a fixed conclusion. Treat it as a clue about one feeling "
+        "that needs care, then give that feeling one small caring action."
+    )
+
+
+def _emotion_led_tiny_action(intake: DreamIntake, answers: str, anchors: List[str], language: str = "en") -> str:
+    if not _should_use_emotion_led_response(intake, answers, language):
+        return ""
+    theme = _dream_theme(intake, answers)
+    anchor = _story_anchor_phrase(intake, anchors, language, answers)
+    if _is_zh(language):
+        if theme == "lost_home":
+            return f"用 5 分钟给「{anchor}」画一张三格小路线：我在找什么、我能问谁或查哪里、今天只走到哪一站。"
+        if theme == "dark_water":
+            return f"用 5 分钟做一个“上岸”动作：看着「{anchor}」，说出三个房间里的真实物件，再喝一口水或开一盏灯。"
+        if theme == "stuck_elevator":
+            return f"用 5 分钟写一个“只按这一层”的按钮：今天卡在哪一层、我能做的最小动作、做完就停。"
+        if theme == "library_signal":
+            return f"用 5 分钟把「{anchor}」改写成一张现实便签：我现在可以回到哪里，或联系谁，让自己稳一点。"
+        if theme == "message_loss":
+            return f"用 5 分钟写一封不发送的短信草稿，开头只写：梦里的「{anchor}」让我想承认的是……"
+        return f"用 5 分钟做一个三格便签：梦里的「{anchor}」最亮的细节、它带出的感受、今天能照顾它的一小步。"
+    if theme == "lost_home":
+        return f"Spend five minutes making a three-box route for {anchor}: what I am looking for, who or where I can ask, and the next stop only."
+    if theme == "dark_water":
+        return f"Spend five minutes doing one shore action for {anchor}: name three real objects in the room, then drink water or turn on a light."
+    if theme == "stuck_elevator":
+        return f"Spend five minutes making a one-floor button for {anchor}: the stuck floor, the smallest action, and permission to stop after it."
+    if theme == "library_signal":
+        return f"Spend five minutes turning {anchor} into a real note: where can I return, or who can I contact, to feel steadier?"
+    if theme == "message_loss":
+        return f"Spend five minutes drafting one unsent message that begins: what {anchor} makes me want to admit is..."
+    return f"Spend five minutes making three boxes for {anchor}: brightest detail, feeling it carries, and one small care step for today."
+
+
+def _emotion_led_caring_note(intake: DreamIntake, answers: str, language: str = "en") -> str:
+    if not _should_use_emotion_led_response(intake, answers, language):
+        return ""
+    labels = _emotion_labels_from_text(_user_supplied_text(intake, answers), language)
+    emotion = _emotion_phrase(labels, language)
+    if _is_zh(language):
+        return f"你不是太脆弱，也不是需要被催着立刻想通；这份{emotion}可以先被轻轻接住。"
+    return f"You are not weak for feeling {emotion}; you do not have to turn it into a lesson before you are comforted."
+
+
 def _main_question_from_intake(intake: DreamIntake, language: str = "en") -> str:
     if intake.main_question.strip():
-        return intake.main_question.strip()
+        return _clean_user_question(intake.main_question, language)
+    explicit_question = _extract_explicit_user_question(intake, "", language)
+    if explicit_question:
+        return explicit_question
     task = _task_focus(intake.merged_text(), language)
     if task:
         if not _is_zh(language):
@@ -576,12 +1043,31 @@ def _fallback_interpretation(intake: DreamIntake, language: str = "en") -> str:
 
 
 def _grounded_today_tip(intake: DreamIntake, language: str = "en") -> str:
-    primary = _primary_anchor(intake, language)
+    anchors = _anchors_for_language(intake, language)
+    primary = anchors[0] if anchors else _primary_anchor(intake, language)
+    anchor = _story_anchor_phrase(intake, anchors, language)
+    theme = _dream_theme(intake)
     if not _is_zh(language):
+        if theme == "lost_home":
+            return f"For today, let {anchor} become a small wayfinding cue: choose one place to ask, one entrance to check, or one next stop to name."
+        if theme == "dark_water":
+            return f"For today, let {anchor} become a shore cue: name what felt too large, then choose one ordinary thing that helps your body feel here again."
+        if theme == "library_signal":
+            return f"For today, let {anchor} become a note back to steadiness: choose one person, place, or object that feels like home and spend five minutes near it."
+        if theme == "message_loss":
+            return f"For today, let {anchor} become one unsent sentence, not a full conversation: write what is still tender and let it rest."
         return (
             f"For today, borrow one action from {_anchor_with_article(primary)}: open the task, write only the first line, "
             "and let that be enough for now."
         )
+    if theme == "lost_home":
+        return f"今天先让「{anchor}」变成一个小路标：只确认一个可以问的人、一个可以查的入口，或一个下一站。"
+    if theme == "dark_water":
+        return f"今天先让「{anchor}」变成一个上岸提示：说出那个太大的感受，再选一件能让身体回到当下的小事。"
+    if theme == "library_signal":
+        return f"今天先让「{anchor}」变成一张回到安定处的便签：靠近一个有回家感的人、地方或物件五分钟。"
+    if theme == "message_loss":
+        return f"今天先让「{anchor}」变成一句不发送的话，而不是一整场对话：写下还柔软的那句，然后让它停在那里。"
     return f"今天先从「{primary}」借一个动作：只做最小的第一步，不急着把整件事完成。"
 
 
@@ -963,6 +1449,143 @@ def _grounded_followup_question(intake: DreamIntake, language: str = "en") -> st
     return f"如果「{primary}」能递给你一个更小的第一步，今天那一步会是什么？"
 
 
+def _first_input_focus_sentence(intake: DreamIntake, language: str = "en") -> str:
+    explicit_question = _extract_explicit_user_question(intake, "", language)
+    labels = _emotion_labels_from_text(_user_supplied_text(intake, "", include_mood=True), language)
+    emotion = _emotion_phrase(labels, language)
+    anchors = _anchors_for_language(intake, language)
+    story_anchor = _story_anchor_phrase(intake, anchors, language)
+    if _is_zh(language):
+        if explicit_question and labels:
+            return f"你最在意的是「{explicit_question}」，而且醒来后的{emotion}需要先被接住。"
+        if explicit_question:
+            return f"你最在意的是「{explicit_question}」，不是只想听一个固定象征解释。"
+        if labels:
+            return f"这个梦留下的{emotion}比符号本身更重要，我会先顺着感受看。"
+        return f"核心线索先落在「{story_anchor}」上，我会先确认它和你今天的需要怎么连起来。"
+    if explicit_question and labels:
+        return f"your main question is \"{explicit_question}\", and the {emotion} after waking needs to be met first."
+    if explicit_question:
+        return f"your main question is \"{explicit_question}\", not a generic symbol reading."
+    if labels:
+        return f"the {emotion} after waking matters more than a fixed symbol meaning."
+    return f"the strongest trail begins with {story_anchor}, so I will connect it to what you may need today."
+
+
+def _decomposition_question(
+    intake: DreamIntake,
+    existing_count: int,
+    answers: str,
+    model_question: str,
+    language: str = "en",
+) -> str:
+    anchors = _anchors_for_language(intake, language)
+    story_anchor = _story_anchor_phrase(intake, anchors, language, answers)
+    theme = _dream_theme(intake, answers)
+    declared_question = _question_for_declared_real_task(intake, language) if existing_count == 0 else ""
+    if declared_question:
+        return declared_question
+    if _is_zh(language):
+        stage_questions = {
+            "lost_home": [
+                "梦里那个迷路的小孩，更像是你自己需要被带路，还是某件现实里暂时找不到家的事？",
+                "如果把地铁站或回家方向看成一个场景，最让你心里一紧的是“没人带路”“找不到入口”，还是“怕把谁弄丢”？",
+                "最后只确认今天的需要：你更想被安慰一下，还是想得到一个很小的找路动作？",
+            ],
+            "dark_water": [
+                "醒来后最强的是害怕、孤单、喘不过气，还是别的身体感受？",
+                "画面里的海浪、月牙或小人，��一个最像你醒来后还忘不掉的部分？",
+                "最后只确认今天的需要：你更想要安定身体，还是想理解为什么会这么慌？",
+            ],
+            "stuck_elevator": [
+                "电梯、按钮或数字 14 里，哪一个最像你最近卡住的感觉？",
+                "这个卡住更像“来不及开始”，还是“已经按了按钮却没有回应”？",
+                "最后只确认今天的需要：你想要一个小行动，还是先要一句能让压力降下来的话？",
+            ],
+            "library_signal": [
+                "旧图书馆、楼梯或便签里，哪一个最像梦在提醒你别忽略的线索？",
+                "那张便签或“回家”的感觉，更像想联系某个人，还是想回到一种安定状态？",
+                "最后只确认今天的需要：你想整理一个现实线索，还是先给自己一点回家的感觉？",
+            ],
+            "message_loss": [
+                "那条消息最刺痛你的地方，是它出现了、消失了，还是它来自某个具体的人？",
+                "这个梦更像在问“我还在等什么”，还是在问“我该怎么照顾还没放下的部分”？",
+                "最后只确认今天的需要：你想要一句安慰，还是一个不打扰别人的小行动？",
+            ],
+        }
+        fallback = [
+            f"在「{story_anchor}」里，醒来后最强烈的感受是什么？",
+            f"如果只选一个细节继续看，你会选「{story_anchor}」里的哪一处？为什么？",
+            "最后只确认今天的需要：你更想被安慰、被提醒，还是得到一个很小的行动？",
+        ]
+    else:
+        stage_questions = {
+            "lost_home": [
+                "Does the lost child feel more like a part of you that needs guidance, or like a real situation that has no clear way home yet?",
+                "In the subway and way-home scene, what tightens most: nobody guiding you, no visible entrance, or fear of losing someone?",
+                "Last check before the tip: would comfort help most today, or one tiny way-finding action?",
+            ],
+            "dark_water": [
+                "After waking, was the strongest feeling fear, loneliness, breathlessness, or something else in your body?",
+                "Which image stays with you most: the waves, the moon, or the small figure?",
+                "Last check before the tip: do you need help calming your body, or understanding why the image felt so intense?",
+            ],
+            "stuck_elevator": [
+                "Which detail feels closest to your current stuck point: the elevator, the melted button, or floor 14?",
+                "Does the stuckness feel more like being late to start, or like pressing the button and getting no response?",
+                "Last check before the tip: would one small action help most, or a sentence that lowers the pressure first?",
+            ],
+        }
+        fallback = [
+            f"In {story_anchor}, what feeling stayed strongest after waking?",
+            f"If we keep only one detail from {story_anchor}, which one matters most, and why?",
+            "Last check before the tip: do you want comfort, a reminder, or one very small action?",
+        ]
+    candidates = stage_questions.get(theme, fallback)
+    index = min(max(existing_count, 0), MAX_DREAM_DECOMPOSITION_QUESTIONS - 1)
+    question = candidates[index] if index < len(candidates) else model_question
+    if question:
+        return question
+    return model_question or _grounded_followup_question(intake, language)
+
+
+def _compose_decomposition_response(
+    intake: DreamIntake,
+    existing_count: int,
+    question: str,
+    answers: str,
+    language: str = "en",
+) -> str:
+    anchors = _anchors_for_language(intake, language)
+    story_anchor = _story_anchor_phrase(intake, anchors, language, answers)
+    answer_snippet = _answer_snippet(answers, language)
+    if _is_zh(language):
+        if existing_count == 0:
+            focus = _first_input_focus_sentence(intake, language)
+            return (
+                f"我先听到的是：{focus}\n\n"
+                f"我会把这个梦拆成三层来看：醒来后的感受、梦里最抓人的画面（{story_anchor}）、"
+                "以及它今天想帮你照顾的需要。\n\n"
+                f"先问一个会影响最后建议的问题：{question}"
+            )
+        if existing_count == 1:
+            prefix = f"我把你的回答也放进来了：{answer_snippet}。" if answer_snippet else "我再补一层具体画面。"
+            return f"{prefix} 这一轮只看「{story_anchor}」里最关键的连接：{question}"
+        return f"最后只确认一个方向，之后我就生成今日小 Tips：{question}"
+    if existing_count == 0:
+        focus = _first_input_focus_sentence(intake, language)
+        return (
+            f"What I hear first is that {focus}\n\n"
+            f"I will unpack this in three layers: the feeling after waking, the concrete image ({story_anchor}), "
+            f"and what it may be asking you to care for today.\n\n"
+            f"One question that will shape the final tip: {question}"
+        )
+    if existing_count == 1:
+        prefix = f"I am adding your answer: {answer_snippet}." if answer_snippet else "I will add one more concrete layer."
+        return f"{prefix} For this round, I am looking at the key link in {story_anchor}: {question}"
+    return f"One last direction check, then I will write the Today Tip: {question}"
+
+
 def _polish_card_for_daily_use(card: PactCard, intake: DreamIntake, answers: str) -> PactCard:
     polished = card.model_copy(deep=True)
     merged = "\n".join([intake.merged_text(), answers or ""])
@@ -1089,14 +1712,20 @@ def _polish_today_tip(card: TodayTipCard, intake: DreamIntake, answers: str = ""
         setattr(polished, field, _clean_placeholder_phrase(getattr(polished, field)))
     if not polished.dream_summary.strip() or _is_placeholder_anchor(polished.dream_summary) or not _text_uses_anchor(polished.dream_summary, anchors):
         polished.dream_summary = _summary_from_intake(intake, language)
-    if (
+    explicit_question = _extract_explicit_user_question(intake, answers, language)
+    if explicit_question:
+        polished.main_question = explicit_question
+    elif (
         not polished.main_question.strip()
         or _is_placeholder_anchor(polished.main_question)
         or not _text_uses_anchor(polished.main_question, anchors)
     ):
         polished.main_question = _main_question_from_intake(intake, language)
+    emotion_interpretation = _emotion_led_interpretation(intake, answers, anchors, language)
     answer_interpretation = _answer_based_interpretation(answers, _answer_bridge_anchor(anchors), language)
-    if answer_interpretation:
+    if emotion_interpretation:
+        polished.interpretation = emotion_interpretation
+    elif answer_interpretation:
         polished.interpretation = answer_interpretation
     elif _has_prophecy_frame(intake.merged_text()):
         anchor = _answer_bridge_anchor(anchors)
@@ -1115,8 +1744,11 @@ def _polish_today_tip(card: TodayTipCard, intake: DreamIntake, answers: str = ""
     elif not polished.interpretation.strip() or not _anchor_in_text(polished.interpretation, anchors):
         polished.interpretation = _fallback_interpretation(intake, language)
     generic_tip_markers = ["drink water", "hydrate", "多休息", "保持积极", "take a walk"]
+    emotion_tip = _emotion_led_today_tip(intake, answers, anchors, language)
     answer_tip = _answer_based_today_tip(answers, anchors[0], language)
-    if answer_tip:
+    if emotion_tip:
+        polished.today_tip = emotion_tip
+    elif answer_tip:
         polished.today_tip = answer_tip
     elif _has_prophecy_frame(intake.merged_text()):
         anchor = anchors[0]
@@ -1140,8 +1772,11 @@ def _polish_today_tip(card: TodayTipCard, intake: DreamIntake, answers: str = ""
     ):
         polished.today_tip = _grounded_today_tip(intake, language)
     hard_action_markers = ["address it immediately", "fix it immediately", "solve it immediately"]
+    emotion_action = _emotion_led_tiny_action(intake, answers, anchors, language)
     answer_action = _answer_based_tiny_action(answers, language)
-    if answer_action:
+    if emotion_action:
+        polished.tiny_action = emotion_action
+    elif answer_action:
         polished.tiny_action = answer_action
     elif _has_prophecy_frame(intake.merged_text()):
         polished.tiny_action = (
@@ -1161,11 +1796,34 @@ def _polish_today_tip(card: TodayTipCard, intake: DreamIntake, answers: str = ""
         or not _anchor_in_text(polished.tiny_action, anchors)
         or any(marker in polished.tiny_action.lower() for marker in hard_action_markers)
     ):
+        anchor_phrase = _story_anchor_phrase(intake, anchors, language, answers)
+        theme = _dream_theme(intake, answers)
         if _is_zh(language):
-            polished.tiny_action = f"用 5 分钟写下：今天和「{anchors[0]}」有关的第一小步是什么？"
+            if theme == "lost_home":
+                polished.tiny_action = f"用 5 分钟给「{anchor_phrase}」补一张小路标：我在找什么、能问哪里、下一站是什么。"
+            elif theme == "dark_water":
+                polished.tiny_action = f"用 5 分钟给「{anchor_phrase}」找一个上岸动作：看见三个真实物件，再做一件让身体安定的小事。"
+            elif theme == "library_signal":
+                polished.tiny_action = f"用 5 分钟把「{anchor_phrase}」变成现实便签：今天我可以靠近哪一个安定来源？"
+            elif theme == "message_loss":
+                polished.tiny_action = f"用 5 分钟给「{anchor_phrase}」写一句不发送的话，然后把手机放下。"
+            else:
+                polished.tiny_action = f"用 5 分钟写下：今天和「{anchors[0]}」有关的第一小步是什么？"
         else:
-            polished.tiny_action = f"Spend five minutes writing the first small step connected to the {anchors[0]}."
-    if not polished.caring_note.strip():
+            if theme == "lost_home":
+                polished.tiny_action = f"Spend five minutes adding a small route marker for {anchor_phrase}: what I seek, where I can ask, and the next stop."
+            elif theme == "dark_water":
+                polished.tiny_action = f"Spend five minutes finding a shore action for {anchor_phrase}: name three real objects, then do one grounding thing."
+            elif theme == "library_signal":
+                polished.tiny_action = f"Spend five minutes turning {anchor_phrase} into a real note: which steady source can I move closer to today?"
+            elif theme == "message_loss":
+                polished.tiny_action = f"Spend five minutes writing one unsent sentence for {anchor_phrase}, then put the phone down."
+            else:
+                polished.tiny_action = f"Spend five minutes writing the first small step connected to the {anchors[0]}."
+    emotion_caring_note = _emotion_led_caring_note(intake, answers, language)
+    if emotion_caring_note:
+        polished.caring_note = emotion_caring_note
+    elif not polished.caring_note.strip():
         polished.caring_note = (
             "你不需要一醒来就解决整个梦，先把一个细节照亮就很好。"
             if _is_zh(language)
@@ -1509,6 +2167,29 @@ def ask_questions(session: CustomsSession, text_client, force_another: bool = Fa
         )
         return next_session
 
+    existing_count = len(next_session.question_history)
+    if existing_count >= MAX_DREAM_DECOMPOSITION_QUESTIONS:
+        next_session.phase = "ask"
+        next_session.qa_state = build_qa_state(
+            next_session.intake,
+            questions=next_session.question_history,
+            answers=next_session.answer_history,
+            language=language,
+        )
+        next_session.events.append(
+            _event(
+                "assistant",
+                "线索已经足够" if _is_zh(language) else "Enough context gathered",
+                (
+                    "我已经问到 3 个核心问题了；现在更适合生成今日小 Tips，而不是继续追问。"
+                    if _is_zh(language)
+                    else "I have asked three core questions; it is better to generate the Today Tip than keep questioning."
+                ),
+                status="ready",
+            )
+        )
+        return next_session
+
     prompt = (
         followup_question_prompt(next_session.intake, next_session.question_history, next_session.answer_history, language)
         if force_another
@@ -1540,7 +2221,23 @@ def ask_questions(session: CustomsSession, text_client, force_another: bool = Fa
         deduped_questions = [_grounded_followup_question(next_session.intake, language)]
     fresh_questions = deduped_questions
 
-    next_session.question_history.extend(fresh_questions[:3])
+    model_question = fresh_questions[0] if fresh_questions else _grounded_followup_question(next_session.intake, language)
+    focused_question = _decomposition_question(
+        next_session.intake,
+        existing_count,
+        next_session.answers_text(),
+        model_question,
+        language,
+    )
+    visible_question = _compose_decomposition_response(
+        next_session.intake,
+        existing_count,
+        focused_question,
+        next_session.answers_text(),
+        language,
+    )
+    if visible_question not in next_session.question_history:
+        next_session.question_history.append(visible_question)
     next_session.phase = "ask"
     next_session.qa_state = build_qa_state(
         next_session.intake,
@@ -1552,10 +2249,12 @@ def ask_questions(session: CustomsSession, text_client, force_another: bool = Fa
     next_session.events.append(
         _event(
             "assistant",
-            ("梦境助手追问" if len(fresh_questions) == 1 else "梦境助手追问清单")
-            if _is_zh(language)
-            else ("Dream QA question" if len(fresh_questions) == 1 else "Dream QA questions"),
-            "\n".join(fresh_questions[:3]),
+            "梦境助手理解与追问" if _is_zh(language) and existing_count == 0 else (
+                "梦境助手追问" if _is_zh(language) else (
+                    "Dream QA understanding and question" if existing_count == 0 else "Dream QA question"
+                )
+            ),
+            visible_question,
             meta=str(negotiation.get("visitor_name", "")),
             status="question",
         )

dream_customs/prompts.py

@@ -51,12 +51,21 @@ def today_tip_prompt(state: DreamQAState, language: str = "en") -> str:
     return f"""
 You are MiniCPM5-1B writing the final Dream QA result.
 Write a non-diagnostic interpretation draft and exactly one primary Today Tip / 今日小 Tips.
+First answer the user's stated question directly. If the user sounds scared, sad,
+overwhelmed, guilty, lonely, or asks for comfort, follow that emotion before giving any action.
+The interpretation must be step-by-step: use 2 to 4 short layers that move from
+the user's feeling, to concrete dream anchors, to the 1-3 follow-up answers, to one gentle way to care for today.
+Do not collapse every dream into productivity advice such as opening a task,
+writing a first line, or making the first step smaller.
 Use non-certain language such as "也许", "可以把它当作", "maybe", or "for today, try".
-The today_tip must cite at least one concrete dream anchor.
+The today_tip and tiny_action must cite at least one concrete dream anchor and must change with the user's story,
+visual evidence, and follow-up answers. Do not reuse stock exercises such as "write two lines" unless the user's
+own dream or answer makes that exact action feel specific.
 Avoid prophecy, frightening certainty, medical advice, therapy framing, and generic wellness filler.
-Keep the whole result short, warm, and specific to the user's answer.
-The tiny_action must be a 5-minute first step, not a command to solve the whole problem.
+Keep the whole result short, warm, emotionally responsive, and specific to the user's answer.
+The tiny_action must be a 5-minute self-check or small care step, not a command to solve the whole problem.
 Avoid demanding phrases such as "immediately", "must", "fix it", or "solve it".
+If the user asks for comfort, caring_note should be warm, specific, and validating.
 Use safety_note only for self-harm, harm to others, severe distress, severe insomnia, panic, or inability to function.
 {_language_instruction(language)}
 
@@ -169,6 +178,8 @@ def negotiation_prompt(intake: DreamIntake, language: str = "en") -> str:
     return f"""
 You are the Dream QA question guide. The user is not asking for diagnosis.
 Help the user record the dream, clarify the main question, and answer one gentle follow-up before the final 今日小 Tips.
+Use a gentle grill-me style: first reflect what you understood, then ask the single question that would most improve
+the final advice. Dream QA can ask at most 3 decomposition questions total, so every question must earn its place.
 The tone should be warm, plain, and specific. Do not make medical claims.
 Ask questions that an ordinary person can understand without knowing any app lore.
 Prefer questions about the strongest feeling, one confusing scene, or one safe next-day reference.
@@ -195,6 +206,8 @@ def followup_question_prompt(
     return f"""
 You are the Dream QA question guide. Ask one more gentle follow-up question.
 Do not diagnose. Do not repeat previous questions.
+Treat this as one of at most 3 decomposition rounds. Ask only the missing piece that would make the final Today Tip
+more personal: feeling, concrete image, or what kind of support the user wants today.
 The question must be plain and useful: ask what the user wants to understand, what feeling was strongest,
 or whether one concrete dream detail connects to today.
 Do not use unclear metaphors about fate, symbols, hidden meanings, stamps, release, or permits.

tests/test_pipeline.py

@@ -178,6 +178,73 @@ def test_generate_today_tip_keeps_answer_history_and_removes_placeholder_text():
     assert "does not indicate any real-life concerns" not in combined
 
 
+def test_generate_today_tip_follows_user_question_and_comfort_need_in_chinese():
+    intake = build_intake(
+        dream_text="我梦到自己掉进海里，醒来很害怕。我想知道这是不是说明我快撑不住了？",
+        mood="害怕",
+    )
+
+    card = generate_today_tip(intake, "我最近工作压力很大，真的很想被安慰一下。", FakeTextClient(), language="zh")
+    combined = "\n".join(
+        [
+            card.main_question,
+            card.interpretation,
+            card.today_tip,
+            card.tiny_action,
+            card.caring_note,
+        ]
+    )
+
+    assert "撑不住" in card.main_question
+    assert "海" in combined
+    assert "压力" in combined or "害怕" in combined
+    assert "第一层" in card.interpretation and "第二层" in card.interpretation
+    assert "太脆弱" in card.caring_note
+    assert "电梯" not in combined
+    assert "只打开那件事" not in combined
+
+
+def test_generate_today_tip_answers_sad_relationship_question_without_productivity_template():
+    intake = build_intake(
+        dream_text="我梦到前任发消息又消失了，我醒来很难过，想知道是不是我还没走出来。",
+        mood="难过",
+    )
+
+    card = generate_today_tip(intake, "我不想要鸡汤，只想知道为什么这么难受。", FakeTextClient(), language="zh")
+    combined = "\n".join([card.main_question, card.interpretation, card.today_tip, card.caring_note])
+
+    assert "为什么这么难受" in card.main_question or "没走出来" in card.main_question
+    assert "难受" in combined or "难过" in combined
+    assert "消息" in combined
+    assert "第一句话" not in combined
+    assert "打开任务" not in combined
+
+
+def test_generate_today_tip_keeps_english_emotional_question_from_becoming_task_advice():
+    intake = build_intake(
+        dream_text="I dreamed I was drowning in dark water and woke scared. Does this mean I am not coping?",
+        mood="scared",
+    )
+
+    card = generate_today_tip(intake, "I need comfort, not productivity advice.", FakeTextClient(), language="en")
+    combined = "\n".join(
+        [
+            card.main_question,
+            card.interpretation,
+            card.today_tip,
+            card.tiny_action,
+            card.caring_note,
+        ]
+    ).lower()
+
+    assert "not coping" in card.main_question.lower()
+    assert "water" in combined
+    assert "first" in card.interpretation.lower() and "second" in card.interpretation.lower()
+    assert "not weak" in combined or "comforted" in combined
+    assert "open the task" not in combined
+    assert "first line" not in combined
+
+
 def test_generate_today_tip_adds_safety_note_for_repeated_insomnia_without_self_harm():
     intake = build_intake(
         dream_text="我昨晚反复梦见自己在一条漆黑的走廊里走，醒来后心跳很快，已经连续3晚都睡不好。",
@@ -346,13 +413,21 @@ def test_ask_answer_skip_draft_revise_and_seal_actions():
     )
     session = ask_questions(session, FakeTextClient())
     assert session.phase == "ask"
-    assert len(session.question_history) == 3
+    assert len(session.question_history) == 1
+    assert "three layers" in session.question_history[0]
 
     session = answer_question(session, "I want one small start.")
     assert session.answer_history[-1] == "I want one small start."
 
     session = ask_questions(session, FakeTextClient(), force_another=True)
-    assert len(session.question_history) == 4
+    assert len(session.question_history) == 2
+    assert "For this round" in session.question_history[-1]
+
+    session = ask_questions(session, FakeTextClient(), force_another=True)
+    assert len(session.question_history) == 3
+
+    session = ask_questions(session, FakeTextClient(), force_another=True)
+    assert len(session.question_history) == 3
 
     session = skip_question(session)
     assert "skip" in session.answer_history[-1].lower()
@@ -536,6 +611,89 @@ def test_visual_witness_clues_drive_questions_and_today_tip():
     assert "objects" not in combined
 
 
+def test_zh_text_and_image_keep_user_question_while_using_visual_anchors():
+    class SeaDreamVision:
+        def extract_witness(self, image_path):
+            return VisionWitness(
+                scene_summary=(
+                    "A simple sketch of a person standing on wavy lines under a crescent moon, "
+                    "with the text 'dark sea dream' above."
+                ),
+                objects=["stick figure", "wavy lines representing water", "crescent moon"],
+                visible_text=["dark sea dream"],
+                mood_cues=["small figure in a large dark place"],
+            )
+
+        def extract_clues(self, image_path):
+            return ["flat fallback should not win"]
+
+    session = add_evidence(
+        create_session(language="zh"),
+        dream_text="我醒来很害怕，这张草图是梦里最清楚的画面。我想知道为什么它让我这么慌。",
+        image_path="sea.png",
+        mood="害怕",
+        vision_client=SeaDreamVision(),
+        asr_client=FakeASRClient(),
+        language="zh",
+    )
+    card = generate_today_tip(session.intake, "", FakeTextClient(), language="zh")
+    combined = "\n".join([card.main_question, ",".join(card.dream_anchors), card.interpretation, card.today_tip])
+
+    assert "为什么它让我这么慌？" in card.main_question
+    assert any(anchor in card.dream_anchors for anchor in ["夜晚的海", "海浪", "月牙", "漆黑的海"])
+    assert "blue hallway" not in combined
+    assert "a simple sketch" not in combined.lower()
+    assert "dreamlike representation" not in combined.lower()
+    assert "这么难受不是你反应过度" in card.interpretation
+
+
+def test_zh_first_response_and_tip_follow_story_and_image_not_template():
+    class LostChildVision:
+        def extract_witness(self, image_path):
+            return VisionWitness(
+                scene_summary="A child figure stands inside a subway station with arrows pointing toward HOME.",
+                objects=["child figure", "subway station", "arrows"],
+                visible_text=["HOME"],
+                mood_cues=["lost", "small figure in a large station"],
+            )
+
+        def extract_clues(self, image_path):
+            return ["flat fallback should not win"]
+
+    session = add_evidence(
+        create_session(language="zh"),
+        dream_text="我梦见一个小孩在地铁站找不到家，我醒来很害怕，想知道为什么这个画面让我这么难受。",
+        image_path="lost-child.png",
+        mood="害怕",
+        vision_client=LostChildVision(),
+        asr_client=FakeASRClient(),
+        language="zh",
+    )
+    session = ask_questions(session, FakeTextClient(), language="zh")
+    first_response = session.question_history[0]
+
+    assert "我先听到的是" in first_response
+    assert "三层" in first_response
+    assert "小孩" in first_response
+    assert "回家" in first_response or "地铁" in first_response
+
+    session = answer_question(session, "更像我自己最近不知道该往哪里走，也很想有人带一下。", language="zh")
+    card = generate_today_tip(
+        session.intake,
+        session.answers_text(),
+        FakeTextClient(),
+        language="zh",
+        followup_questions=session.question_history,
+    )
+    combined = "\n".join([card.interpretation, card.today_tip, card.tiny_action, card.caring_note])
+
+    assert "小孩" in combined
+    assert "回家" in combined or "地铁" in combined or "路标" in combined
+    assert "需要被带路" in card.today_tip or "路标" in card.today_tip
+    assert "写两行" not in combined
+    assert "当作害怕的形状" not in combined
+
+
 def test_witness_failure_keeps_text_path_alive():
     class BrokenWitnessVision:
         def extract_witness(self, image_path):