Route mic recording through MiMo ASR

app.py

@@ -1,14 +1,52 @@
+import asyncio
 import os
+import tempfile
 
 from gradio.routes import App
 from fastapi import Request
 from fastapi.responses import JSONResponse, RedirectResponse
 
 from dream_customs import zerogpu  # noqa: F401
+from dream_customs.app_logic import _client_settings
+from dream_customs.models import HostedASRClient
 from dream_customs.runtime_env import auto_load_runtime_env_json
 from dream_customs.ui.app import build_demo
 
 
+LOCAL_GRADIO_PORT = 7862
+HF_SPACE_GRADIO_PORT = 7860
+BROWSER_ASR_TIMEOUT_SECONDS = 150.0
+
+
+def _default_server_port() -> int:
+    configured_port = os.getenv("GRADIO_SERVER_PORT", "").strip()
+    if configured_port:
+        return int(configured_port)
+    if os.getenv("SPACE_ID", "").strip() or os.getenv("SPACE_HOST", "").strip():
+        return int(os.getenv("PORT", str(HF_SPACE_GRADIO_PORT)))
+    return LOCAL_GRADIO_PORT
+
+
+def _browser_asr_timeout_seconds() -> float:
+    value = os.getenv("DREAM_CUSTOMS_BROWSER_ASR_TIMEOUT_SECONDS", "").strip()
+    if not value:
+        return BROWSER_ASR_TIMEOUT_SECONDS
+    try:
+        return max(10.0, float(value))
+    except ValueError:
+        return BROWSER_ASR_TIMEOUT_SECONDS
+
+
+def _browser_asr_client() -> HostedASRClient:
+    resolved = _client_settings(asr_timeout_seconds=_browser_asr_timeout_seconds())
+    return HostedASRClient(
+        endpoint=resolved["asr_endpoint"],
+        token=resolved["hosted_token"],
+        timeout=resolved["asr_timeout_seconds"],
+        fallback_enabled=False,
+    )
+
+
 auto_load_runtime_env_json()
 demo = build_demo()
 
@@ -19,6 +57,58 @@ _ORIGINAL_CREATE_APP = App.create_app
 def _install_gradio_api_aliases(app, blocks) -> None:
     existing_paths = {getattr(route, "path", "") for route in app.routes}
 
+    if "/dream-asr" not in existing_paths:
+        @app.post("/dream-asr", include_in_schema=False)
+        async def dream_asr(request: Request) -> JSONResponse:
+            """Transcribe a browser-recorded voice note through the server-side ASR client."""
+
+            form = await request.form()
+            upload = form.get("audio")
+            if upload is None or not hasattr(upload, "read"):
+                return JSONResponse(
+                    {"status": "error", "transcript": "", "error": "Missing audio."},
+                    status_code=400,
+                )
+
+            filename = str(getattr(upload, "filename", "") or "dream-voice.webm")
+            suffix = os.path.splitext(filename)[1] or ".webm"
+            temp_path = ""
+            asr_client = None
+            try:
+                audio_bytes = await upload.read()
+                if not audio_bytes:
+                    return JSONResponse(
+                        {"status": "error", "transcript": "", "error": "Empty audio."},
+                        status_code=400,
+                    )
+                with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as temp_file:
+                    temp_file.write(audio_bytes)
+                    temp_path = temp_file.name
+                asr_client = _browser_asr_client()
+                transcript = await asyncio.to_thread(asr_client.transcribe, temp_path)
+            finally:
+                if temp_path:
+                    try:
+                        os.unlink(temp_path)
+                    except OSError:
+                        pass
+
+            if not transcript:
+                return JSONResponse(
+                    {
+                        "status": "error",
+                        "transcript": "",
+                        "error": (
+                            asr_client.last_error
+                            if asr_client is not None
+                            else "MiMo ASR client could not be initialized."
+                        )
+                        or "No transcript returned.",
+                    },
+                    status_code=502,
+                )
+            return JSONResponse({"status": "ok", "transcript": transcript})
+
     if "/gradio_api/info" not in existing_paths:
         @app.get("/gradio_api/info", include_in_schema=False)
         async def gradio_api_info_alias() -> JSONResponse:
@@ -60,7 +150,7 @@ _install_gradio_api_aliases(demo.app, demo)
 if __name__ == "__main__":
     demo.launch(
         server_name=os.getenv("GRADIO_SERVER_NAME", "0.0.0.0"),
-        server_port=int(os.getenv("GRADIO_SERVER_PORT", "7860")),
+        server_port=_default_server_port(),
         show_api=False,
         show_error=True,
     )

docs/local-space-mirror.md

@@ -10,6 +10,8 @@ The mirror does not copy the app into a second implementation. It imports the sa
 .venv/bin/python scripts/local_space_mirror.py
 ```
 
+By default, the wrapper keeps the local review app on port `7862`. If an older Dream QA app from this repository is already listening on that port, it stops that process before launching the current code. Use `--no-replace` to leave the old listener untouched.
+
 Open:
 
 ```text

dream_customs/app_logic.py

@@ -37,7 +37,7 @@ DEFAULT_TEXT_MODEL = "hf.co/openbmb/MiniCPM5-1B-GGUF:Q8_0"
 DEFAULT_VISION_MODEL = "openbmb/minicpm-v4.6"
 DEFAULT_HOSTED_TIMEOUT_SECONDS = 60.0
 DEFAULT_ASR_TIMEOUT_SECONDS = 45.0
-DEFAULT_TEXT_TEMPERATURE = 0.2
+DEFAULT_TEXT_TEMPERATURE = 0.0
 DEFAULT_VISION_TEMPERATURE = 0.1
 DEFAULT_TEXT_MAX_TOKENS = 780
 DEFAULT_VISION_MAX_TOKENS = 320

dream_customs/models.py

@@ -194,7 +194,14 @@ def _extract_json_object(text: str) -> Optional[Dict[str, Any]]:
 
 def _as_string_list(value: Any) -> List[str]:
     if isinstance(value, list):
-        return [str(item).strip() for item in value if str(item).strip()]
+        items = []
+        for item in value:
+            if isinstance(item, dict):
+                item = item.get("question") or item.get("text") or item.get("content") or item.get("label") or ""
+            text = str(item).strip()
+            if text:
+                items.append(text)
+        return items
     if isinstance(value, str) and value.strip():
         return [part.strip() for part in re.split(r"[,，\n]", value) if part.strip()]
     return []
@@ -310,7 +317,7 @@ class OllamaTextClient:
         model_name: str = "hf.co/openbmb/MiniCPM5-1B-GGUF:Q8_0",
         base_url: str = "http://localhost:11434",
         timeout: float = 45.0,
-        temperature: float = 0.2,
+        temperature: float = 0.0,
         max_tokens: int = 700,
         fallback: Optional[FakeTextClient] = None,
     ):
@@ -618,7 +625,7 @@ class HostedMiniCPMTextClient:
         endpoint: str = "",
         token: str = "",
         timeout: float = 60.0,
-        temperature: float = 0.2,
+        temperature: float = 0.0,
         max_tokens: int = 780,
         fallback: Optional[FakeTextClient] = None,
     ):
@@ -870,21 +877,32 @@ class HostedASRClient:
         token: str = "",
         timeout: float = 45.0,
         fallback: Optional[FakeASRClient] = None,
+        fallback_enabled: bool = True,
     ):
         self.endpoint = endpoint.strip()
         self.token = token.strip()
         self.timeout = timeout
         self.fallback = fallback or FakeASRClient()
+        self.fallback_enabled = fallback_enabled
+        self.last_error = ""
+
+    def _fallback_transcript(self, audio_path: Optional[str]) -> str:
+        if not self.fallback_enabled:
+            return ""
+        return self.fallback.transcribe(audio_path)
 
     def transcribe(self, audio_path: Optional[str]) -> str:
+        self.last_error = ""
         if not audio_path:
             return ""
         if not self.endpoint:
-            return self.fallback.transcribe(audio_path)
+            self.last_error = "Missing ASR endpoint."
+            return self._fallback_transcript(audio_path)
         try:
             with open(audio_path, "rb") as audio_file:
                 audio_b64 = base64.b64encode(audio_file.read()).decode("ascii")
-        except OSError:
+        except OSError as exc:
+            self.last_error = f"{exc.__class__.__name__}: {exc}"
             return ""
         payload = {
             "audio": audio_b64,
@@ -902,6 +920,12 @@ class HostedASRClient:
         try:
             with urllib.request.urlopen(request, timeout=self.timeout) as response:
                 payload = json.loads(response.read().decode("utf-8"))
-        except (OSError, TimeoutError, urllib.error.URLError, json.JSONDecodeError):
-            return self.fallback.transcribe(audio_path)
-        return _hosted_transcript_from_response(payload) or self.fallback.transcribe(audio_path)
+        except (OSError, TimeoutError, urllib.error.URLError, json.JSONDecodeError) as exc:
+            self.last_error = f"{exc.__class__.__name__}: {exc}"
+            return self._fallback_transcript(audio_path)
+        transcript = _hosted_transcript_from_response(payload)
+        if transcript:
+            return transcript
+        error = payload.get("error") if isinstance(payload, dict) else ""
+        self.last_error = str(error or "No transcript returned.").strip()
+        return self._fallback_transcript(audio_path)

dream_customs/pipeline.py

@@ -178,6 +178,23 @@ _ZH_ANCHOR_MARKERS = [
     "楼顶",
     "办公楼",
     "高的办公楼",
+    "公司午觉",
+    "公司午休",
+    "公司",
+    "办公室",
+    "上班",
+    "午觉",
+    "午休",
+    "被人泼了一盆水",
+    "被人泼水",
+    "被泼了一盆水",
+    "被泼水",
+    "往脸上浇了一盆水",
+    "浇了一盆水",
+    "泼了一盆水",
+    "一盆水",
+    "盆水",
+    "泼水",
     "漆黑的走廊",
     "漆黑走廊",
     "黑暗走廊",
@@ -297,6 +314,23 @@ _ZH_TO_EN_PHRASES = {
     "楼顶": "rooftop",
     "办公楼": "office building",
     "高的办公楼": "tall office building",
+    "公司午觉": "office nap",
+    "公司午休": "office lunch-break nap",
+    "公司": "company office",
+    "办公室": "office",
+    "上班": "being at work",
+    "午觉": "nap",
+    "午休": "lunch break",
+    "被人泼了一盆水": "someone pouring a basin of water",
+    "被人泼水": "someone splashing water",
+    "被泼了一盆水": "being splashed with a basin of water",
+    "被泼水": "being splashed with water",
+    "往脸上浇了一盆水": "water poured onto the face",
+    "浇了一盆水": "a basin of water being poured",
+    "泼了一盆水": "a basin of water being splashed",
+    "一盆水": "a basin of water",
+    "盆水": "basin of water",
+    "泼水": "splashing water",
     "漆黑的走廊": "dark hallway",
     "漆黑走廊": "dark hallway",
     "黑暗走廊": "dark hallway",
@@ -486,6 +520,8 @@ def _extract_dream_anchors(intake: DreamIntake) -> List[str]:
     candidates: List[str] = []
     visual_candidates = _visual_anchor_candidates(intake)
     candidates.extend(visual_candidates[:3])
+    if re.search(r"公司|办公室|上班", raw_text) and re.search(r"午觉|午休", raw_text) and re.search(r"泼|浇|水", raw_text):
+        candidates.extend(["公司", "午觉", "被人泼水"])
     if "elevator" in text:
         candidates.append("elevator")
     if re.search(r"\bfloor\s*14\b|\b14\b", text):
@@ -697,7 +733,7 @@ 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"]):
+    if _contains_any(text, ["海", "海浪", "月牙", "moon", "sea", "wave", "dark sea", "dark water", "漆黑的海"]):
         return "dark_water"
     if _contains_any(text, ["电梯", "按钮", "14", "elevator", "button", "floor"]):
         return "stuck_elevator"
@@ -754,6 +790,8 @@ def _story_anchor_phrase(intake: DreamIntake, anchors: List[str], language: str
     theme = _dream_theme(intake, answers)
     if theme == "stuck_elevator":
         return _stuck_elevator_anchor_phrase(intake, anchors, language, answers)
+    if anchors:
+        return _join_anchors(anchors, language)
     if _is_zh(language):
         themed = {
             "lost_home": "地铁站里迷路的小孩和回家的方向",
@@ -1169,13 +1207,16 @@ def _main_question_from_intake(intake: DreamIntake, language: str = "en") -> str
 def _fallback_interpretation(intake: DreamIntake, language: str = "en") -> str:
     primary = _primary_anchor(intake, language)
     secondary = _secondary_anchor(intake, language)
+    anchors = _anchors_for_language(intake, language)
+    story_anchor = _story_anchor_phrase(intake, anchors, language) if anchors else primary
     if not _is_zh(language):
         return (
-            f"Maybe this dream is not giving you a fixed answer. It is placing {_anchor_with_article(primary)} "
-            f"beside {_anchor_with_article(secondary)} so you can notice one small stuck point today."
+            "Maybe this dream is not giving you a fixed answer. "
+            f"It is placing {_anchor_with_article(story_anchor)} near {_anchor_with_article(secondary)} "
+            "so you can notice one small stuck point today."
         )
     return (
-        f"也许这个梦不是在给你一个确定答案，而是把「{primary}」和「{secondary}」放到一起，"
+        f"也许这个梦不是在给你一个确定答案，而是把「{story_anchor}」这组线索放在一起，"
         "提醒你先看见今天最卡住的一小处。"
     )
 
@@ -1368,7 +1409,7 @@ def _grounded_today_tip(intake: DreamIntake, language: str = "en") -> str:
         )
     return _numbered_suggestions(
         [
-            f"把「{primary}」当成现实生活的线索，不当成梦里给你的命令。",
+            f"把「{anchor}」当成现实生活的线索，不当成梦里给你的命令。",
             "说出它像今天哪件普通小事，再选一个真的能做的小动作。",
         ],
         language,
@@ -2038,6 +2079,82 @@ def build_qa_state(
     )
 
 
+def _has_unsupported_clinical_frame(text: str) -> bool:
+    clean = (text or "").lower()
+    markers = [
+        "睡眠剥夺",
+        "睡眠障碍",
+        "睡眠问题",
+        "压力过大",
+        "压力过载",
+        "压力信号",
+        "持续焦虑",
+        "焦虑症",
+        "寻求专业帮助",
+        "专业帮助",
+        "专业支持",
+        "心理咨询",
+        "心理治疗",
+        "医疗建议",
+        "临床",
+        "诊断",
+        "病理",
+        "创伤证据",
+        "sleep deprivation",
+        "sleep disorder",
+        "sleep problem",
+        "pressure overload",
+        "professional help",
+        "professional support",
+        "medical advice",
+        "clinical",
+        "diagnosis",
+        "therapy",
+        "pathology",
+        "trauma evidence",
+    ]
+    return any(marker in clean for marker in markers)
+
+
+def _has_unsupported_emotion_or_generic_wellness(text: str, intake: DreamIntake, answers: str = "") -> bool:
+    clean = (text or "").lower()
+    if not clean:
+        return False
+    source = _story_text(intake, answers)
+    unsupported_without_source = [
+        (["工作压力", "压力"], ["压力", "焦虑", "stress", "stressed", "pressure", "overwhelmed"]),
+        (["害怕", "恐惧", "scared", "afraid"], ["害怕", "怕", "恐惧", "scared", "afraid"]),
+        (["孤独", "lonely"], ["孤独", "lonely"]),
+        (["焦虑", "anxious"], ["焦虑", "anxious"]),
+        (["自责", "guilt", "guilty"], ["自责", "内疚", "guilt", "guilty"]),
+    ]
+    for output_markers, source_markers in unsupported_without_source:
+        if any(marker in clean for marker in output_markers) and not any(marker in source for marker in source_markers):
+            return True
+    generic_markers = [
+        "保持积极",
+        "积极心态",
+        "明天会更好",
+        "喝一杯温水",
+        "一杯温水",
+        "温水",
+        "轻松的音乐",
+        "relaxing music",
+        "stay positive",
+        "positive mindset",
+        "tomorrow will be better",
+        "warm water",
+    ]
+    return any(marker in clean for marker in generic_markers)
+
+
+def _nonclinical_caring_note(anchors: List[str], language: str = "en") -> str:
+    anchor = anchors[0] if anchors else ("梦里的这个细节" if _is_zh(language) else "this dream detail")
+    if _is_zh(language):
+        return f"这个梦被你记下来已经够了；今天先把「{anchor}」当作一个需要被温柔看见的细节。"
+    return f"Writing this dream down is already enough; today, let {anchor} be one detail you meet gently."
+
+
 def _polish_today_tip(card: TodayTipCard, intake: DreamIntake, answers: str = "", language: str = "en") -> TodayTipCard:
     polished = card.model_copy(deep=True)
     answer_lines = [line.strip() for line in (answers or "").splitlines() if line.strip()]
@@ -2209,7 +2326,25 @@ def _polish_today_tip(card: TodayTipCard, intake: DreamIntake, answers: str = ""
     elif _is_zh(language) and "所有楼层" in polished.caring_note:
         polished.caring_note = "你不需要一醒来就解释完整个梦；先照顾一个细节和一个很小的下一步就好。"
     merged = "\n".join([intake.merged_text(), answers or ""])
-    polished.safety_note = safety_note(language) if needs_escalation(merged) else ""
+    has_escalation = needs_escalation(merged)
+    if not has_escalation:
+        if _has_unsupported_clinical_frame(polished.interpretation) or _has_unsupported_emotion_or_generic_wellness(
+            polished.interpretation, intake, answers
+        ):
+            polished.interpretation = _fallback_interpretation(intake, language)
+        if _has_unsupported_clinical_frame(polished.today_tip) or _has_unsupported_emotion_or_generic_wellness(
+            polished.today_tip, intake, answers
+        ):
+            polished.today_tip = _grounded_today_tip(intake, language)
+        if _has_unsupported_clinical_frame(polished.tiny_action) or _has_unsupported_emotion_or_generic_wellness(
+            polished.tiny_action, intake, answers
+        ):
+            polished.tiny_action = _weird_little_action(intake, answers, anchors, language)
+        if _has_unsupported_clinical_frame(polished.caring_note) or _has_unsupported_emotion_or_generic_wellness(
+            polished.caring_note, intake, answers
+        ):
+            polished.caring_note = _nonclinical_caring_note(anchors, language)
+    polished.safety_note = safety_note(language) if has_escalation else ""
     if not _is_zh(language):
         polished = _clean_english_today_tip_language(polished)
     return polished

dream_customs/prompts.py

@@ -33,6 +33,10 @@ You are MiniCPM5-1B acting as Dream QA / 梦境问答台, a gentle question guid
 Summarize the dream, infer the user's main question if they did not write one, and ask 1 to 3 warm follow-up questions.
 Do not diagnose, predict fate, frighten the user, or claim one fixed dream meaning.
 Ground every question in a concrete detail from the text, voice transcript, mood, or visual clues.
+Use the Dream intake as the source of truth. Do not add scenes, characters, places, objects, times of day, or emotions
+that are not explicitly present. If the intake is short or has only one detail, ask a clarifying question instead of
+expanding it into a richer scene. For example, do not turn "water" into sea, waves, moonlight, or a person unless those
+details appear in the intake.
 {_language_instruction(language)}
 
 Dream intake:
@@ -67,7 +71,14 @@ use real-world physics or an ordinary physical object, and create one strange, p
 the user can actually do in 1 to 5 minutes while awake. It should feel random and fresh, not like a stock
 self-check, journaling prompt, breathing exercise, or generic productivity hack.
 The today_tip and tiny_action must change with the user's story, visual evidence, and follow-up answers.
+Use only dream facts present in the Dream QA state. Do not add scenes, people, places, objects, or time cues that are
+not in dream_summary, dream_anchors, followup_questions, or user_answers. If an anchor is minimal, keep it minimal.
 Avoid prophecy, frightening certainty, medical advice, therapy framing, and generic wellness filler.
+Do not call an ordinary dream a sign of sleep deprivation, a sleep problem, pressure overload, trauma evidence,
+or a reason to seek professional help unless the user explicitly reports severe insomnia, severe distress, panic,
+self-harm, harm to others, or inability to function.
+Do not infer work stress, fear, loneliness, anxiety, guilt, or self-blame unless the user actually says that feeling.
+Avoid generic wellness filler such as warm water, relaxing music, positive mindset, or "tomorrow will be better".
 Keep the whole result short, warm, emotionally responsive, and specific to the user's answer.
 The weird little thing must be harmless, legal, low-cost, non-embarrassing, and not a command to solve the whole problem.
 Avoid demanding phrases such as "immediately", "must", "fix it", or "solve it".
@@ -191,6 +202,8 @@ Ask questions that an ordinary person can understand without knowing any app lor
 Prefer questions about the strongest feeling, one confusing scene, or one safe next-day reference.
 Ground every question in a concrete detail from the intake when possible, such as an object,
 place, action, color, or phrase the user actually provided.
+Never invent supporting scenery around a short anchor. If the user says water, ask about water; do not make it sea,
+waves, moonlight, or a small figure unless those words came from text, voice, or visual clues.
 {_language_instruction(language)}
 
 Dream intake:
@@ -198,7 +211,7 @@ Dream intake:
 
 Return JSON with:
 - visitor_name: short vivid anchor label
-- questions: 1 to 3 gentle, specific, easy-to-understand questions
+- questions: 1 to 3 gentle, specific, easy-to-understand questions as plain strings, not objects
 - tone_note: one sentence explaining why the questions may help without certainty
 """.strip()
 
@@ -219,6 +232,8 @@ or whether one concrete dream detail connects to today.
 Do not use unclear metaphors about fate, symbols, hidden meanings, stamps, release, or permits.
 Reuse one concrete dream detail from the intake so the user can feel the question belongs
 to this dream rather than to a generic reflection form.
+Use only details explicitly present in the intake, previous questions, or user answers. Do not expand one word into a
+larger imagined scene; if context is missing, ask for the missing context.
 {_language_instruction(language)}
 
 Dream intake:
@@ -232,7 +247,7 @@ User answers:
 
 Return JSON with:
 - visitor_name: short vivid name
-- questions: one gentle, specific question in a single-item list
+- questions: one gentle, specific question in a single-item list of plain strings, not objects
 - tone_note: one sentence explaining why this question matters today
 """.strip()
 

dream_customs/ui/app.py

@@ -89,13 +89,18 @@ VOICE_JS = r"""
     button.dataset.bound = "true";
 
     const messageFor = (key, fallback) => button.dataset[key] || fallback;
-    let checkingTimer = null;
+    let mediaRecorder = null;
+    let mediaStream = null;
+    let chunks = [];
+    let audioContext = null;
+    let silenceTimer = null;
+    let maxTimer = null;
+    let wakingTimer = null;
+    let requestTimer = null;
+    let heardVoice = false;
+    let lastVoiceAt = 0;
 
     const setStatus = (message, mode) => {
-      if (mode !== "listening" && checkingTimer) {
-        window.clearTimeout(checkingTimer);
-        checkingTimer = null;
-      }
       if (status) {
         status.textContent = message;
         status.dataset.mode = mode || "";
@@ -109,84 +114,172 @@ VOICE_JS = r"""
       if (!transcript) {
         return;
       }
-      const spacer = textarea.value.trim() ? "\n" : "";
-      textarea.value = `${textarea.value}${spacer}${transcript}`;
-      textarea.dispatchEvent(new InputEvent("input", { bubbles: true, inputType: "insertText", data: transcript }));
-      textarea.dispatchEvent(new Event("change", { bubbles: true }));
-      textarea.focus();
+      const prefix = textarea.value.trim() ? "\n" : "";
+      let index = 0;
+      const writeNext = () => {
+        const next = transcript.slice(index, index + 2);
+        textarea.value = `${textarea.value}${next}`;
+        textarea.dispatchEvent(new InputEvent("input", { bubbles: true, inputType: "insertText", data: next }));
+        textarea.dispatchEvent(new Event("change", { bubbles: true }));
+        index += next.length;
+        if (index < transcript.length) {
+          window.setTimeout(writeNext, 24);
+        } else {
+          textarea.focus();
+        }
+      };
+      textarea.value = `${textarea.value}${prefix}`;
+      writeNext();
     };
 
-    button.addEventListener("click", async () => {
-      const Recognition = window.SpeechRecognition || window.webkitSpeechRecognition;
-      if (!Recognition) {
-        setStatus(messageFor("unsupported", "This browser cannot transcribe voice here. You can still type the dream."), "error");
-        textarea.focus();
-        return;
+    const cleanupMedia = () => {
+      if (silenceTimer) {
+        window.clearInterval(silenceTimer);
+        silenceTimer = null;
       }
+      if (maxTimer) {
+        window.clearTimeout(maxTimer);
+        maxTimer = null;
+      }
+      mediaStream?.getTracks().forEach((track) => track.stop());
+      mediaStream = null;
+      if (audioContext && audioContext.state !== "closed") {
+        audioContext.close().catch(() => {});
+      }
+      audioContext = null;
+    };
 
-      setStatus(messageFor("checking", "Checking microphone permission..."), "listening");
-      let latestTranscript = "";
-
-      const recognition = new Recognition();
-      recognition.lang = button.dataset.language === "zh" ? "zh-CN" : "en-US";
-      recognition.interimResults = true;
-      recognition.continuous = false;
-      recognition.maxAlternatives = 1;
-      checkingTimer = window.setTimeout(() => {
-        if (button.dataset.mode === "listening" && !latestTranscript) {
-          setStatus(messageFor("timeout", "Voice is taking too long here. You can keep typing the dream instead."), "error");
-          try {
-            recognition.stop();
-          } catch (_error) {
-            // Best-effort stop for browsers that leave speech recognition pending.
-          }
-          textarea.focus();
-        }
-      }, 3000);
+    const clearRequestTimers = () => {
+      if (wakingTimer) {
+        window.clearTimeout(wakingTimer);
+        wakingTimer = null;
+      }
+      if (requestTimer) {
+        window.clearTimeout(requestTimer);
+        requestTimer = null;
+      }
+    };
 
-      recognition.onstart = () => {
-        if (checkingTimer) {
-          window.clearTimeout(checkingTimer);
-          checkingTimer = null;
-        }
-        setStatus(messageFor("listening", "Listening. Say the dream fragment when you are ready."), "listening");
-      };
+    const chooseMimeType = () => {
+      const candidates = ["audio/webm;codecs=opus", "audio/webm", "audio/mp4", "audio/wav"];
+      return candidates.find((type) => window.MediaRecorder?.isTypeSupported?.(type)) || "";
+    };
 
-      recognition.onresult = (event) => {
-        latestTranscript = Array.from(event.results)
-          .map((result) => result[0]?.transcript || "")
-          .join("")
-          .trim();
-        if (latestTranscript) {
-          setStatus(`Listening: ${latestTranscript}`, "listening");
+    const uploadAudio = async (blob) => {
+      if (!blob || blob.size === 0) {
+        setStatus(messageFor("empty", "No speech detected. Tap again if you want to retry."), "error");
+        return;
+      }
+      setStatus(messageFor("transcribing", "Transcribing with MiMo ASR..."), "transcribing");
+      const form = new FormData();
+      const extension = blob.type.includes("mp4") ? "m4a" : blob.type.includes("wav") ? "wav" : "webm";
+      form.append("audio", blob, `dream-voice.${extension}`);
+      clearRequestTimers();
+      const controller = new AbortController();
+      const asrRequestTimeout = Number(button.dataset.timeoutMs || "140000");
+      wakingTimer = window.setTimeout(() => {
+        setStatus(messageFor("waking", "MiMo ASR is waking on Modal. This first pass can take a moment."), "waking");
+      }, 6000);
+      requestTimer = window.setTimeout(() => {
+        controller.abort();
+      }, asrRequestTimeout);
+      try {
+        const response = await fetch("/dream-asr", { method: "POST", body: form, signal: controller.signal });
+        const payload = await response.json();
+        if (!response.ok || payload.status !== "ok" || !payload.transcript) {
+          throw new Error(payload.error || "No transcript returned.");
         }
-      };
-
-      recognition.onerror = (event) => {
-        if (checkingTimer) {
-          window.clearTimeout(checkingTimer);
-          checkingTimer = null;
+        appendTranscript(payload.transcript);
+        setStatus(messageFor("done", "Added the ASR transcript to the dream note."), "done");
+      } catch (error) {
+        if (error?.name === "AbortError") {
+          setStatus(messageFor("timeout", "MiMo ASR timed out. Tap the mic to try once more."), "error");
+        } else {
+          setStatus(messageFor("error", "Voice transcription failed. You can type this fragment instead."), "error");
         }
-        const message = event.error === "not-allowed"
-          ? messageFor("permission", "Microphone permission was denied. Allow recording and try again.")
-          : messageFor("empty", "I did not catch that. Tap the microphone again if you want to retry.");
-        setStatus(message, "error");
-      };
+      } finally {
+        clearRequestTimers();
+      }
+    };
+
+    const stopRecording = () => {
+      if (mediaRecorder && mediaRecorder.state === "recording") {
+        mediaRecorder.stop();
+      }
+    };
 
-      recognition.onend = () => {
-        if (checkingTimer) {
-          window.clearTimeout(checkingTimer);
-          checkingTimer = null;
+    const watchSilence = (stream) => {
+      const AudioContext = window.AudioContext || window.webkitAudioContext;
+      if (!AudioContext) {
+        return;
+      }
+      audioContext = new AudioContext();
+      const source = audioContext.createMediaStreamSource(stream);
+      const analyser = audioContext.createAnalyser();
+      analyser.fftSize = 1024;
+      source.connect(analyser);
+      const samples = new Uint8Array(analyser.fftSize);
+      const startedAt = Date.now();
+      silenceTimer = window.setInterval(() => {
+        analyser.getByteTimeDomainData(samples);
+        let total = 0;
+        for (const sample of samples) {
+          const value = (sample - 128) / 128;
+          total += value * value;
+        }
+        const rms = Math.sqrt(total / samples.length);
+        const now = Date.now();
+        if (rms > 0.035) {
+          heardVoice = true;
+          lastVoiceAt = now;
         }
-        if (latestTranscript) {
-          appendTranscript(latestTranscript);
-          setStatus(messageFor("done", "Added to the dream note."), "done");
-        } else if (button.dataset.mode === "listening") {
-          setStatus(messageFor("empty", "No speech detected. Tap again if you want to retry."), "idle");
+        if (heardVoice && now - lastVoiceAt > 1300 && now - startedAt > 1200) {
+          stopRecording();
         }
+      }, 180);
+    };
+
+    const startRecording = async () => {
+      if (!navigator.mediaDevices?.getUserMedia || !window.MediaRecorder) {
+        setStatus(messageFor("unsupported", "This browser cannot record audio here. You can still type the dream."), "error");
+        return;
+      }
+      try {
+        mediaStream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      } catch (_error) {
+        setStatus(messageFor("permission", "Microphone permission was not granted. Allow recording and try again."), "error");
+        return;
+      }
+      chunks = [];
+      heardVoice = false;
+      lastVoiceAt = Date.now();
+      const mimeType = chooseMimeType();
+      mediaRecorder = new MediaRecorder(mediaStream, mimeType ? { mimeType } : undefined);
+      mediaRecorder.ondataavailable = (event) => {
+        if (event.data?.size) {
+          chunks.push(event.data);
+        }
+      };
+      mediaRecorder.onstop = () => {
+        cleanupMedia();
+        const type = mediaRecorder?.mimeType || mimeType || "audio/webm";
+        const blob = new Blob(chunks, { type });
+        mediaRecorder = null;
+        uploadAudio(blob);
       };
+      mediaRecorder.start();
+      watchSilence(mediaStream);
+      maxTimer = window.setTimeout(stopRecording, 30000);
+      setStatus(messageFor("recording", "Listening. Tap again to stop, or pause and I will transcribe."), "recording");
+    };
 
-      recognition.start();
+    button.addEventListener("click", () => {
+      if (mediaRecorder?.state === "recording") {
+        stopRecording();
+      } else {
+        clearRequestTimers();
+        startRecording();
+      }
     });
   };
 
@@ -740,14 +833,20 @@ def _mic_html(language: str = DEFAULT_LANGUAGE) -> str:
     type="button"
     class="dc-mic-button"
     aria-label="{escape(copy['mic_idle'])}"
+    aria-expanded="false"
     data-language="{escape(language)}"
-    data-checking="{escape('正在请求麦克风权限...' if language == 'zh' else 'Checking microphone permission...')}"
-    data-timeout="{escape('语音识别等待太久了。你可以先继续手动输入梦境。' if language == 'zh' else 'Voice is taking too long here. You can keep typing the dream instead.')}"
+    data-idle="{escape(copy['mic_idle'])}"
+    data-open="{escape(copy['voice_help'])}"
+    data-recording="{escape(copy['mic_listening'])}"
+    data-transcribing="{escape(copy['mic_transcribing'])}"
+    data-waking="{escape(copy['mic_waking'])}"
     data-unsupported="{escape(copy['mic_unsupported'])}"
     data-permission="{escape(copy['mic_permission'])}"
-    data-listening="{escape(copy['mic_listening'])}"
     data-done="{escape(copy['mic_done'])}"
     data-empty="{escape(copy['mic_empty'])}"
+    data-error="{escape(copy['mic_error'])}"
+    data-timeout="{escape(copy['mic_timeout'])}"
+    data-timeout-ms="140000"
   >
     <span class="dc-mic-glyph" aria-hidden="true"></span>
   </button>

dream_customs/ui/copy.py

@@ -22,14 +22,18 @@ APP_COPY = {
         "notice_error": "Dream QA needs a dream fragment before it can continue.",
         "dream_label": "Dream note",
         "dream_placeholder": "Write the dream while it is still foggy...\nExample: I kept missing an elevator. The button for floor 14 melted like wax.",
-        "mic_idle": "Tap the microphone to dictate",
+        "mic_idle": "Add a voice note",
         "mic_unsupported": "This browser cannot transcribe voice here. You can still type the dream.",
         "mic_permission": "Microphone permission was not granted. Allow recording and try again.",
-        "mic_listening": "Listening. Say the dream fragment when you are ready.",
-        "mic_done": "Added to the dream note.",
+        "mic_listening": "Recording. Tap again to stop, or pause and MiMo ASR will transcribe.",
+        "mic_transcribing": "Transcribing with MiMo ASR...",
+        "mic_waking": "MiMo ASR is waking on Modal. This first pass can take a moment.",
+        "mic_done": "Added the ASR transcript to the dream note.",
         "mic_empty": "No speech detected. Tap again if you want to retry.",
+        "mic_error": "Voice transcription failed. You can type this fragment instead.",
+        "mic_timeout": "MiMo ASR timed out. Tap the mic to try once more.",
         "voice_label": "Voice note",
-        "voice_help": "Record or upload a short voice note. It is transcribed by the ASR adapter when you continue.",
+        "voice_help": "Record or upload a short voice note. It is sent to MiMo ASR when you continue.",
         "field_tip": "The desk looks for three anchors: a place, an object, and the question the dream left behind.",
         "example_button": "elevator",
         "example_button_2": "floor 14",
@@ -93,14 +97,18 @@ APP_COPY = {
         "notice_error": "梦境问答台还没有收到片段。",
         "dream_label": "梦境记录",
         "dream_placeholder": "趁梦还带着雾气，先写下来...\n例如：我一直赶不上电梯，14 楼按钮像蜡一样融化。",
-        "mic_idle": "点击麦克风录音",
+        "mic_idle": "添加语音片段",
         "mic_unsupported": "这个浏览器暂时不能直接转写语音，你仍然可以手动输入梦境。",
         "mic_permission": "没有获得麦克风权限。允许浏览器录音后可以再试一次。",
-        "mic_listening": "正在听。准备好后说出梦境片段。",
-        "mic_done": "已加入梦境记录。",
+        "mic_listening": "正在录音。再次点击可停止，停顿后会交给 MiMo ASR 转写。",
+        "mic_transcribing": "正在用 MiMo ASR 转写...",
+        "mic_waking": "Modal 上的 MiMo ASR 正在唤醒，首次转写可能需要等一下。",
+        "mic_done": "已把 ASR 转写加入梦境记录。",
         "mic_empty": "没有检测到语音。想重试的话，再点一次麦克风。",
+        "mic_error": "语音转写失败。你也可以先手动输入这一段。",
+        "mic_timeout": "MiMo ASR 转写超时了。可以再点一次麦克风重试。",
         "voice_label": "语音片段",
-        "voice_help": "可以录音或上传一小段语音。点击继续后，ASR 适配器会先转写它。",
+        "voice_help": "可以录音或上传一小段语音。点击继续后，会直接发送给 MiMo ASR 转写。",
         "field_tip": "问讯室会优先寻找三个锚点：地点、物件、以及梦醒后留下的问题。",
         "example_button": "电梯",
         "example_button_2": "14 楼",

dream_customs/ui/styles.py

@@ -441,7 +441,9 @@ body,
   transform: translateY(-1px);
 }
 
-.dc-mic-button[data-mode="listening"] {
+.dc-mic-button[data-mode="recording"],
+.dc-mic-button[data-mode="transcribing"],
+.dc-mic-button[data-mode="waking"] {
   animation: dc-mic-pulse 1.2s ease-in-out infinite;
   background: var(--dc-teal) !important;
 }
@@ -476,12 +478,18 @@ body,
   width: 2px;
 }
 
-.dc-mic-button[data-mode="listening"] .dc-mic-glyph,
-.dc-mic-button[data-mode="listening"] .dc-mic-glyph::before {
+.dc-mic-button[data-mode="recording"] .dc-mic-glyph,
+.dc-mic-button[data-mode="recording"] .dc-mic-glyph::before,
+.dc-mic-button[data-mode="transcribing"] .dc-mic-glyph,
+.dc-mic-button[data-mode="transcribing"] .dc-mic-glyph::before,
+.dc-mic-button[data-mode="waking"] .dc-mic-glyph,
+.dc-mic-button[data-mode="waking"] .dc-mic-glyph::before {
   border-color: #fff9ee;
 }
 
-.dc-mic-button[data-mode="listening"] .dc-mic-glyph::after {
+.dc-mic-button[data-mode="recording"] .dc-mic-glyph::after,
+.dc-mic-button[data-mode="transcribing"] .dc-mic-glyph::after,
+.dc-mic-button[data-mode="waking"] .dc-mic-glyph::after {
   background: #fff9ee;
 }
 
@@ -500,7 +508,9 @@ body,
 }
 
 .dc-mic-control:hover .dc-mic-status,
-.dc-mic-status[data-mode="listening"],
+.dc-mic-status[data-mode="recording"],
+.dc-mic-status[data-mode="transcribing"],
+.dc-mic-status[data-mode="waking"],
 .dc-mic-status[data-mode="error"],
 .dc-mic-status[data-mode="done"] {
   opacity: 1;

modal_backend/contracts.py

@@ -30,11 +30,11 @@ def normalize_text_payload(payload: Dict[str, Any]) -> Dict[str, Any]:
     except (TypeError, ValueError):
         max_tokens = 700
     max_tokens = max(64, min(max_tokens, 1200))
-    temperature = payload.get("temperature", 0.2)
+    temperature = payload.get("temperature", 0.0)
     try:
         temperature = float(temperature)
     except (TypeError, ValueError):
-        temperature = 0.2
+        temperature = 0.0
     temperature = max(0.0, min(temperature, 0.7))
     return {
         "prompt": prompt,

modal_backend/dream_customs_modal.py

@@ -1,6 +1,8 @@
 import io
 import json
 import os
+import subprocess
+import sys
 import tempfile
 from typing import Any, Dict, Optional
 
@@ -20,7 +22,11 @@ from modal_backend.contracts import (
 APP_NAME = "dream-customs-minicpm-backend"
 TEXT_MODEL = "openbmb/MiniCPM5-1B"
 VISION_MODEL = "openbmb/MiniCPM-V-4.6"
-ASR_MODEL = "openai/whisper-tiny"
+ASR_MODEL = "XiaomiMiMo/MiMo-V2.5-ASR"
+ASR_TOKENIZER_MODEL = "XiaomiMiMo/MiMo-Audio-Tokenizer"
+MIMO_ASR_REPO_DIR = "/opt/MiMo-V2.5-ASR"
+MIMO_ASR_NESTED_REPO_DIR = "/opt/MiMo-V2.5-ASR/MiMo-V2.5-ASR"
+MIMO_ASR_RUNTIME_REPO_DIR = "/tmp/MiMo-V2.5-ASR"
 MINUTES = 60
 
 app = modal.App(APP_NAME)
@@ -52,6 +58,34 @@ image = (
     .add_local_dir("modal_backend", remote_path="/root/modal_backend")
 )
 
+asr_image = (
+    modal.Image.from_registry("nvidia/cuda:12.4.1-devel-ubuntu22.04", add_python="3.12")
+    .apt_install("build-essential", "ffmpeg", "git", "ninja-build")
+    .pip_install(
+        "accelerate>=1.9.0",
+        "fastapi[standard]>=0.116.1",
+        "huggingface-hub",
+        "librosa>=0.11.0",
+        "pydantic>=2.11.7",
+        "scipy>=1.16.1",
+        "torch==2.6.0",
+        "torchaudio==2.6.0",
+        "transformers==4.49.0",
+        "triton==3.2.0",
+        "uvicorn>=0.35.0",
+        "zhon==2.1.1",
+    )
+    .run_commands(
+        "pip install wheel && "
+        "CUDA_HOME=/usr/local/cuda pip install flash-attn==2.7.4.post1 --no-build-isolation"
+    )
+    .run_commands(
+        "git clone --depth 1 https://github.com/XiaomiMiMo/MiMo-V2.5-ASR.git "
+        f"{MIMO_ASR_REPO_DIR} && test -d {MIMO_ASR_REPO_DIR}/src"
+    )
+    .add_local_dir("modal_backend", remote_path="/root/modal_backend")
+)
+
 secrets = [
     modal.Secret.from_name(
         "dream-customs-modal-secrets",
@@ -121,13 +155,54 @@ def _load_vision_pipe():
 def _load_asr_pipe():
     global _ASR_PIPE
     if _ASR_PIPE is None:
-        from transformers import pipeline
+        from huggingface_hub import snapshot_download
 
-        _ASR_PIPE = pipeline(
-            "automatic-speech-recognition",
-            model=os.getenv("DREAM_CUSTOMS_ASR_MODEL", ASR_MODEL),
-            device_map="auto",
-            torch_dtype="auto",
+        repo_candidates = (
+            MIMO_ASR_REPO_DIR,
+            MIMO_ASR_NESTED_REPO_DIR,
+            MIMO_ASR_RUNTIME_REPO_DIR,
+        )
+        source_dir = ""
+        for repo_dir in repo_candidates:
+            if os.path.isdir(os.path.join(repo_dir, "src")) and repo_dir not in sys.path:
+                sys.path.insert(0, repo_dir)
+                source_dir = repo_dir
+                break
+            if os.path.isdir(os.path.join(repo_dir, "src")):
+                source_dir = repo_dir
+                break
+        if not source_dir:
+            subprocess.run(
+                [
+                    "git",
+                    "clone",
+                    "--depth",
+                    "1",
+                    "https://github.com/XiaomiMiMo/MiMo-V2.5-ASR.git",
+                    MIMO_ASR_RUNTIME_REPO_DIR,
+                ],
+                check=True,
+            )
+            if not os.path.isdir(os.path.join(MIMO_ASR_RUNTIME_REPO_DIR, "src")):
+                raise RuntimeError("MiMo-V2.5-ASR source checkout is missing in Modal.")
+            sys.path.insert(0, MIMO_ASR_RUNTIME_REPO_DIR)
+        from src.mimo_audio.mimo_audio import MimoAudio
+
+        model_path = os.getenv("DREAM_CUSTOMS_ASR_MODEL_PATH", "").strip()
+        if not model_path:
+            model_path = snapshot_download(
+                os.getenv("DREAM_CUSTOMS_ASR_MODEL", ASR_MODEL),
+                token=os.getenv("HF_TOKEN") or None,
+            )
+        tokenizer_path = os.getenv("DREAM_CUSTOMS_ASR_TOKENIZER_PATH", "").strip()
+        if not tokenizer_path:
+            tokenizer_path = snapshot_download(
+                os.getenv("DREAM_CUSTOMS_ASR_TOKENIZER_MODEL", ASR_TOKENIZER_MODEL),
+                token=os.getenv("HF_TOKEN") or None,
+            )
+        _ASR_PIPE = MimoAudio(
+            model_path=model_path,
+            mimo_audio_tokenizer_path=tokenizer_path,
         )
     return _ASR_PIPE
 
@@ -373,6 +448,7 @@ def health() -> Dict[str, str]:
         "text_model": TEXT_MODEL,
         "vision_model": VISION_MODEL,
         "asr_model": ASR_MODEL,
+        "asr_tokenizer_model": ASR_TOKENIZER_MODEL,
     }
 
 
@@ -467,9 +543,9 @@ async def vision(
 
 
 @app.function(
-    image=image,
-    gpu="L4",
-    timeout=10 * MINUTES,
+    image=asr_image,
+    gpu="A100",
+    timeout=20 * MINUTES,
     scaledown_window=5 * MINUTES,
     volumes={"/root/.cache/huggingface": hf_cache},
     secrets=secrets,
@@ -489,10 +565,10 @@ async def asr(
         return _json_error(str(exc))
 
     suffix = os.path.splitext(filename)[1] or ".wav"
-    pipe = _load_asr_pipe()
+    model = _load_asr_pipe()
     with tempfile.NamedTemporaryFile(suffix=suffix) as temp_file:
         temp_file.write(audio_bytes)
         temp_file.flush()
-        result = pipe(temp_file.name)
-    transcript = _stringify_pipeline_result(result)
+        transcript = model.asr_sft(temp_file.name)
+    transcript = str(transcript or "").strip()
     return {"status": "ok", "transcript": transcript, "response": transcript}

scripts/local_space_mirror.py

@@ -6,7 +6,10 @@ from __future__ import annotations
 import argparse
 import json
 import os
+import signal
+import subprocess
 import sys
+import time
 from pathlib import Path
 
 ROOT = Path(__file__).resolve().parents[1]
@@ -22,6 +25,10 @@ from dream_customs.runtime_env import (
 )
 
 
+DEFAULT_LOCAL_HOST = "127.0.0.1"
+DEFAULT_LOCAL_PORT = 7862
+
+
 def _repo_root_on_path() -> None:
     root = str(ROOT)
     if root not in sys.path:
@@ -53,8 +60,12 @@ def mirror_manifest(host: str, port: int) -> dict:
 
 def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
     parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--host", default=os.getenv("GRADIO_SERVER_NAME", "127.0.0.1"))
-    parser.add_argument("--port", type=int, default=int(os.getenv("GRADIO_SERVER_PORT", "7862")))
+    parser.add_argument("--host", default=os.getenv("GRADIO_SERVER_NAME", DEFAULT_LOCAL_HOST))
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=int(os.getenv("GRADIO_SERVER_PORT", str(DEFAULT_LOCAL_PORT))),
+    )
     parser.add_argument("--share", action="store_true", help="Create a public Gradio share link.")
     parser.add_argument(
         "--manifest-only",
@@ -75,9 +86,81 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
         action="store_true",
         help="Do not auto-load the default local runtime env JSON.",
     )
+    parser.add_argument(
+        "--no-replace",
+        action="store_true",
+        help="Do not stop an older Dream QA local app that is already listening on the target port.",
+    )
     return parser.parse_args(argv)
 
 
+def _run_text(argv: list[str]) -> str:
+    try:
+        result = subprocess.run(argv, check=False, capture_output=True, text=True)
+    except FileNotFoundError:
+        return ""
+    if result.returncode != 0:
+        return ""
+    return result.stdout.strip()
+
+
+def _listener_pids(port: int) -> list[int]:
+    output = _run_text(["lsof", "-nP", f"-iTCP:{port}", "-sTCP:LISTEN", "-t"])
+    pids: list[int] = []
+    for line in output.splitlines():
+        try:
+            pids.append(int(line.strip()))
+        except ValueError:
+            continue
+    return pids
+
+
+def _process_command(pid: int) -> str:
+    return _run_text(["ps", "-p", str(pid), "-o", "command="])
+
+
+def _process_cwd(pid: int) -> Path | None:
+    output = _run_text(["lsof", "-a", "-p", str(pid), "-d", "cwd", "-Fn"])
+    for line in output.splitlines():
+        if line.startswith("n"):
+            return Path(line[1:]).resolve()
+    return None
+
+
+def _is_repo_gradio_command(command: str) -> bool:
+    return "scripts/local_space_mirror.py" in command or command.endswith(" app.py")
+
+
+def _is_repo_local_gradio_process(pid: int) -> bool:
+    cwd = _process_cwd(pid)
+    command = _process_command(pid)
+    return cwd == ROOT.resolve() and _is_repo_gradio_command(command)
+
+
+def _wait_until_port_is_free(port: int, stopped_pids: list[int]) -> None:
+    deadline = time.time() + 4
+    while time.time() < deadline:
+        remaining = [pid for pid in _listener_pids(port) if pid in stopped_pids]
+        if not remaining:
+            return
+        time.sleep(0.2)
+    raise RuntimeError(
+        f"Stopped local Gradio process(es) {stopped_pids}, but port {port} is still busy."
+    )
+
+
+def stop_previous_local_app(port: int) -> list[int]:
+    stopped_pids: list[int] = []
+    for pid in _listener_pids(port):
+        if pid == os.getpid() or not _is_repo_local_gradio_process(pid):
+            continue
+        os.kill(pid, signal.SIGTERM)
+        stopped_pids.append(pid)
+    if stopped_pids:
+        _wait_until_port_is_free(port, stopped_pids)
+    return stopped_pids
+
+
 def main(argv: list[str] | None = None) -> int:
     args = parse_args(argv)
     os.environ["GRADIO_SERVER_NAME"] = args.host
@@ -91,6 +174,10 @@ def main(argv: list[str] | None = None) -> int:
 
     manifest = mirror_manifest(args.host, args.port)
     manifest["runtime_env_json"] = runtime_env
+    if args.manifest_only or args.no_replace:
+        manifest["replaced_local_pids"] = []
+    else:
+        manifest["replaced_local_pids"] = stop_previous_local_app(args.port)
     print(json.dumps(manifest, ensure_ascii=False, indent=2), flush=True)
     if args.manifest_only:
         return 0

tests/test_app_logic.py

@@ -1,4 +1,5 @@
 import json
+import urllib.error
 
 from dream_customs.app_logic import (
     _clients,
@@ -148,3 +149,22 @@ def test_asr_endpoint_derives_from_modal_text_endpoint_when_secret_is_missing():
     )
 
     assert settings["asr_endpoint"] == "https://workspace--dream-customs-minicpm-backend-asr.modal.run"
+
+
+def test_hosted_asr_can_disable_demo_fallback_for_browser_voice(monkeypatch, tmp_path):
+    audio_path = tmp_path / "voice.wav"
+    audio_path.write_bytes(b"not a real wav but enough to exercise upload encoding")
+
+    def raise_url_error(*_args, **_kwargs):
+        raise urllib.error.URLError("modal unavailable")
+
+    monkeypatch.setattr("dream_customs.models.urllib.request.urlopen", raise_url_error)
+    client = HostedASRClient(
+        endpoint="https://example.test/asr",
+        token="secret-token",
+        timeout=3,
+        fallback_enabled=False,
+    )
+
+    assert client.transcribe(str(audio_path)) == ""
+    assert "URLError" in client.last_error

tests/test_local_space_mirror.py

@@ -1,9 +1,16 @@
 import json
 import os
+import signal
 import subprocess
 import sys
 
-from scripts.local_space_mirror import load_runtime_env_json, mirror_manifest
+from scripts.local_space_mirror import (
+    DEFAULT_LOCAL_PORT,
+    _is_repo_gradio_command,
+    load_runtime_env_json,
+    mirror_manifest,
+    stop_previous_local_app,
+)
 from scripts.smoke_local_space_mirror import inspect_config
 
 
@@ -15,7 +22,7 @@ def test_local_space_mirror_manifest_matches_space_entrypoint(monkeypatch):
         "DREAM_CUSTOMS_HOSTED_TOKEN",
     ]:
         monkeypatch.delenv(key, raising=False)
-    manifest = mirror_manifest("127.0.0.1", 7862)
+    manifest = mirror_manifest("127.0.0.1", DEFAULT_LOCAL_PORT)
 
     assert manifest["mode"] == "local-space-mirror"
     assert manifest["space_id"] == "build-small-hackathon/dream-customs"
@@ -35,6 +42,68 @@ def test_local_space_mirror_manifest_matches_space_entrypoint(monkeypatch):
     assert "secret" not in serialized_env
 
 
+def test_app_uses_stable_local_port_without_changing_space_default():
+    env = os.environ.copy()
+    env.pop("PYTEST_CURRENT_TEST", None)
+    for key in ["GRADIO_SERVER_PORT", "PORT", "SPACE_HOST", "SPACE_ID"]:
+        env.pop(key, None)
+    env["GRADIO_ANALYTICS_ENABLED"] = "False"
+
+    local_result = subprocess.run(
+        [sys.executable, "-c", "import app; print(app._default_server_port())"],
+        check=True,
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+
+    env["SPACE_ID"] = "build-small-hackathon/dream-customs"
+    space_result = subprocess.run(
+        [sys.executable, "-c", "import app; print(app._default_server_port())"],
+        check=True,
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+
+    env["GRADIO_SERVER_PORT"] = "7877"
+    configured_result = subprocess.run(
+        [sys.executable, "-c", "import app; print(app._default_server_port())"],
+        check=True,
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+
+    assert local_result.stdout.strip() == "7862"
+    assert space_result.stdout.strip() == "7860"
+    assert configured_result.stdout.strip() == "7877"
+
+
+def test_local_space_mirror_only_replaces_repo_gradio_commands():
+    assert _is_repo_gradio_command("/usr/bin/python scripts/local_space_mirror.py")
+    assert _is_repo_gradio_command("/usr/bin/python app.py")
+    assert not _is_repo_gradio_command("/usr/bin/python other_app.py")
+
+
+def test_local_space_mirror_stops_only_matching_repo_processes(monkeypatch):
+    killed: list[tuple[int, signal.Signals]] = []
+
+    monkeypatch.setattr("scripts.local_space_mirror._listener_pids", lambda port: [111, 222])
+    monkeypatch.setattr(
+        "scripts.local_space_mirror._is_repo_local_gradio_process",
+        lambda pid: pid == 111,
+    )
+    monkeypatch.setattr(
+        "scripts.local_space_mirror.os.kill",
+        lambda pid, sig: killed.append((pid, sig)),
+    )
+    monkeypatch.setattr("scripts.local_space_mirror._wait_until_port_is_free", lambda port, pids: None)
+
+    assert stop_previous_local_app(DEFAULT_LOCAL_PORT) == [111]
+    assert killed == [(111, signal.SIGTERM)]
+
+
 def test_local_space_mirror_loads_runtime_env_json_without_printing_values(tmp_path, monkeypatch):
     for key in [
         "DREAM_CUSTOMS_TEXT_ENDPOINT",

tests/test_modal_contract.py

@@ -14,7 +14,7 @@ def test_normalize_text_payload_accepts_prompt():
     payload = normalize_text_payload({"prompt": "Return JSON.", "max_tokens": 123})
     assert payload["prompt"] == "Return JSON."
     assert payload["max_tokens"] == 123
-    assert payload["temperature"] == 0.2
+    assert payload["temperature"] == 0.0
 
 
 def test_normalize_text_payload_accepts_openai_style_messages():

tests/test_ollama_models.py

@@ -143,6 +143,22 @@ def test_hosted_text_client_parses_common_response_shape():
     assert negotiation["questions"] == ["What does it ask?"]
 
 
+def test_hosted_text_client_extracts_question_text_from_object_list():
+    client = StubHostedTextClient(
+        {
+            "response": (
+                '{"visitor_name":"小水盆",'
+                '"questions":[{"type":"1","question":"你当时是怎么被泼水的？"}],'
+                '"tone_note":"先贴近用户自己的场景。"}'
+            )
+        }
+    )
+
+    negotiation = client.generate_negotiation("dream")
+
+    assert negotiation["questions"] == ["你当时是怎么被泼水的？"]
+
+
 def test_hosted_text_client_parses_model_led_brief():
     class StubHostedBriefClient(HostedMiniCPMTextClient):
         def _post_json(self, prompt, max_tokens=700):

tests/test_pipeline.py

@@ -93,6 +93,122 @@ def test_elevator_floor14_demo_anchors_are_clean_for_question_stage():
     assert "for floor" not in state.dream_anchors
 
 
+def test_zh_company_nap_splashed_water_keeps_real_anchors():
+    session = add_evidence(
+        create_session(language="zh"),
+        dream_text="我在公司午觉的时候被人泼了一盆水。",
+        mood="",
+        vision_client=FakeVisionClient(),
+        asr_client=FakeASRClient(),
+        language="zh",
+    )
+
+    assert any("公司" in anchor for anchor in session.qa_state.dream_anchors)
+    assert any("午觉" in anchor or "午休" in anchor for anchor in session.qa_state.dream_anchors)
+    assert any("泼" in anchor or "水" in anchor for anchor in session.qa_state.dream_anchors)
+
+    session = ask_questions(session, FakeTextClient(), language="zh")
+    first_response = session.question_history[0]
+
+    assert "公司" in first_response or "午觉" in first_response or "泼" in first_response
+    assert "夜晚的海" not in first_response
+    assert "海浪" not in first_response
+    assert "月牙" not in first_response
+    assert "小人" not in first_response
+
+
+def test_zh_plain_water_fragment_does_not_invent_sea_scene():
+    session = add_evidence(
+        create_session(language="zh"),
+        dream_text="水",
+        mood="",
+        vision_client=FakeVisionClient(),
+        asr_client=FakeASRClient(),
+        language="zh",
+    )
+    session = ask_questions(session, FakeTextClient(), language="zh")
+
+    first_response = session.question_history[0]
+
+    assert "水" in first_response
+    assert "夜晚的海" not in first_response
+    assert "海浪" not in first_response
+    assert "月牙" not in first_response
+    assert "小人" not in first_response
+
+
+def test_today_tip_removes_unsupported_clinical_frame_for_company_water_dream():
+    class ClinicalHostedTextClient:
+        def generate_today_tip(self, prompt):
+            return TodayTipCard(
+                dream_summary="你梦见在公司午觉时被人泼水。",
+                main_question="这个梦里的水可能在提醒我什么？",
+                dream_anchors=["水"],
+                followup_questions=[],
+                user_answers=[],
+                interpretation="「被人泼水」可能是睡眠剥夺或压力过大的信号。",
+                today_tip="围绕「公司午觉」留意睡眠问题，必要时寻求专业帮助。",
+                tiny_action="把一杯水放在桌上，提醒自己尽快寻求专业帮助。",
+                caring_note="如果你持续焦虑或有睡眠问题，建议寻求专业帮助。",
+                safety_note="建议寻求专业帮助。",
+            )
+
+    intake = build_intake(dream_text="我在公司午觉的时候被人泼了一盆水。")
+
+    card = generate_today_tip(intake, "", ClinicalHostedTextClient(), language="zh")
+    combined = card.to_plain_text()
+
+    assert any("公司" in anchor for anchor in card.dream_anchors)
+    assert any("午觉" in anchor or "午休" in anchor for anchor in card.dream_anchors)
+    assert any("泼" in anchor or "水" in anchor for anchor in card.dream_anchors)
+    assert "睡眠剥夺" not in combined
+    assert "压力过大" not in combined
+    assert "睡眠问题" not in combined
+    assert "专业帮助" not in combined
+    assert card.safety_note == ""
+
+
+def test_today_tip_removes_unsupported_emotion_and_generic_wellness_for_company_water_dream():
+    class OverreachingHostedTextClient:
+        def generate_today_tip(self, prompt):
+            return TodayTipCard(
+                dream_summary="你梦见在公司午觉时被人泼水。",
+                main_question="这个梦里的水可能在提醒我什么？",
+                dream_anchors=["公司午觉", "被人泼水"],
+                followup_questions=["在「公司、午觉、被人泼水」里，醒来后最强烈的感受是什么？"],
+                user_answers=["用户选择跳过这个追问。"],
+                interpretation=(
+                    "你选择跳过这个追问。梦中的公司可能是在提醒你注意工作与休息的平衡，"
+                    "或者暗示你今天需要处理一些工作压力。午觉时被泼水可能象征着突如其来的挑战。"
+                ),
+                today_tip="明天上班前，先喝一杯温水，或者听一首轻松的音乐。",
+                tiny_action="把一杯温水放在桌上提醒自己保持积极。",
+                caring_note="如果你感到害怕或孤独，不必过度自责。保持积极心态，明天会更好。",
+                safety_note="",
+            )
+
+    intake = build_intake(dream_text="我在公司午觉的时候被人泼了一盆水。")
+
+    card = generate_today_tip(
+        intake,
+        "用户选择跳过这个追问。",
+        OverreachingHostedTextClient(),
+        language="zh",
+        followup_questions=["在「公司、午觉、被人泼水」里，醒来后最强烈的感受是什么？"],
+    )
+    combined = card.to_plain_text()
+
+    assert "公司" in combined
+    assert "被人泼水" in combined or "被人泼了一盆水" in combined
+    assert "工作压力" not in combined
+    assert "害怕" not in combined
+    assert "孤独" not in combined
+    assert "保持积极" not in combined
+    assert "明天会更好" not in combined
+    assert "温水" not in combined
+    assert "轻松的音乐" not in combined
+
+
 def test_generate_pact_returns_card_and_html():
     intake = build_intake(dream_text="I missed an elevator.", mood="anxious")
     card, html = generate_pact(intake, "I want a small start.", FakeTextClient())

tests/test_ui_actions.py

@@ -1,6 +1,7 @@
 import json
 import inspect
 from datetime import date
+from pathlib import Path
 
 from dream_customs.ui.actions import (
     answer_to_card_action,
@@ -34,22 +35,40 @@ def test_runtime_settings_are_collapsed_for_public_flow():
     assert 'with gr.Accordion(initial_copy["debug_title"], open=False' in flow_column_source
 
 
-def test_voice_input_keeps_modal_asr_component_but_uses_inline_mic_button():
+def test_voice_input_records_audio_to_modal_asr_without_browser_speech_recognition():
     source = inspect.getsource(ui_app.build_demo)
     app_source = inspect.getsource(ui_app)
 
     assert "audio_input = gr.Audio(" in source
-    assert 'sources=["upload"]' in source
-    assert 'sources=["microphone", "upload"]' not in source
-    assert 'type="filepath"' in source
     assert "visible=False" in source
+    assert 'type="filepath"' in source
     assert "_make_media_api_info_client_safe(audio_input)" in source
     assert "mic_html = gr.HTML(_mic_html(DEFAULT_LANGUAGE))" in source
     assert "audio_input = gr.State(None)" not in source
     assert 'value=DEFAULT_ASR_BACKEND' in source
-    assert 'data-timeout="' in ui_app._mic_html("en")
-    assert "Voice is taking too long here" in ui_app._mic_html("en")
-    assert "window.setTimeout" in app_source
+    assert 'data-open="' in ui_app._mic_html("en")
+    assert 'aria-expanded="false"' in ui_app._mic_html("en")
+    assert "window.SpeechRecognition" not in app_source
+    assert "webkitSpeechRecognition" not in app_source
+    assert "recognition.lang" not in app_source
+    assert "MediaRecorder" in app_source
+    assert 'fetch("/dream-asr"' in app_source
+    assert "AbortController" in app_source
+    assert "asrRequestTimeout" in app_source
+    assert "waking" in app_source
+    assert "appendTranscript" in app_source
+    assert "DREAM_CUSTOMS_HOSTED_TOKEN" not in app_source
+
+
+def test_browser_voice_uses_same_origin_asr_proxy():
+    source = Path("app.py").read_text(encoding="utf-8")
+
+    assert '@app.post("/dream-asr", include_in_schema=False)' in source
+    assert "_browser_asr_client()" in source
+    assert "fallback_enabled=False" in source
+    assert "asyncio.to_thread(asr_client.transcribe, temp_path)" in source
+    assert "BROWSER_ASR_TIMEOUT_SECONDS = 150.0" in source
+    assert "DREAM_CUSTOMS_HOSTED_TOKEN" not in source
 
 
 def test_image_upload_is_composer_plus_drawer():