@researai/deepscientist 1.5.14 → 1.5.16

package/src/deepscientist/daemon/app.py

@@ -2,11 +2,15 @@ from __future__ import annotations
 
 import base64
 from collections import deque
+from dataclasses import dataclass
 import faulthandler
+import hashlib
+import hmac
 import json
 import mimetypes
 import os
 import re
+import secrets
 import signal
 import shutil
 import subprocess
@@ -15,6 +19,7 @@ import threading
 import time
 import traceback
 from datetime import UTC, datetime, timedelta
+from http.cookies import SimpleCookie
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
 from typing import Any
@@ -23,9 +28,11 @@ from urllib.request import Request
 
 from .. import __version__
 from ..annotations import AnnotationService
+from ..acp import build_session_update
 from ..artifact import ArtifactService
 from ..bash_exec import BashExecService
-from ..bash_exec.runtime import TerminalClient
+from ..bash_exec.models import TerminalClient
+from ..bash_exec.service import DEFAULT_TERMINAL_SESSION_ID
 from ..bridges import register_builtin_connector_bridges
 from ..bridges.connectors import QQConnectorBridge
 from ..channels import QQRelayChannel, get_channel_factory, list_channel_names, register_builtin_channels
@@ -68,7 +75,7 @@ from ..connector.lingzhu_support import (
     lingzhu_verify_auth_header,
 )
 from ..prompts import PromptBuilder
-from ..prompts.builder import STANDARD_SKILLS
+from ..prompts.builder import classify_turn_intent, current_standard_skills
 from ..connector.qq_profiles import list_qq_profiles, merge_qq_profile_config, normalize_qq_connector_config
 from ..quest import QuestService
 from ..runners import CodexRunner, RunRequest, get_runner_factory, register_builtin_runners
@@ -79,9 +86,11 @@ from ..team import SingleTeamService
 from ..connector.weixin_support import (
     DEFAULT_WEIXIN_BOT_TYPE,
     fetch_weixin_qrcode,
+    get_weixin_replay_cursor,
     normalize_weixin_base_url,
     normalize_weixin_cdn_base_url,
     poll_weixin_qrcode_status,
+    update_weixin_replay_cursor,
 )
 from .api import ApiHandlers, match_route
 from .sessions import SessionStore
@@ -93,7 +102,9 @@ from websockets.sync.server import Server as WebSocketServer
 from websockets.sync.server import ServerConnection, serve as websocket_serve
 
 TERMINAL_STREAM_IDLE_SLEEP_SECONDS = 0.02
-_AUTO_CONTINUE_DELAY_SECONDS = 0.2
+_AUTO_CONTINUE_DELAY_SECONDS = 240.0
+_AUTO_CONTINUE_ACTIVE_WORK_DELAY_SECONDS = 0.2
+_TERMINAL_PREWARM_DEBOUNCE_SECONDS = 20.0
 CODEX_RETRY_DEFAULT_MAX_ATTEMPTS = 5
 CODEX_RETRY_DEFAULT_INITIAL_BACKOFF_SEC = 10.0
 CODEX_RETRY_DEFAULT_BACKOFF_MULTIPLIER = 6.0
@@ -138,13 +149,42 @@ _LINGZHU_SHORT_COMMAND_PREFIX_MAP = {
     "恢复": "resume",
 }
 _LINGZHU_SHORT_LATEST_ALIASES = {"latest", "newest", "最新", "最新的"}
+_WEIXIN_STALE_REPLAY_LIMIT_DEFAULT = 5
+_WEIXIN_STALE_REPLAY_INTERVAL_SECONDS_DEFAULT = 2.0
 _LINGZHU_DELETE_CONFIRM_ALIASES = {"确认", "强制", "--yes", "-y"}
+_BROWSER_AUTH_COOKIE_NAME = "ds_local_auth"
+_BROWSER_AUTH_COOKIE_MAX_AGE_SECONDS = 60 * 60 * 24 * 365
+_BROWSER_AUTH_QUERY_PARAM = "token"
+_BROWSER_AUTH_STORAGE_KEY = "ds_local_auth_token"
+_BROWSER_AUTH_PUBLIC_ROUTE_NAMES = {"root", "spa_root", "ui_asset", "asset", "auth_login"}
+_BROWSER_AUTH_EXEMPT_ROUTE_NAMES = {"lingzhu_health", "lingzhu_sse"}
+_BROWSER_AUTH_REALM = "DeepScientist"
+
+
+@dataclass(frozen=True)
+class BrowserAuthState:
+    authenticated: bool
+    token_source: str | None = None
+    response_cookie: str | None = None
+
+
+def _windows_hidden_subprocess_kwargs() -> dict[str, object]:
+    if os.name == "nt" and hasattr(subprocess, "CREATE_NO_WINDOW"):
+        return {"creationflags": getattr(subprocess, "CREATE_NO_WINDOW")}
+    return {}
 
 
 class DaemonApp:
     _MAX_INBOUND_ATTACHMENT_BYTES = 25 * 1024 * 1024
 
-    def __init__(self, home: Path) -> None:
+    def __init__(
+        self,
+        home: Path,
+        *,
+        browser_auth_enabled: bool | None = None,
+        browser_auth_token: str | None = None,
+        prompt_version_selection: str | None = None,
+    ) -> None:
         self.home = home.resolve()
         self.daemon_id = str(os.environ.get("DS_DAEMON_ID") or "").strip() or generate_id("daemon")
         self.daemon_managed_by = str(os.environ.get("DS_DAEMON_MANAGED_BY") or "manual").strip() or "manual"
@@ -180,7 +220,11 @@ class DaemonApp:
                 abandoned_run_id=item.get("abandoned_run_id"),
                 status=item.get("status"),
             )
-        self.prompt_builder = PromptBuilder(self.repo_root, home)
+        self.prompt_builder = PromptBuilder(
+            self.repo_root,
+            home,
+            prompt_version_selection=prompt_version_selection,
+        )
         self.codex_runner = CodexRunner(
             home=home,
             repo_root=self.repo_root,
@@ -200,6 +244,8 @@ class DaemonApp:
         self._canonicalize_lingzhu_binding_state()
         self._turn_lock = threading.Lock()
         self._turn_state: dict[str, dict[str, object]] = {}
+        self._terminal_prewarm_lock = threading.Lock()
+        self._terminal_prewarm_recent: dict[str, float] = {}
         self._server: ThreadingHTTPServer | None = None
         self._terminal_attach_server: WebSocketServer | None = None
         self._terminal_attach_thread: threading.Thread | None = None
@@ -219,8 +265,190 @@ class DaemonApp:
         self._process_hooks_installed = False
         self._faulthandler_stream = None
         self._recovered_quest_ids: set[str] = set()
+        ui_config = config.get("ui") if isinstance(config.get("ui"), dict) else {}
+        configured_browser_auth_enabled = self._parse_browser_auth_bool(ui_config.get("auth_enabled"))
+        env_browser_auth_enabled = self._parse_browser_auth_bool(os.environ.get("DS_UI_AUTH_ENABLED"))
+        explicit_browser_auth_enabled = self._parse_browser_auth_bool(browser_auth_enabled)
+        if explicit_browser_auth_enabled is not None:
+            self.browser_auth_enabled = explicit_browser_auth_enabled
+        elif env_browser_auth_enabled is not None:
+            self.browser_auth_enabled = env_browser_auth_enabled
+        elif configured_browser_auth_enabled is not None:
+            self.browser_auth_enabled = configured_browser_auth_enabled
+        else:
+            self.browser_auth_enabled = False
+        explicit_browser_auth_token = self._normalize_browser_auth_token(browser_auth_token)
+        env_browser_auth_token = self._normalize_browser_auth_token(os.environ.get("DS_UI_AUTH_TOKEN"))
+        if self.browser_auth_enabled:
+            self.browser_auth_token = explicit_browser_auth_token or env_browser_auth_token or self.generate_browser_auth_token()
+        else:
+            self.browser_auth_token = None
         self.handlers = ApiHandlers(self)
 
+    @staticmethod
+    def _parse_browser_auth_bool(value: object) -> bool | None:
+        if isinstance(value, bool):
+            return value
+        normalized = str(value or "").strip().lower()
+        if not normalized:
+            return None
+        if normalized in {"1", "true", "yes", "on"}:
+            return True
+        if normalized in {"0", "false", "no", "off"}:
+            return False
+        return None
+
+    @staticmethod
+    def _normalize_browser_auth_token(value: object) -> str | None:
+        token = str(value or "").strip()
+        return token or None
+
+    @staticmethod
+    def generate_browser_auth_token() -> str:
+        return secrets.token_hex(8)
+
+    def masked_browser_auth_token(self) -> str | None:
+        token = self.browser_auth_token
+        if not token:
+            return None
+        if len(token) <= 6:
+            return "*" * len(token)
+        return f"{token[:3]}{'*' * (len(token) - 6)}{token[-3:]}"
+
+    @staticmethod
+    def _header_value(headers: dict[str, str] | None, name: str) -> str:
+        if not isinstance(headers, dict):
+            return ""
+        target = name.strip().lower()
+        for key, value in headers.items():
+            if str(key).strip().lower() == target:
+                return str(value or "")
+        return ""
+
+    @staticmethod
+    def _parse_bearer_token(header_value: str) -> str | None:
+        normalized = str(header_value or "").strip()
+        prefix = "bearer "
+        if not normalized or normalized[: len(prefix)].lower() != prefix:
+            return None
+        token = normalized[len(prefix) :].strip()
+        return token or None
+
+    def _request_cookie_token(self, headers: dict[str, str] | None) -> str | None:
+        raw_cookie = self._header_value(headers, "Cookie")
+        if not raw_cookie:
+            return None
+        try:
+            cookie = SimpleCookie()
+            cookie.load(raw_cookie)
+        except Exception:
+            return None
+        morsel = cookie.get(_BROWSER_AUTH_COOKIE_NAME)
+        if morsel is None:
+            return None
+        token = str(getattr(morsel, "value", "") or "").strip()
+        return token or None
+
+    @staticmethod
+    def _request_query_token(path: str) -> str | None:
+        query = parse_qs(urlparse(path).query, keep_blank_values=True)
+        token = str((query.get(_BROWSER_AUTH_QUERY_PARAM) or [""])[0] or "").strip()
+        return token or None
+
+    def _browser_auth_cookie_header(self, token: str | None = None) -> str:
+        cookie = SimpleCookie()
+        cookie[_BROWSER_AUTH_COOKIE_NAME] = token or (self.browser_auth_token or "")
+        morsel = cookie[_BROWSER_AUTH_COOKIE_NAME]
+        morsel["path"] = "/"
+        morsel["httponly"] = True
+        morsel["samesite"] = "Strict"
+        morsel["max-age"] = str(_BROWSER_AUTH_COOKIE_MAX_AGE_SECONDS)
+        return morsel.OutputString()
+
+    @staticmethod
+    def _browser_auth_clear_cookie_header() -> str:
+        cookie = SimpleCookie()
+        cookie[_BROWSER_AUTH_COOKIE_NAME] = ""
+        morsel = cookie[_BROWSER_AUTH_COOKIE_NAME]
+        morsel["path"] = "/"
+        morsel["httponly"] = True
+        morsel["samesite"] = "Strict"
+        morsel["max-age"] = "0"
+        morsel["expires"] = "Thu, 01 Jan 1970 00:00:00 GMT"
+        return morsel.OutputString()
+
+    def browser_auth_matches(self, token: str | None) -> bool:
+        expected = self.browser_auth_token
+        candidate = self._normalize_browser_auth_token(token)
+        return bool(expected and candidate and hmac.compare_digest(candidate, expected))
+
+    def rotate_browser_auth_token(self) -> str:
+        if not self.browser_auth_enabled:
+            raise RuntimeError("Browser authentication is disabled.")
+        rotated = self.generate_browser_auth_token()
+        self.browser_auth_token = rotated
+        return rotated
+
+    def browser_auth_state_for_request(self, path: str, headers: dict[str, str] | None = None) -> BrowserAuthState:
+        if not self.browser_auth_enabled:
+            return BrowserAuthState(authenticated=True)
+        expected = self.browser_auth_token
+        if not expected:
+            return BrowserAuthState(authenticated=False)
+
+        candidates = (
+            ("authorization", self._parse_bearer_token(self._header_value(headers, "Authorization"))),
+            ("query", self._request_query_token(path)),
+            ("cookie", self._request_cookie_token(headers)),
+        )
+        for source, candidate in candidates:
+            if candidate and hmac.compare_digest(candidate, expected):
+                response_cookie = self._browser_auth_cookie_header(expected) if source in {"authorization", "query"} else None
+                return BrowserAuthState(authenticated=True, token_source=source, response_cookie=response_cookie)
+        return BrowserAuthState(authenticated=False, response_cookie=self._browser_auth_clear_cookie_header())
+
+    @staticmethod
+    def _auth_response_headers(auth_state: BrowserAuthState | None) -> dict[str, str]:
+        if auth_state is None or not auth_state.response_cookie:
+            return {}
+        return {"Set-Cookie": auth_state.response_cookie}
+
+    @staticmethod
+    def _merge_response_headers(
+        base: dict[str, str] | None = None,
+        extra: dict[str, str] | None = None,
+    ) -> dict[str, str]:
+        merged: dict[str, str] = {}
+        if isinstance(extra, dict):
+            merged.update(extra)
+        if isinstance(base, dict):
+            merged.update(base)
+        return merged
+
+    def _route_requires_browser_auth(self, route_name: str | None) -> bool:
+        if not self.browser_auth_enabled or not route_name:
+            return False
+        if route_name in _BROWSER_AUTH_PUBLIC_ROUTE_NAMES:
+            return False
+        if route_name in _BROWSER_AUTH_EXEMPT_ROUTE_NAMES:
+            return False
+        return True
+
+    def browser_auth_runtime_payload(self) -> dict[str, object]:
+        return {
+            "enabled": self.browser_auth_enabled,
+            "tokenQueryParam": _BROWSER_AUTH_QUERY_PARAM,
+            "storageKey": _BROWSER_AUTH_STORAGE_KEY,
+        }
+
+    def browser_auth_tokenized_url(self, url: str) -> str:
+        if not self.browser_auth_enabled or not self.browser_auth_token:
+            return url
+        parsed = urlparse(url)
+        query = parse_qs(parsed.query, keep_blank_values=True)
+        query[_BROWSER_AUTH_QUERY_PARAM] = [self.browser_auth_token]
+        return parsed._replace(query=urlencode(query, doseq=True)).geturl()
+
     def list_connector_statuses(self) -> list[dict[str, object]]:
         title_by_quest = self._quest_titles_by_id()
         items = [
@@ -450,6 +678,14 @@ class DaemonApp:
             ensure_dir(faulthandler_path.parent)
             self._faulthandler_stream = open(faulthandler_path, "a", encoding="utf-8")
             faulthandler.enable(file=self._faulthandler_stream)
+            dump_signal = getattr(signal, "SIGUSR1", None)
+            if dump_signal is not None:
+                faulthandler.register(
+                    dump_signal,
+                    file=self._faulthandler_stream,
+                    all_threads=True,
+                    chain=False,
+                )
         except Exception as exc:
             self.logger.log("warning", "daemon.faulthandler_enable_failed", error=str(exc))
 
@@ -716,6 +952,7 @@ class DaemonApp:
                 timeout=8,
                 check=False,
                 env=os.environ.copy(),
+                **_windows_hidden_subprocess_kwargs(),
             )
         except subprocess.TimeoutExpired as exc:
             raise RuntimeError("DeepScientist update check timed out.") from exc
@@ -763,6 +1000,7 @@ class DaemonApp:
                 timeout=8,
                 check=False,
                 env=os.environ.copy(),
+                **_windows_hidden_subprocess_kwargs(),
             )
         except subprocess.TimeoutExpired as exc:
             raise RuntimeError("DeepScientist update request timed out.") from exc
@@ -1290,6 +1528,7 @@ class DaemonApp:
             client_message_id=client_message_id,
         )
         snapshot = self.quest_service.snapshot(quest_id)
+        snapshot = self._reconcile_stale_active_turn(quest_id, snapshot=snapshot)
         runtime_status = str(snapshot.get("runtime_status") or snapshot.get("status") or "").strip()
         auto_resumed = previous_status in {"stopped", "paused", "completed"} and runtime_status not in {"stopped", "paused", "completed"}
         if auto_resumed:
@@ -1302,9 +1541,8 @@ class DaemonApp:
                 summary=f"Quest {quest_id} automatically resumed after a new user message.",
                 automated=True,
             )
-        with self._turn_lock:
-            turn_state = dict(self._turn_state.get(quest_id) or {})
-        has_live_turn = bool(turn_state.get("running")) or bool(snapshot.get("active_run_id"))
+        turn_state = self._refresh_turn_worker_state(quest_id)
+        has_live_turn = bool(turn_state.get("running"))
         if runtime_status == "running" and has_live_turn:
             scheduled = {
                 "scheduled": True,
@@ -1474,6 +1712,7 @@ class DaemonApp:
         return snapshot
 
     def schedule_turn(self, quest_id: str, *, reason: str = "user_message") -> dict:
+        self._refresh_turn_worker_state(quest_id)
         with self._turn_lock:
             state = self._turn_state.setdefault(quest_id, {"running": False, "pending": False})
             state["pending"] = True
@@ -1502,6 +1741,120 @@ class DaemonApp:
             "reason": reason,
         }
 
+    @staticmethod
+    def _turn_worker_is_alive(worker: object) -> bool:
+        return isinstance(worker, threading.Thread) and worker.is_alive()
+
+    def schedule_latest_quest_terminal_prewarm(
+        self,
+        quest_id: str,
+        *,
+        source: str = "quest_session_prewarm",
+    ) -> None:
+        normalized_quest_id = str(quest_id or "").strip()
+        if not normalized_quest_id or os.name == "nt":
+            return
+        try:
+            quests = self.quest_service.list_quests()
+        except Exception:
+            return
+        latest_quest_id = str((quests[0].get("quest_id") if quests else "") or "").strip()
+        if latest_quest_id != normalized_quest_id:
+            return
+        now = time.monotonic()
+        with self._terminal_prewarm_lock:
+            last_attempt = float(self._terminal_prewarm_recent.get(normalized_quest_id) or 0.0)
+            if now - last_attempt < _TERMINAL_PREWARM_DEBOUNCE_SECONDS:
+                return
+            self._terminal_prewarm_recent[normalized_quest_id] = now
+        threading.Thread(
+            target=self._prewarm_terminal_for_quest,
+            args=(normalized_quest_id, source),
+            daemon=True,
+            name=f"deepscientist-terminal-prewarm-{normalized_quest_id}",
+        ).start()
+
+    def _prewarm_terminal_for_quest(self, quest_id: str, source: str) -> None:
+        try:
+            quest_root = self.quest_service._quest_root(quest_id)
+            workspace_root = self.quest_service.active_workspace_root(quest_root)
+            self.bash_exec_service.ensure_terminal_session(
+                quest_root,
+                quest_id=quest_id,
+                bash_id=DEFAULT_TERMINAL_SESSION_ID,
+                cwd=workspace_root,
+                source=source,
+            )
+        except Exception as exc:
+            with self._terminal_prewarm_lock:
+                self._terminal_prewarm_recent.pop(quest_id, None)
+            self.logger.log(
+                "warning",
+                "terminal.prewarm_failed",
+                quest_id=quest_id,
+                source=source,
+                error=str(exc),
+            )
+
+    def _refresh_turn_worker_state(self, quest_id: str) -> dict[str, object]:
+        with self._turn_lock:
+            state = self._turn_state.setdefault(quest_id, {"running": False, "pending": False})
+            if bool(state.get("running")) and not self._turn_worker_is_alive(state.get("worker")):
+                state["running"] = False
+                state.pop("worker", None)
+            return dict(state)
+
+    def _reconcile_stale_active_turn(self, quest_id: str, *, snapshot: dict | None = None) -> dict:
+        snapshot = dict(snapshot or self.quest_service.snapshot(quest_id))
+        active_run_id = str(snapshot.get("active_run_id") or "").strip()
+        if not active_run_id:
+            self._refresh_turn_worker_state(quest_id)
+            return snapshot
+        turn_state = self._refresh_turn_worker_state(quest_id)
+        if turn_state.get("running"):
+            return snapshot
+
+        quest_root = self.quest_service._quest_root(quest_id)
+        result_payload = read_json(quest_root / ".ds" / "runs" / active_run_id / "result.json", {})
+        completed_at = str(result_payload.get("completed_at") or "").strip() if isinstance(result_payload, dict) else ""
+        exit_code = result_payload.get("exit_code") if isinstance(result_payload, dict) else None
+        previous_status = (
+            str(snapshot.get("runtime_status") or snapshot.get("status") or snapshot.get("display_status") or "running").strip()
+            or "running"
+        )
+        normalized_status = "active" if previous_status == "running" else previous_status
+        summary = (
+            f"Cleared stale active turn state for run `{active_run_id}` after no live worker was found."
+            if not completed_at
+            else f"Cleared stale active turn state for completed run `{active_run_id}`."
+        )
+        append_jsonl(
+            quest_root / ".ds" / "events.jsonl",
+            {
+                "event_id": generate_id("evt"),
+                "type": "quest.turn_state_reconciled",
+                "quest_id": quest_id,
+                "abandoned_run_id": active_run_id,
+                "previous_status": previous_status,
+                "status": normalized_status,
+                "completed_at": completed_at or None,
+                "exit_code": exit_code if isinstance(exit_code, int) else None,
+                "summary": summary,
+                "created_at": utc_now(),
+            },
+        )
+        self.logger.log(
+            "warning",
+            "quest.turn_state_reconciled",
+            quest_id=quest_id,
+            abandoned_run_id=active_run_id,
+            previous_status=previous_status,
+            status=normalized_status,
+            completed_at=completed_at or None,
+            exit_code=exit_code if isinstance(exit_code, int) else None,
+        )
+        return self.quest_service.mark_turn_finished(quest_id, status=normalized_status)
+
     def control_quest(self, quest_id: str, *, action: str, source: str = "local") -> dict:
         normalized_action = str(action or "").strip().lower()
         if normalized_action == "pause":
@@ -1544,7 +1897,7 @@ class DaemonApp:
             reason=f"quest_{action}",
             user_id=source,
         )
-        if action == "stop":
+        if action == "stop" and source == "local-admin":
             cancel_reason = "cancelled_by_daemon_shutdown" if source == "local-admin" else "cancelled_by_stop"
             cancelled_pending = self.quest_service.cancel_pending_user_messages(
                 quest_id,
@@ -1640,6 +1993,23 @@ class DaemonApp:
         snapshot = self.quest_service.snapshot(quest_id)
         next_status = "running" if snapshot.get("status") == "running" else "active"
         snapshot = self.quest_service.set_status(quest_id, next_status)
+        recovery_abandoned_run_id = None
+        recovery_summary = None
+        if source.startswith("auto:daemon-recovery"):
+            recent_events = self.quest_service.events(quest_id)["events"]
+            for item in reversed(recent_events[-20:]):
+                if str(item.get("type") or "").strip() != "quest.runtime_reconciled":
+                    continue
+                recovery_abandoned_run_id = str(item.get("abandoned_run_id") or "").strip() or None
+                recovery_summary = str(item.get("summary") or "").strip() or None
+                break
+        self.quest_service.update_runtime_state(
+            quest_root=self.quest_service._quest_root(quest_id),
+            last_resume_source=source,
+            last_resume_at=utc_now(),
+            last_recovery_abandoned_run_id=recovery_abandoned_run_id,
+            last_recovery_summary=recovery_summary,
+        )
         summary = f"Quest {quest_id} resumed."
         event = self._append_control_event(
             quest_id,
@@ -1780,52 +2150,50 @@ class DaemonApp:
         cancelled_pending_user_message_count: int,
         previous_snapshot: dict | None = None,
     ) -> str:
-        branch = str(snapshot.get("branch") or "unknown").strip() or "unknown"
-        workspace_root = str(snapshot.get("current_workspace_root") or snapshot.get("quest_root") or "").strip()
         if action == "resume":
             lines = [
                 self._polite_copy(
-                    zh="DeepScientist 已恢复运行。",
-                    en="DeepScientist has resumed.",
+                    zh=f"我回来继续干活啦，Quest `{quest_id}` 已恢复。",
+                    en=f"I’m back on it. Quest `{quest_id}` has resumed. ✨",
                 ),
                 self._polite_copy(
-                    zh="当前 Git 分支与 worktree 已保留，系统会沿用现有研究上下文继续。",
-                    en="The current Git branch and worktree were kept intact, and the quest will continue from the existing research context.",
+                    zh="刚才的进度都还在，我会直接接着往下推。",
+                    en="The current progress is still here, and I’ll pick up right where I left off.",
                 ),
             ]
             if source.startswith("auto:daemon-recovery"):
                 lines.append(
                     self._polite_copy(
-                        zh="检测到 daemon 曾异常退出；当前 quest 已在自动恢复后继续运行。",
-                        en="The daemon exited unexpectedly before; this quest has now been recovered automatically and will continue.",
+                        zh="刚才是 daemon 意外断开了，不过现在已经自动接回来了。",
+                        en="The daemon dropped unexpectedly, but it has been recovered automatically. 🔧",
                     )
                 )
         elif action == "pause":
             lines = [
                 self._polite_copy(
-                    zh="DeepScientist 已从运行状态转为暂停状态。",
-                    en="DeepScientist has moved from running to paused.",
+                    zh=f"我先帮您把 Quest `{quest_id}` 稳稳停在这里啦。",
+                    en=f"I’ve paused Quest `{quest_id}` right here for now. ⏸️",
                 ),
                 self._polite_copy(
-                    zh="当前 Git 分支与 worktree 已保留。如需继续，请直接在当前聊天或 connector 中发送任意新指令，或使用 /resume；系统会沿用当前 quest 上下文继续。",
-                    en="The current Git branch and worktree were kept intact. To continue, send any new instruction in this chat or connector, or use /resume; the quest will resume from the current context.",
+                    zh="当前进度我都保留好了，您发新消息或者执行 `/resume`，我就会继续。",
+                    en="I kept the current progress safe. Send a new message or use `/resume`, and I’ll continue.",
                 ),
             ]
         else:
             lines = [
                 self._polite_copy(
-                    zh="DeepScientist 已从运行状态转为停止状态。",
-                    en="DeepScientist has moved from running to stopped.",
+                    zh=f"这轮我先收住啦，Quest `{quest_id}` 已停止运行。",
+                    en=f"I’m wrapping this round here. Quest `{quest_id}` has stopped. 📌",
                 ),
                 self._polite_copy(
-                    zh="当前 Git 分支与 worktree 已保留。如需继续，请直接在当前聊天或 connector 中发送任意新指令，或使用 /resume；系统会沿用当前 quest 上下文继续。",
-                    en="The current Git branch and worktree were kept intact. To continue, send any new instruction in this chat or connector, or use /resume; the quest will resume from the current context.",
+                    zh="不过别担心，当前进度我都保留好了；您发新消息或者执行 `/resume`，我就能接着干。",
+                    en="Don’t worry, the current progress is still preserved. Send a new message or use `/resume`, and I’ll keep going.",
                 ),
             ]
         if interrupted:
             lines.append(
                 self._polite_copy(
-                    zh="当前活跃 runner 已被中断。",
+                    zh="刚才正在跑的任务已经被打断了。",
                     en="The active runner was interrupted.",
                 )
             )
@@ -1833,8 +2201,8 @@ class DaemonApp:
         if cancelled_count > 0:
             lines.append(
                 self._polite_copy(
-                    zh=f"已取消 {cancelled_count} 条排队中的用户消息。",
-                    en=f"Cancelled {cancelled_count} queued user message(s).",
+                    zh=f"另外我还顺手清掉了 {cancelled_count} 条排队消息，避免旧指令继续堆着。",
+                    en=f"I also cleared {cancelled_count} queued message(s) so stale instructions do not pile up.",
                 )
             )
         previous_status = str(
@@ -1845,17 +2213,10 @@ class DaemonApp:
         if previous_status and action == "resume":
             lines.append(
                 self._polite_copy(
-                    zh=f"此前状态：`{previous_status}`。",
+                    zh=f"恢复前的状态是：`{previous_status}`。",
                     en=f"Previous status: `{previous_status}`.",
                 )
             )
-        lines.extend(
-            [
-                f"- Quest: `{quest_id}`",
-                f"- Branch: `{branch}`",
-                f"- Workspace: `{workspace_root or snapshot.get('quest_root')}`",
-            ]
-        )
         return "\n".join(lines)
 
     def _drain_turns(self, quest_id: str) -> None:
@@ -1867,7 +2228,16 @@ class DaemonApp:
                     state.pop("worker", None)
                     return
                 state["pending"] = False
-            self._run_quest_turn(quest_id)
+            try:
+                self._run_quest_turn(quest_id)
+            except Exception as exc:
+                self.logger.log(
+                    "error",
+                    "daemon.turn_worker_crashed",
+                    quest_id=quest_id,
+                    error=str(exc),
+                    traceback=traceback.format_exc(),
+                )
 
     def _run_quest_turn(self, quest_id: str) -> None:
         with self._turn_lock:
@@ -1885,7 +2255,9 @@ class DaemonApp:
 
         runner_name = self._runner_name_for(snapshot)
         runner_cfg = self.runners_config.get(runner_name, {})
-        skill_id = self._turn_skill_for(snapshot, latest_user_message, turn_reason=turn_reason)
+        turn_intent = self._turn_intent_for(latest_user_message, turn_reason=turn_reason)
+        turn_mode = self._turn_mode_for(snapshot, latest_user_message, turn_reason=turn_reason)
+        skill_id = self._turn_skill_for(snapshot, latest_user_message, turn_reason=turn_reason, turn_mode=turn_mode)
         run_id = generate_id("run")
         model = str(runner_cfg.get("model", "gpt-5.4"))
         run_message = ""
@@ -1982,6 +2354,8 @@ class DaemonApp:
                 approval_policy=str(runner_cfg.get("approval_policy", "on-request")),
                 sandbox_mode=str(runner_cfg.get("sandbox_mode", "workspace-write")),
                 turn_reason=turn_reason,
+                turn_intent=turn_intent,
+                turn_mode=turn_mode,
                 reasoning_effort=reasoning_effort,
                 turn_id=turn_id,
                 attempt_index=attempt_index,
@@ -2002,24 +2376,172 @@ class DaemonApp:
                         "next_retry_at": None,
                     },
                 )
-
             try:
-                result = runner.run(request)
-            except Exception as exc:  # pragma: no cover - exercised via integration behavior
+                try:
+                    result = runner.run(request)
+                except Exception as exc:  # pragma: no cover - exercised via integration behavior
+                    if self._turn_stop_requested(quest_id):
+                        return
+                    failure_summary = f"Runner `{runner_name}` failed on attempt {attempt_index}/{max_attempts}: {exc}"
+                    retry_context = self._build_retry_context(
+                        quest_id=quest_id,
+                        failed_run_id=current_run_id,
+                        turn_id=turn_id,
+                        attempt_index=attempt_index,
+                        max_attempts=max_attempts,
+                        failure_kind="exception",
+                        failure_summary=failure_summary,
+                        previous_exit_code=None,
+                        previous_output_text="",
+                        stderr_text=str(exc),
+                    )
+                    if bool(retry_policy.get("enabled")) and attempt_index < max_attempts:
+                        delay_seconds = self._retry_delay_seconds(retry_policy, attempt_index=attempt_index + 1)
+                        next_retry_at = self._retry_next_timestamp(delay_seconds)
+                        self.quest_service.update_runtime_state(
+                            quest_root=quest_root,
+                            status="running",
+                            display_status="retrying",
+                            active_run_id=None,
+                            retry_state={
+                                "turn_id": turn_id,
+                                "attempt_index": attempt_index,
+                                "max_attempts": max_attempts,
+                                "last_run_id": current_run_id,
+                                "last_error": failure_summary,
+                                "next_retry_at": next_retry_at,
+                            },
+                        )
+                        self._append_retry_event(
+                            quest_id,
+                            event_type="runner.turn_retry_scheduled",
+                            runner_name=runner_name,
+                            run_id=current_run_id,
+                            turn_id=turn_id,
+                            skill_id=skill_id,
+                            model=model,
+                            attempt_index=attempt_index,
+                            max_attempts=max_attempts,
+                            summary=f"Attempt {attempt_index}/{max_attempts} failed. Retrying in {delay_seconds:.1f}s.",
+                            failure_summary=failure_summary,
+                            backoff_seconds=delay_seconds,
+                            next_attempt_index=attempt_index + 1,
+                        )
+                        if self._wait_for_retry_delay(quest_id, delay_seconds):
+                            continue
+                        self._append_retry_event(
+                            quest_id,
+                            event_type="runner.turn_retry_aborted",
+                            runner_name=runner_name,
+                            run_id=current_run_id,
+                            turn_id=turn_id,
+                            skill_id=skill_id,
+                            model=model,
+                            attempt_index=attempt_index,
+                            max_attempts=max_attempts,
+                            summary="Retry sequence aborted because the quest was stopped or paused.",
+                            failure_summary=failure_summary,
+                        )
+                        return
+                    exhausted_summary = f"{failure_summary} Retry budget exhausted after {attempt_index} attempt(s)."
+                    self._append_retry_event(
+                        quest_id,
+                        event_type="runner.turn_retry_exhausted",
+                        runner_name=runner_name,
+                        run_id=current_run_id,
+                        turn_id=turn_id,
+                        skill_id=skill_id,
+                        model=model,
+                        attempt_index=attempt_index,
+                        max_attempts=max_attempts,
+                        summary=exhausted_summary,
+                        failure_summary=failure_summary,
+                    )
+                    self._record_turn_error(
+                        quest_id=quest_id,
+                        runner_name=runner_name,
+                        run_id=current_run_id,
+                        skill_id=skill_id,
+                        model=model,
+                        summary=exhausted_summary,
+                        retry_state=None,
+                    )
+                    return
+
                 if self._turn_stop_requested(quest_id):
                     return
-                failure_summary = f"Runner `{runner_name}` failed on attempt {attempt_index}/{max_attempts}: {exc}"
+
+                if result.ok:
+                    self.quest_service.update_runtime_state(quest_root=quest_root, retry_state=None)
+                    if result.output_text:
+                        result_attachment = [
+                            {
+                                "kind": "runner_result",
+                                "run_id": result.run_id,
+                                "skill_id": skill_id,
+                                "runner": runner_name,
+                                "model": result.model,
+                                "exit_code": result.exit_code,
+                                "history_root": str(result.history_root),
+                                "run_root": str(result.run_root),
+                            }
+                        ]
+                        try:
+                            self.quest_service.append_message(
+                                quest_id,
+                                role="assistant",
+                                content=result.output_text,
+                                source=runner_name,
+                                run_id=result.run_id,
+                                skill_id=skill_id,
+                            )
+                        except Exception as exc:
+                            self._record_turn_postprocess_warning(
+                                quest_id=quest_id,
+                                runner_name=runner_name,
+                                run_id=result.run_id,
+                                skill_id=skill_id,
+                                model=result.model,
+                                stage="append_message",
+                                error=exc,
+                            )
+                        try:
+                            self._relay_quest_message_to_bound_connectors(
+                                quest_id,
+                                message=result.output_text,
+                                kind="assistant",
+                                response_phase="final",
+                                importance="normal",
+                                attachments=result_attachment,
+                            )
+                        except Exception as exc:
+                            self._record_turn_postprocess_warning(
+                                quest_id=quest_id,
+                                runner_name=runner_name,
+                                run_id=result.run_id,
+                                skill_id=skill_id,
+                                model=result.model,
+                                stage="connector_relay",
+                                error=exc,
+                            )
+                    self._normalize_status_after_turn(quest_id, turn_reason=turn_reason)
+                    return
+
+                failure_summary = f"Runner `{runner_name}` exited with code {result.exit_code} on attempt {attempt_index}/{max_attempts}."
+                stderr_excerpt = self._trim_text(result.stderr_text, limit=240)
+                if stderr_excerpt:
+                    failure_summary = f"{failure_summary} stderr: {stderr_excerpt}"
                 retry_context = self._build_retry_context(
                     quest_id=quest_id,
-                    failed_run_id=current_run_id,
+                    failed_run_id=result.run_id,
                     turn_id=turn_id,
                     attempt_index=attempt_index,
                     max_attempts=max_attempts,
-                    failure_kind="exception",
+                    failure_kind="exit_code",
                     failure_summary=failure_summary,
-                    previous_exit_code=None,
-                    previous_output_text="",
-                    stderr_text=str(exc),
+                    previous_exit_code=result.exit_code,
+                    previous_output_text=result.output_text,
+                    stderr_text=result.stderr_text,
                 )
                 if bool(retry_policy.get("enabled")) and attempt_index < max_attempts:
                     delay_seconds = self._retry_delay_seconds(retry_policy, attempt_index=attempt_index + 1)
@@ -2033,7 +2555,7 @@ class DaemonApp:
                             "turn_id": turn_id,
                             "attempt_index": attempt_index,
                             "max_attempts": max_attempts,
-                            "last_run_id": current_run_id,
+                            "last_run_id": result.run_id,
                             "last_error": failure_summary,
                             "next_retry_at": next_retry_at,
                         },
@@ -2042,7 +2564,7 @@ class DaemonApp:
                         quest_id,
                         event_type="runner.turn_retry_scheduled",
                         runner_name=runner_name,
-                        run_id=current_run_id,
+                        run_id=result.run_id,
                         turn_id=turn_id,
                         skill_id=skill_id,
                         model=model,
@@ -2059,7 +2581,7 @@ class DaemonApp:
                         quest_id,
                         event_type="runner.turn_retry_aborted",
                         runner_name=runner_name,
-                        run_id=current_run_id,
+                        run_id=result.run_id,
                         turn_id=turn_id,
                         skill_id=skill_id,
                         model=model,
@@ -2069,12 +2591,13 @@ class DaemonApp:
                         failure_summary=failure_summary,
                     )
                     return
+
                 exhausted_summary = f"{failure_summary} Retry budget exhausted after {attempt_index} attempt(s)."
                 self._append_retry_event(
                     quest_id,
                     event_type="runner.turn_retry_exhausted",
                     runner_name=runner_name,
-                    run_id=current_run_id,
+                    run_id=result.run_id,
                     turn_id=turn_id,
                     skill_id=skill_id,
                     model=model,
@@ -2086,150 +2609,155 @@ class DaemonApp:
                 self._record_turn_error(
                     quest_id=quest_id,
                     runner_name=runner_name,
-                    run_id=current_run_id,
+                    run_id=result.run_id,
                     skill_id=skill_id,
                     model=model,
                     summary=exhausted_summary,
                     retry_state=None,
                 )
                 return
-
-            if self._turn_stop_requested(quest_id):
-                return
-
-            if result.ok:
-                self.quest_service.update_runtime_state(quest_root=quest_root, retry_state=None)
-                if result.output_text:
-                    self.quest_service.append_message(
-                        quest_id,
-                        role="assistant",
-                        content=result.output_text,
-                        source=runner_name,
-                        run_id=result.run_id,
-                        skill_id=skill_id,
-                    )
-                    self._relay_quest_message_to_bound_connectors(
-                        quest_id,
-                        message=result.output_text,
-                        kind="assistant",
-                        response_phase="final",
-                        importance="normal",
-                        attachments=[
-                            {
-                                "kind": "runner_result",
-                                "run_id": result.run_id,
-                                "skill_id": skill_id,
-                                "runner": runner_name,
-                                "model": result.model,
-                                "exit_code": result.exit_code,
-                                "history_root": str(result.history_root),
-                                "run_root": str(result.run_root),
-                            }
-                        ],
-                    )
-                self._normalize_status_after_turn(quest_id)
-                return
-
-            failure_summary = f"Runner `{runner_name}` exited with code {result.exit_code} on attempt {attempt_index}/{max_attempts}."
-            stderr_excerpt = self._trim_text(result.stderr_text, limit=240)
-            if stderr_excerpt:
-                failure_summary = f"{failure_summary} stderr: {stderr_excerpt}"
-            retry_context = self._build_retry_context(
-                quest_id=quest_id,
-                failed_run_id=result.run_id,
-                turn_id=turn_id,
-                attempt_index=attempt_index,
-                max_attempts=max_attempts,
-                failure_kind="exit_code",
-                failure_summary=failure_summary,
-                previous_exit_code=result.exit_code,
-                previous_output_text=result.output_text,
-                stderr_text=result.stderr_text,
-            )
-            if bool(retry_policy.get("enabled")) and attempt_index < max_attempts:
-                delay_seconds = self._retry_delay_seconds(retry_policy, attempt_index=attempt_index + 1)
-                next_retry_at = self._retry_next_timestamp(delay_seconds)
-                self.quest_service.update_runtime_state(
-                    quest_root=quest_root,
-                    status="running",
-                    display_status="retrying",
-                    active_run_id=None,
-                    retry_state={
-                        "turn_id": turn_id,
-                        "attempt_index": attempt_index,
-                        "max_attempts": max_attempts,
-                        "last_run_id": result.run_id,
-                        "last_error": failure_summary,
-                        "next_retry_at": next_retry_at,
-                    },
-                )
-                self._append_retry_event(
-                    quest_id,
-                    event_type="runner.turn_retry_scheduled",
-                    runner_name=runner_name,
-                    run_id=result.run_id,
-                    turn_id=turn_id,
-                    skill_id=skill_id,
-                    model=model,
-                    attempt_index=attempt_index,
-                    max_attempts=max_attempts,
-                    summary=f"Attempt {attempt_index}/{max_attempts} failed. Retrying in {delay_seconds:.1f}s.",
-                    failure_summary=failure_summary,
-                    backoff_seconds=delay_seconds,
-                    next_attempt_index=attempt_index + 1,
-                )
-                if self._wait_for_retry_delay(quest_id, delay_seconds):
-                    continue
-                self._append_retry_event(
+            finally:
+                self._ensure_turn_cleanup(
                     quest_id,
-                    event_type="runner.turn_retry_aborted",
-                    runner_name=runner_name,
-                    run_id=result.run_id,
-                    turn_id=turn_id,
-                    skill_id=skill_id,
-                    model=model,
-                    attempt_index=attempt_index,
-                    max_attempts=max_attempts,
-                    summary="Retry sequence aborted because the quest was stopped or paused.",
-                    failure_summary=failure_summary,
+                    run_id=current_run_id,
+                    turn_reason=turn_reason,
                 )
-                return
-
-            exhausted_summary = f"{failure_summary} Retry budget exhausted after {attempt_index} attempt(s)."
-            self._append_retry_event(
-                quest_id,
-                event_type="runner.turn_retry_exhausted",
-                runner_name=runner_name,
-                run_id=result.run_id,
-                turn_id=turn_id,
-                skill_id=skill_id,
-                model=model,
-                attempt_index=attempt_index,
-                max_attempts=max_attempts,
-                summary=exhausted_summary,
-                failure_summary=failure_summary,
-            )
-            self._record_turn_error(
-                quest_id=quest_id,
-                runner_name=runner_name,
-                run_id=result.run_id,
-                skill_id=skill_id,
-                model=model,
-                summary=exhausted_summary,
-                retry_state=None,
-            )
-            return
 
     def _runner_name_for(self, snapshot: dict) -> str:
         configured = self.config_manager.load_named("config")
         return str(snapshot.get("runner") or configured.get("default_runner", "codex")).strip().lower()
 
     @staticmethod
-    def _turn_skill_for(snapshot: dict, latest_user_message: dict | None, *, turn_reason: str = "user_message") -> str:
+    def _stage_state_fingerprint(snapshot: dict) -> str:
+        paper_health = (
+            dict(snapshot.get("paper_contract_health") or {})
+            if isinstance(snapshot.get("paper_contract_health"), dict)
+            else {}
+        )
+        payload = {
+            "active_anchor": str(snapshot.get("active_anchor") or "").strip() or None,
+            "active_run_id": str(snapshot.get("active_run_id") or "").strip() or None,
+            "active_analysis_campaign_id": str(snapshot.get("active_analysis_campaign_id") or "").strip() or None,
+            "next_pending_slice_id": str(snapshot.get("next_pending_slice_id") or "").strip() or None,
+            "current_workspace_branch": str(snapshot.get("current_workspace_branch") or "").strip() or None,
+            "continuation_policy": str(snapshot.get("continuation_policy") or "").strip() or None,
+            "paper": {
+                "closure_state": str(paper_health.get("closure_state") or "").strip() or None,
+                "delivery_state": str(paper_health.get("delivery_state") or "").strip() or None,
+                "recommended_next_stage": str(paper_health.get("recommended_next_stage") or "").strip() or None,
+                "recommended_action": str(paper_health.get("recommended_action") or "").strip() or None,
+                "blocking_reasons": list(paper_health.get("blocking_reasons") or []),
+                "keep_bundle_fixed_by_default": bool(paper_health.get("keep_bundle_fixed_by_default")),
+            },
+        }
+        return hashlib.sha256(json.dumps(payload, ensure_ascii=False, sort_keys=True).encode("utf-8")).hexdigest()
+
+    @staticmethod
+    def _turn_intent_for(latest_user_message: dict | None, *, turn_reason: str = "user_message") -> str:
         if str(turn_reason or "").strip() == "auto_continue" or latest_user_message is None:
+            return "continue_stage"
+        return classify_turn_intent(str(latest_user_message.get("content") or "").strip())
+
+    @staticmethod
+    def _turn_mode_for(snapshot: dict, latest_user_message: dict | None, *, turn_reason: str = "user_message") -> str:
+        normalized_reason = str(turn_reason or "").strip() or "user_message"
+        if normalized_reason == "auto_continue":
+            resume_source = str(snapshot.get("last_resume_source") or "").strip()
+            if resume_source.startswith("auto:daemon-recovery"):
+                return "recovering"
+            continuation_policy = str(snapshot.get("continuation_policy") or "auto").strip().lower() or "auto"
+            if continuation_policy == "when_external_progress":
+                return "monitoring"
+            if continuation_policy in {"wait_for_user_or_resume", "none"}:
+                return "parked"
+            return "stage_execution"
+        turn_intent = DaemonApp._turn_intent_for(latest_user_message, turn_reason=turn_reason)
+        if turn_intent == "answer_user_question_first":
+            return "answering"
+        if turn_intent == "execute_user_command_first":
+            return "command_execution"
+        return "stage_execution"
+
+    @staticmethod
+    def _continuation_anchor_for(snapshot: dict) -> str:
+        available_stage_skills = current_standard_skills(repo_root())
+        continuation_anchor = str(snapshot.get("continuation_anchor") or "").strip()
+        if continuation_anchor in available_stage_skills:
+            return continuation_anchor
+        active_anchor = str(snapshot.get("active_anchor") or "").strip()
+        return active_anchor if active_anchor in available_stage_skills else "decision"
+
+    @staticmethod
+    def _workspace_mode_for(snapshot: dict) -> str:
+        value = str(snapshot.get("workspace_mode") or "").strip().lower()
+        if value in {"copilot", "autonomous"}:
+            return value
+        startup_contract = snapshot.get("startup_contract")
+        if isinstance(startup_contract, dict):
+            value = str(startup_contract.get("workspace_mode") or "").strip().lower()
+            if value in {"copilot", "autonomous"}:
+                return value
+        return "autonomous"
+
+    def _resolve_continuation_policy(self, snapshot: dict, *, current_policy: str) -> tuple[str, str]:
+        normalized = str(current_policy or "auto").strip().lower() or "auto"
+        if normalized != "auto":
+            return normalized, str(snapshot.get("continuation_reason") or "").strip() or "explicit_continuation_policy"
+        if self._workspace_mode_for(snapshot) == "copilot":
+            return "wait_for_user_or_resume", "copilot_mode"
+        if self._has_external_progress(snapshot):
+            return "when_external_progress", "background_external_progress_active"
+        return "auto", "autonomous_prepare_or_launch_long_run"
+
+    @staticmethod
+    def _auto_continue_delay_for_policy(policy: str) -> float:
+        normalized = str(policy or "").strip().lower() or "auto"
+        if normalized == "when_external_progress":
+            return _AUTO_CONTINUE_DELAY_SECONDS
+        return _AUTO_CONTINUE_ACTIVE_WORK_DELAY_SECONDS
+
+    @staticmethod
+    def _turn_skill_stage_gate(snapshot: dict, candidate_skill: str) -> str:
+        skill = str(candidate_skill or "").strip()
+        baseline_gate = str(snapshot.get("baseline_gate") or "pending").strip().lower() or "pending"
+        startup_contract = snapshot.get("startup_contract") if isinstance(snapshot.get("startup_contract"), dict) else {}
+        raw_need_research_paper = startup_contract.get("need_research_paper")
+        need_research_paper = raw_need_research_paper if isinstance(raw_need_research_paper, bool) else True
+        active_idea_id = str(snapshot.get("active_idea_id") or "").strip()
+
+        if (
+            baseline_gate == "pending"
+            and skill in {"idea", "optimize", "experiment", "analysis-campaign", "write", "review", "rebuttal", "finalize"}
+        ):
+            return "baseline"
+
+        if skill == "experiment" and not active_idea_id:
+            return "idea" if need_research_paper else "optimize"
+
+        return skill
+
+    @staticmethod
+    def _turn_skill_for(
+        snapshot: dict,
+        latest_user_message: dict | None,
+        *,
+        turn_reason: str = "user_message",
+        turn_mode: str = "stage_execution",
+    ) -> str:
+        available_stage_skills = current_standard_skills(repo_root())
+        workspace_mode = DaemonApp._workspace_mode_for(snapshot)
+
+        def copilot_default_skill() -> str:
             active_anchor = str(snapshot.get("active_anchor") or "").strip()
-            return active_anchor if active_anchor in STANDARD_SKILLS else "decision"
-        reply_target = str(latest_user_message.get("reply_to_interaction_id") or "").strip()
+            if active_anchor in available_stage_skills and active_anchor != "decision":
+                return DaemonApp._turn_skill_stage_gate(snapshot, active_anchor)
+            continuation_anchor = str(snapshot.get("continuation_anchor") or "").strip()
+            if continuation_anchor in available_stage_skills and continuation_anchor != "decision":
+                return DaemonApp._turn_skill_stage_gate(snapshot, continuation_anchor)
+            fallback = "baseline" if "baseline" in available_stage_skills else "scout"
+            return DaemonApp._turn_skill_stage_gate(snapshot, fallback)
+
+        reply_target = str((latest_user_message or {}).get("reply_to_interaction_id") or "").strip()
         if reply_target:
             for item in (snapshot.get("active_interactions") or []):
                 candidate_ids = {
@@ -2247,13 +2775,42 @@ class DaemonApp:
                     str(item.get("interaction_id") or "").strip(),
                     str(item.get("artifact_id") or "").strip(),
                 }
-                if reply_target in candidate_ids and (
+                if reply_target not in candidate_ids:
+                    continue
+                if (
                     str(item.get("reply_mode") or "") == "blocking"
                     or str(item.get("kind") or "") == "decision_request"
                 ):
                     return "decision"
+                if str(item.get("reply_mode") or "") == "threaded":
+                    if workspace_mode == "copilot":
+                        return copilot_default_skill()
+                    return DaemonApp._turn_skill_stage_gate(
+                        snapshot,
+                        DaemonApp._continuation_anchor_for(snapshot),
+                    )
+        if turn_mode == "recovering":
+            return "decision"
+        if workspace_mode == "copilot" and latest_user_message is not None:
+            return copilot_default_skill()
+        if turn_mode in {"answering", "command_execution"}:
+            return "decision"
+        if str(turn_reason or "").strip() == "auto_continue" or latest_user_message is None:
+            return DaemonApp._turn_skill_stage_gate(
+                snapshot,
+                DaemonApp._continuation_anchor_for(snapshot),
+            )
+        continuation_policy = str(snapshot.get("continuation_policy") or "auto").strip().lower() or "auto"
+        if continuation_policy == "wait_for_user_or_resume":
+            return DaemonApp._turn_skill_stage_gate(
+                snapshot,
+                DaemonApp._continuation_anchor_for(snapshot),
+            )
         active_anchor = str(snapshot.get("active_anchor") or "").strip()
-        return active_anchor if active_anchor in STANDARD_SKILLS else "decision"
+        return DaemonApp._turn_skill_stage_gate(
+            snapshot,
+            active_anchor if active_anchor in available_stage_skills else "decision",
+        )
 
     def _latest_user_message(self, quest_id: str) -> dict | None:
         for item in reversed(self.quest_service.history(quest_id, limit=200)):
@@ -2601,7 +3158,80 @@ class DaemonApp:
             ],
         )
 
-    def _normalize_status_after_turn(self, quest_id: str) -> None:
+    def _record_turn_postprocess_warning(
+        self,
+        *,
+        quest_id: str,
+        runner_name: str,
+        run_id: str,
+        skill_id: str,
+        model: str,
+        stage: str,
+        error: Exception,
+    ) -> None:
+        quest_root = self.home / "quests" / quest_id
+        summary = f"Runner post-run stage `{stage}` failed for run `{run_id}`: {error}"
+        append_jsonl(
+            quest_root / ".ds" / "events.jsonl",
+            {
+                "event_id": generate_id("evt"),
+                "type": "runner.turn_postprocess_warning",
+                "quest_id": quest_id,
+                "run_id": run_id,
+                "source": runner_name,
+                "skill_id": skill_id,
+                "model": model,
+                "stage": stage,
+                "summary": summary,
+                "created_at": utc_now(),
+            },
+        )
+        self.logger.log(
+            "error",
+            "runner.turn_postprocess_warning",
+            quest_id=quest_id,
+            run_id=run_id,
+            runner=runner_name,
+            skill_id=skill_id,
+            model=model,
+            stage=stage,
+            error=str(error),
+        )
+
+    def _ensure_turn_cleanup(self, quest_id: str, *, run_id: str, turn_reason: str) -> None:
+        snapshot = self.quest_service.snapshot(quest_id)
+        if str(snapshot.get("active_run_id") or "").strip() != str(run_id or "").strip():
+            return
+        try:
+            self._normalize_status_after_turn(quest_id, turn_reason=turn_reason)
+            return
+        except Exception as exc:
+            current_status = str(snapshot.get("status") or snapshot.get("display_status") or "active").strip() or "active"
+            normalized_status = "active" if current_status == "running" else current_status
+            self.quest_service.mark_turn_finished(quest_id, status=normalized_status)
+            quest_root = self.quest_service._quest_root(quest_id)
+            append_jsonl(
+                quest_root / ".ds" / "events.jsonl",
+                {
+                    "event_id": generate_id("evt"),
+                    "type": "runner.turn_cleanup_recovered",
+                    "quest_id": quest_id,
+                    "run_id": run_id,
+                    "status": normalized_status,
+                    "summary": f"Recovered turn cleanup after `_normalize_status_after_turn` failed: {exc}",
+                    "created_at": utc_now(),
+                },
+            )
+            self.logger.log(
+                "error",
+                "runner.turn_cleanup_recovered",
+                quest_id=quest_id,
+                run_id=run_id,
+                status=normalized_status,
+                error=str(exc),
+            )
+
+    def _normalize_status_after_turn(self, quest_id: str, *, turn_reason: str = "user_message") -> None:
         with self._turn_lock:
             if bool((self._turn_state.get(quest_id) or {}).get("stop_requested")):
                 return
@@ -2609,6 +3239,46 @@ class DaemonApp:
         current_status = str(snapshot.get("status") or snapshot.get("display_status") or "active").strip() or "active"
         normalized_status = "active" if current_status == "running" else current_status
         snapshot = self.quest_service.mark_turn_finished(quest_id, status=normalized_status)
+        runtime_updates: dict[str, Any] = {}
+        current_fingerprint = self._stage_state_fingerprint(snapshot)
+        previous_fingerprint = str(snapshot.get("last_stage_fingerprint") or "").strip() or None
+        same_fingerprint_count = int(snapshot.get("same_fingerprint_auto_turn_count") or 0)
+        if str(turn_reason or "").strip() == "auto_continue":
+            same_fingerprint_count = same_fingerprint_count + 1 if previous_fingerprint == current_fingerprint else 1
+        else:
+            same_fingerprint_count = 0
+        runtime_updates.update(
+            {
+                "last_stage_fingerprint": current_fingerprint,
+                "last_stage_fingerprint_at": utc_now(),
+                "same_fingerprint_auto_turn_count": same_fingerprint_count,
+            }
+        )
+        if (
+            str(turn_reason or "").strip() == "auto_continue"
+            and str(snapshot.get("active_anchor") or "").strip() == "finalize"
+            and same_fingerprint_count >= 2
+            and int(snapshot.get("pending_user_message_count") or 0) == 0
+        ):
+            runtime_updates.update(
+                {
+                    "continuation_policy": "wait_for_user_or_resume",
+                    "continuation_anchor": "decision",
+                    "continuation_reason": "unchanged_finalize_state",
+                    "continuation_updated_at": utc_now(),
+                }
+            )
+            self.quest_service.update_runtime_state(
+                quest_root=self.quest_service._quest_root(quest_id),
+                **runtime_updates,
+            )
+            snapshot = self.quest_service.snapshot(quest_id)
+        else:
+            self.quest_service.update_runtime_state(
+                quest_root=self.quest_service._quest_root(quest_id),
+                **runtime_updates,
+            )
+            snapshot = self.quest_service.snapshot(quest_id)
         status = str(snapshot.get("status") or "")
         if status in {"stopped", "paused", "completed", "error"}:
             return
@@ -2618,12 +3288,68 @@ class DaemonApp:
             if int(snapshot.get("pending_user_message_count") or 0) > 0:
                 self.schedule_turn(quest_id, reason="queued_user_messages")
             else:
-                self._schedule_turn_later(quest_id, reason="auto_continue", delay_seconds=_AUTO_CONTINUE_DELAY_SECONDS)
+                continuation_policy = str(snapshot.get("continuation_policy") or "auto").strip().lower() or "auto"
+                if continuation_policy == "auto":
+                    continuation_policy, continuation_reason = self._resolve_continuation_policy(
+                        snapshot,
+                        current_policy=continuation_policy,
+                    )
+                    self.quest_service.update_runtime_state(
+                        quest_root=self.quest_service._quest_root(quest_id),
+                        continuation_policy=continuation_policy,
+                        continuation_reason=continuation_reason,
+                        continuation_updated_at=utc_now(),
+                    )
+                    snapshot = self.quest_service.snapshot(quest_id)
+                if continuation_policy not in {"wait_for_user_or_resume", "none"}:
+                    self._schedule_turn_later(
+                        quest_id,
+                        reason="auto_continue",
+                        delay_seconds=self._auto_continue_delay_for_policy(continuation_policy),
+                    )
             return
         if int(snapshot.get("pending_user_message_count") or 0) > 0:
             self.schedule_turn(quest_id, reason="queued_user_messages")
             return
-        self._schedule_turn_later(quest_id, reason="auto_continue", delay_seconds=_AUTO_CONTINUE_DELAY_SECONDS)
+        continuation_policy = str(snapshot.get("continuation_policy") or "auto").strip().lower() or "auto"
+        if continuation_policy == "auto":
+            continuation_policy, continuation_reason = self._resolve_continuation_policy(
+                snapshot,
+                current_policy=continuation_policy,
+            )
+            self.quest_service.update_runtime_state(
+                quest_root=self.quest_service._quest_root(quest_id),
+                continuation_policy=continuation_policy,
+                continuation_reason=continuation_reason,
+                continuation_updated_at=utc_now(),
+            )
+            snapshot = self.quest_service.snapshot(quest_id)
+        if continuation_policy == "none":
+            return
+        if continuation_policy == "wait_for_user_or_resume":
+            return
+        if continuation_policy == "when_external_progress":
+            if not self._has_external_progress(snapshot):
+                next_policy = "wait_for_user_or_resume" if self._workspace_mode_for(snapshot) == "copilot" else "auto"
+                next_reason = "external_progress_finished" if next_policy == "wait_for_user_or_resume" else "external_progress_finished_continue_autonomous"
+                self.quest_service.update_runtime_state(
+                    quest_root=self.quest_service._quest_root(quest_id),
+                    continuation_policy=next_policy,
+                    continuation_reason=next_reason,
+                    continuation_updated_at=utc_now(),
+                )
+                if next_policy != "wait_for_user_or_resume":
+                    self._schedule_turn_later(
+                        quest_id,
+                        reason="auto_continue",
+                        delay_seconds=self._auto_continue_delay_for_policy(next_policy),
+                    )
+                return
+        self._schedule_turn_later(
+            quest_id,
+            reason="auto_continue",
+            delay_seconds=self._auto_continue_delay_for_policy(continuation_policy),
+        )
 
     def _schedule_turn_later(self, quest_id: str, *, reason: str, delay_seconds: float) -> None:
         def _delayed() -> None:
@@ -2634,6 +3360,32 @@ class DaemonApp:
             status = str(snapshot.get("status") or snapshot.get("runtime_status") or "").strip().lower()
             if status in {"completed", "paused", "stopped", "error", "waiting_for_user"}:
                 return
+            continuation_policy = str(snapshot.get("continuation_policy") or "auto").strip().lower() or "auto"
+            if continuation_policy == "auto":
+                continuation_policy, continuation_reason = self._resolve_continuation_policy(
+                    snapshot,
+                    current_policy=continuation_policy,
+                )
+                self.quest_service.update_runtime_state(
+                    quest_root=self.quest_service._quest_root(quest_id),
+                    continuation_policy=continuation_policy,
+                    continuation_reason=continuation_reason,
+                    continuation_updated_at=utc_now(),
+                )
+                snapshot = self.quest_service.snapshot(quest_id)
+            if continuation_policy in {"none", "wait_for_user_or_resume"}:
+                return
+            if continuation_policy == "when_external_progress":
+                if not self._has_external_progress(snapshot):
+                    next_policy = "wait_for_user_or_resume" if self._workspace_mode_for(snapshot) == "copilot" else "auto"
+                    next_reason = "external_progress_finished" if next_policy == "wait_for_user_or_resume" else "external_progress_finished_continue_autonomous"
+                    self.quest_service.update_runtime_state(
+                        quest_root=self.quest_service._quest_root(quest_id),
+                        continuation_policy=next_policy,
+                        continuation_reason=next_reason,
+                        continuation_updated_at=utc_now(),
+                    )
+                    return
             self.schedule_turn(quest_id, reason=reason)
 
         threading.Thread(
@@ -2642,6 +3394,23 @@ class DaemonApp:
             name=f"deepscientist-turn-delay-{quest_id}",
         ).start()
 
+    def _has_external_progress(self, snapshot: dict) -> bool:
+        if bool(snapshot.get("active_run_id")):
+            return True
+        quest_id = str(snapshot.get("quest_id") or "").strip()
+        if not quest_id:
+            return False
+        try:
+            quest_root = self.quest_service._quest_root(quest_id)
+        except FileNotFoundError:
+            return False
+        try:
+            sessions = self.bash_exec_service.list_sessions(quest_root, limit=200)
+            return any(str(item.get("status") or "").strip().lower() == "running" for item in sessions if isinstance(item, dict))
+        except Exception:
+            counts = snapshot.get("counts") if isinstance(snapshot.get("counts"), dict) else {}
+            return int(counts.get("bash_running_count") or 0) > 0
+
     def _relay_quest_message_to_bound_connectors(
         self,
         quest_id: str,
@@ -3492,6 +4261,13 @@ class DaemonApp:
                     **normalized,
                     "_qq_main_chat_binding": qq_binding,
                 }
+        if connector_name == "weixin":
+            replay = self._maybe_replay_weixin_pending_outbox(normalized)
+            if replay is not None:
+                normalized = {
+                    **normalized,
+                    "_weixin_replay": replay,
+                }
         reply = self._route_connector_message(connector_name, normalized)
         return {
             "ok": True,
@@ -3627,8 +4403,8 @@ class DaemonApp:
                         "quest_id": target_quest,
                         "kind": "ack",
                         "message": self._polite_copy(
-                            zh=f"老师，已将当前 {connector_label} 会话绑定到 {target_quest}，我会继续推进并同步计划。",
-                            en=f"Received. I’ve bound this {connector_label} conversation to {target_quest} and will keep the plan moving.",
+                            zh=f"收到啦！这里已经切到 Quest `{target_quest}` 了，接下来我会直接在这个 {connector_label} 里继续同步进展。",
+                            en=f"Got it. This {connector_label} is now on Quest `{target_quest}`, and I’ll keep the next updates here. ✨",
                         ),
                     }
                 )
@@ -4719,13 +5495,13 @@ class DaemonApp:
                 channel = self._channel_with_bindings(old_connector)
                 if mode == "disconnect":
                     message = self._polite_copy(
-                        zh=f"当前已退出 Quest `{quest_id}`，项目已切换为仅本地。",
-                        en=f"This conversation is no longer bound to Quest `{quest_id}`. The project is now local only.",
+                        zh=f"Quest `{quest_id}` 已经从这里解绑啦，后面会只在本地继续推进。",
+                        en=f"Quest `{quest_id}` is no longer bound here. It will continue locally only. 📌",
                     )
                 else:
                     message = self._polite_copy(
-                        zh=f"当前已退出 Quest `{quest_id}`，后续请在 {current_label} 查看进展。",
-                        en=f"This conversation is no longer bound to Quest `{quest_id}`. Continue from {current_label}.",
+                        zh=f"Quest `{quest_id}` 已经从这里切走啦，后面的进展请在 {current_label} 查看。",
+                        en=f"Quest `{quest_id}` has moved away from this conversation. Continue from {current_label}. 🔁",
                     )
                 channel.send(
                     {
@@ -4742,13 +5518,13 @@ class DaemonApp:
                 channel = self._channel_with_bindings(new_connector)
                 if mode == "bind":
                     message = self._polite_copy(
-                        zh=f"当前已绑定 Quest `{quest_id}`。",
-                        en=f"This conversation is now bound to Quest `{quest_id}`.",
+                        zh=f"收到！Quest `{quest_id}` 已经接上啦，后面的进展我都会直接在这里同步给您。",
+                        en=f"Quest `{quest_id}` is now connected here, and I’ll keep the next updates in this conversation. ✨",
                     )
                 elif mode == "switch":
                     message = self._polite_copy(
-                        zh=f"当前已绑定 Quest `{quest_id}`，并已从 {previous_label} 切换到当前会话。",
-                        en=f"This conversation is now bound to Quest `{quest_id}`, replacing {previous_label}.",
+                        zh=f"收到！Quest `{quest_id}` 已经切到这里啦，后面的进展我都会直接在这里同步给您。",
+                        en=f"Quest `{quest_id}` has switched over here, and I’ll keep the next updates in this conversation. 🔄",
                     )
                 else:
                     message = ""
@@ -4982,6 +5758,20 @@ class DaemonApp:
         )
         return f"{notice}\n\n{base}"
 
+    def _connector_goal_preview(self, goal: str, *, limit: int = 88) -> str:
+        for raw_line in str(goal or "").replace("\r", "\n").split("\n"):
+            line = re.sub(r"^[#>*\-\d\.)\s]+", "", raw_line).strip()
+            if not line:
+                continue
+            normalized = re.sub(r"\s+", " ", line).strip()
+            if len(normalized) <= limit:
+                return normalized
+            return normalized[: max(0, limit - 3)].rstrip() + "..."
+        return self._polite_copy(
+            zh="我会先把当前任务整理清楚，再继续推进。",
+            en="I will clarify the current task first, then keep moving. ✨",
+        )
+
     def _quest_created_connector_message(
         self,
         connector_name: str,
@@ -4990,29 +5780,29 @@ class DaemonApp:
         goal: str,
         previous_quest_id: str | None = None,
     ) -> str:
-        normalized_goal = str(goal or "").strip() or "（未提供具体任务）"
         previous = str(previous_quest_id or "").strip()
+        goal_preview = self._connector_goal_preview(goal)
         restore_zh = (
-            f"\n如果需要恢复到原先绑定的 quest，请发送：`/use {previous}`。"
+            f"\n如果想切回原先的 Quest `{previous}`，给我发 `/use {previous}` 就行。"
             if previous and previous != quest_id
             else ""
         )
         restore_en = (
-            f"\nIf you need to switch back to the previously bound quest, send: `/use {previous}`."
+            f"\nIf you want to switch back to Quest `{previous}`, send `/use {previous}`. 🔁"
             if previous and previous != quest_id
             else ""
         )
         return self._polite_copy(
             zh=(
-                f"老师，已顺利创建新的 quest `{quest_id}`。\n"
-                f"我即将为您完成以下任务：{normalized_goal}\n"
-                f"当前 {self._connector_label(connector_name)} 会话接下来会自动使用这个新 quest 保持连接。\n"
+                f"开工啦！新的 Quest `{quest_id}` 已经建好啦。\n"
+                f"这轮我先做这件事：{goal_preview}\n"
+                f"后面的进展我都会直接在这里同步给您。"
             )
             + restore_zh,
             en=(
-                f"Created a new quest `{quest_id}` successfully.\n"
-                f"I am about to work on: {normalized_goal}\n"
-                f"This {self._connector_label(connector_name)} conversation will now stay attached to the new quest automatically.\n"
+                f"Quest `{quest_id}` is ready, and I’m starting now. 🚀\n"
+                f"Current focus: {goal_preview}\n"
+                f"I’ll keep the next updates right here."
             )
             + restore_en,
         )
@@ -5290,6 +6080,121 @@ class DaemonApp:
         resolved = dict(config) if isinstance(config, dict) else {}
         return lingzhu_health_payload(resolved, chat_completions_enabled=True)
 
+    @staticmethod
+    def _weixin_replay_limit(config: dict[str, Any]) -> int:
+        try:
+            limit = int(config.get("stale_replay_latest_limit") or _WEIXIN_STALE_REPLAY_LIMIT_DEFAULT)
+        except (TypeError, ValueError):
+            limit = _WEIXIN_STALE_REPLAY_LIMIT_DEFAULT
+        return max(0, min(limit, 20))
+
+    @staticmethod
+    def _weixin_replay_interval_seconds(config: dict[str, Any]) -> float:
+        try:
+            interval = float(
+                config.get("stale_replay_interval_seconds") or _WEIXIN_STALE_REPLAY_INTERVAL_SECONDS_DEFAULT
+            )
+        except (TypeError, ValueError):
+            interval = _WEIXIN_STALE_REPLAY_INTERVAL_SECONDS_DEFAULT
+        return max(0.0, min(interval, 30.0))
+
+    def _weixin_connector_root(self) -> Path:
+        return self.home / "logs" / "connectors" / "weixin"
+
+    def _weixin_queued_outbox_records(self, conversation_id: str) -> list[dict[str, Any]]:
+        outbox_path = self._weixin_connector_root() / "outbox.jsonl"
+        target_key = conversation_identity_key(conversation_id)
+        items: list[dict[str, Any]] = []
+        for record in read_jsonl(outbox_path):
+            if not isinstance(record, dict):
+                continue
+            current_conversation_id = str(record.get("conversation_id") or "").strip()
+            if not current_conversation_id:
+                continue
+            if conversation_identity_key(current_conversation_id) != target_key:
+                continue
+            delivery = record.get("delivery") if isinstance(record.get("delivery"), dict) else {}
+            if not bool(delivery.get("queued", False)):
+                continue
+            attachments = [dict(item) for item in (record.get("attachments") or []) if isinstance(item, dict)]
+            if not str(record.get("text") or "").strip() and not attachments:
+                continue
+            items.append(
+                {
+                    **dict(record),
+                    "attachments": attachments,
+                }
+            )
+        return items
+
+    def _weixin_pending_outbox_records(self, conversation_id: str, *, user_id: str) -> tuple[list[dict[str, Any]], int]:
+        records = self._weixin_queued_outbox_records(conversation_id)
+        baseline = get_weixin_replay_cursor(self._weixin_connector_root(), user_id)
+        applied_baseline = max(0, min(int(baseline), len(records)))
+        return records[applied_baseline:], len(records)
+
+    @staticmethod
+    def _weixin_replay_payload(record: dict[str, Any]) -> dict[str, Any]:
+        attachments = [dict(item) for item in (record.get("attachments") or []) if isinstance(item, dict)]
+        surface_actions = [dict(item) for item in (record.get("surface_actions") or []) if isinstance(item, dict)]
+        connector_hints = dict(record.get("connector_hints")) if isinstance(record.get("connector_hints"), dict) else {}
+        return {
+            "conversation_id": record.get("conversation_id"),
+            "reply_to_message_id": record.get("reply_to_message_id"),
+            "kind": record.get("kind"),
+            "message": str(record.get("text") or ""),
+            "attachments": attachments,
+            "surface_actions": surface_actions,
+            "connector_hints": connector_hints,
+            "quest_id": record.get("quest_id"),
+            "quest_root": record.get("quest_root"),
+            "importance": record.get("importance"),
+            "response_phase": record.get("response_phase"),
+        }
+
+    def _maybe_replay_weixin_pending_outbox(self, message: dict[str, Any]) -> dict[str, Any] | None:
+        conversation_id = str(message.get("conversation_id") or "").strip()
+        sender_id = str(message.get("sender_id") or message.get("direct_id") or "").strip()
+        if not conversation_id or not sender_id:
+            return None
+        config = self.connectors_config.get("weixin", {})
+        resolved = dict(config) if isinstance(config, dict) else {}
+        limit = self._weixin_replay_limit(resolved)
+        if limit <= 0:
+            return {"replayed_count": 0, "dropped_count": 0, "total_pending": 0}
+        pending_records, total_count = self._weixin_pending_outbox_records(conversation_id, user_id=sender_id)
+        if not pending_records:
+            return {"replayed_count": 0, "dropped_count": 0, "total_pending": 0}
+        selected_records = pending_records[-limit:]
+        dropped_count = max(0, len(pending_records) - len(selected_records))
+        update_weixin_replay_cursor(
+            self._weixin_connector_root(),
+            user_id=sender_id,
+            queued_replay_cursor=total_count,
+            last_replay_trigger_message_id=str(message.get("message_id") or "").strip() or None,
+            last_replayed_count=len(selected_records),
+            last_replay_dropped_count=dropped_count,
+        )
+        channel = self._channel_with_bindings("weixin")
+        interval_seconds = self._weixin_replay_interval_seconds(resolved)
+        for index, record in enumerate(selected_records):
+            channel.send(self._weixin_replay_payload(record))
+            if index + 1 < len(selected_records) and interval_seconds > 0:
+                time.sleep(interval_seconds)
+        self.logger.log(
+            "info",
+            "connector.weixin_replay",
+            conversation_id=conversation_id,
+            replayed_count=len(selected_records),
+            dropped_count=dropped_count,
+            trigger_message_id=str(message.get("message_id") or "").strip() or None,
+        )
+        return {
+            "replayed_count": len(selected_records),
+            "dropped_count": dropped_count,
+            "total_pending": len(pending_records),
+        }
+
     def _lingzhu_state_path(self) -> Path:
         return self.home / "logs" / "connectors" / "lingzhu" / "metis_state.json"
 
@@ -5449,6 +6354,13 @@ class DaemonApp:
         return emitted
 
     def _lingzhu_short_status_text(self, quest_id: str | None) -> str:
+        normalized_quest_id = str(quest_id or "").strip()
+        if normalized_quest_id:
+            snapshot = self.quest_service.snapshot_fast(normalized_quest_id)
+            runtime_status = str(snapshot.get("runtime_status") or snapshot.get("status") or "").strip().lower()
+            if runtime_status in {"running", "active"}:
+                return "进行中"
+            return self._lingzhu_status_hint_text(normalized_quest_id)
         return self._lingzhu_status_hint_text(quest_id)
 
     @staticmethod
@@ -5717,6 +6629,33 @@ class DaemonApp:
         handler.wfile.write(b"\n")
         handler.wfile.flush()
 
+    @staticmethod
+    def _write_handler_response(
+        handler: BaseHTTPRequestHandler,
+        *,
+        code: int,
+        content: bytes,
+        content_type: str | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> bool:
+        try:
+            handler.send_response(code)
+            if content_type:
+                handler.send_header("Content-Type", content_type)
+            handler.send_header("Content-Length", str(len(content)))
+            for key, value in (extra_headers or {}).items():
+                handler.send_header(key, value)
+            handler.end_headers()
+            if content:
+                handler.wfile.write(content)
+            return True
+        except (BrokenPipeError, ConnectionResetError, TimeoutError):
+            try:
+                handler.close_connection = True
+            except Exception:
+                pass
+            return False
+
     @staticmethod
     def _parse_bash_log_jsonl_line(raw_line: bytes) -> dict[str, Any] | None:
         stripped = raw_line.strip()
@@ -5730,6 +6669,19 @@ class DaemonApp:
             return None
         return payload
 
+    @staticmethod
+    def _parse_quest_event_jsonl_line(raw_line: bytes) -> dict[str, Any] | None:
+        stripped = raw_line.strip()
+        if not stripped:
+            return None
+        try:
+            payload = json.loads(stripped.decode("utf-8", errors="replace"))
+        except json.JSONDecodeError:
+            return None
+        if not isinstance(payload, dict):
+            return None
+        return payload
+
     @classmethod
     def _read_bash_log_delta(
         cls,
@@ -5773,6 +6725,42 @@ class DaemonApp:
 
         return fresh_entries, next_offset, remainder
 
+    @classmethod
+    def _read_quest_event_delta(
+        cls,
+        event_path: Path,
+        *,
+        offset: int,
+        pending: bytes,
+    ) -> tuple[list[dict[str, Any]], int, bytes]:
+        if not event_path.exists():
+            return [], 0, pending
+
+        current_size = event_path.stat().st_size
+        safe_offset = max(0, min(offset, current_size))
+        with event_path.open("rb") as handle:
+            handle.seek(safe_offset)
+            chunk = handle.read()
+            next_offset = handle.tell()
+
+        if not chunk:
+            return [], next_offset, pending
+
+        payload = pending + chunk
+        lines = payload.split(b"\n")
+        remainder = b""
+        if payload and not payload.endswith(b"\n"):
+            remainder = lines.pop()
+
+        fresh_entries: list[dict[str, Any]] = []
+        for raw_line in lines:
+            entry = cls._parse_quest_event_jsonl_line(raw_line.rstrip(b"\r"))
+            if not entry:
+                continue
+            fresh_entries.append(entry)
+
+        return fresh_entries, next_offset, remainder
+
     def stream_quest_events(
         self,
         handler: BaseHTTPRequestHandler,
@@ -5780,6 +6768,7 @@ class DaemonApp:
         quest_id: str,
         path: str,
         headers: dict[str, str] | None = None,
+        extra_headers: dict[str, str] | None = None,
     ) -> None:
         query = self.handlers.parse_query(path)
         after = int((query.get("after") or ["0"])[0] or "0")
@@ -5789,46 +6778,132 @@ class DaemonApp:
         last_event_id = str((headers or {}).get("Last-Event-ID") or (headers or {}).get("last-event-id") or "").strip()
         current_cursor = max(after, int(last_event_id)) if last_event_id.isdigit() else after
         heartbeat_at = time.monotonic()
-        idle_sleep_seconds = 0.35
+        idle_sleep_seconds = 0.08
+        force_fetch = True
+        event_path = self.quest_service._quest_root(quest_id) / ".ds" / "events.jsonl"
+        previous_event_state = None
+        cached_tail = self.quest_service.jsonl_tail_cache_entry(event_path) or {}
+        cached_tail_state = cached_tail.get("state") if isinstance(cached_tail.get("state"), (list, tuple)) else None
+        cached_tail_total = int(cached_tail.get("total") or 0) if isinstance(cached_tail, dict) else 0
+        event_offset = int(cached_tail_state[2]) if cached_tail_state and cached_tail_total == current_cursor else 0
+        pending_bytes = b""
 
         handler.send_response(200)
         handler.send_header("Content-Type", "text/event-stream; charset=utf-8")
         handler.send_header("Cache-Control", "no-cache, no-transform")
         handler.send_header("Connection", "keep-alive")
         handler.send_header("X-Accel-Buffering", "no")
+        for key, value in (extra_headers or {}).items():
+            handler.send_header(key, value)
         handler.end_headers()
         handler.wfile.write(b"retry: 1000\n\n")
         handler.wfile.flush()
 
         try:
             while True:
-                stream_path = f"/api/quests/{quest_id}/events?{urlencode({'after': current_cursor, 'limit': limit, 'format': format_name, 'session_id': session_id})}"
-                payload = self.handlers.quest_events(quest_id, path=stream_path)
-                updates = payload.get("acp_updates") or []
-                if updates:
-                    for update in updates:
-                        update_cursor = str(((update.get("params") or {}).get("update") or {}).get("cursor") or "")
+                current_event_state = self.quest_service._path_state(event_path)
+                if force_fetch or current_event_state != previous_event_state:
+                    used_incremental_delta = False
+                    delta_base_state = previous_event_state or cached_tail_state
+                    can_read_incremental = (
+                        current_cursor > 0
+                        and event_offset > 0
+                        and current_event_state is not None
+                        and delta_base_state is not None
+                        and tuple(delta_base_state)[0] == current_event_state[0]
+                        and current_event_state[2] >= int(tuple(delta_base_state)[2])
+                    )
+                    if can_read_incremental:
+                        fresh_events, event_offset, pending_bytes = self._read_quest_event_delta(
+                            event_path,
+                            offset=event_offset,
+                            pending=pending_bytes,
+                        )
+                        previous_event_state = current_event_state
+                        if fresh_events:
+                            for event in fresh_events:
+                                current_cursor += 1
+                                enriched_event = {
+                                    "cursor": current_cursor,
+                                    "event_id": event.get("event_id") or f"evt-{quest_id}-{current_cursor}",
+                                    **event,
+                                }
+                                update = build_session_update(
+                                    enriched_event,
+                                    quest_id=quest_id,
+                                    cursor=current_cursor,
+                                    session_id=session_id,
+                                )
+                                self._write_sse_event(
+                                    handler,
+                                    event="acp_update",
+                                    data=update,
+                                    event_id=str(current_cursor),
+                                )
+                            self._write_sse_event(
+                                handler,
+                                event="cursor",
+                                data={"cursor": current_cursor, "quest_id": quest_id},
+                            )
+                            heartbeat_at = time.monotonic()
+                            used_incremental_delta = True
+                            force_fetch = False
+                            idle_sleep_seconds = 0.03
+                        else:
+                            force_fetch = False
+                            now = time.monotonic()
+                            if now - heartbeat_at >= 10:
+                                handler.wfile.write(b": keep-alive\n\n")
+                                handler.wfile.flush()
+                                heartbeat_at = now
+                    if used_incremental_delta:
+                        time.sleep(idle_sleep_seconds)
+                        continue
+                    stream_path = f"/api/quests/{quest_id}/events?{urlencode({'after': current_cursor, 'limit': limit, 'format': format_name, 'session_id': session_id})}"
+                    payload = self.handlers.quest_events(quest_id, path=stream_path)
+                    previous_event_state = current_event_state
+                    updates = payload.get("acp_updates") or []
+                    if updates:
+                        for update in updates:
+                            update_cursor = str(((update.get("params") or {}).get("update") or {}).get("cursor") or "")
+                            self._write_sse_event(
+                                handler,
+                                event="acp_update",
+                                data=update,
+                                event_id=update_cursor or None,
+                            )
+                        current_cursor = int(payload.get("cursor") or current_cursor)
+                        if current_event_state is not None and not payload.get("has_more"):
+                            event_offset = int(current_event_state[2])
+                            pending_bytes = b""
+                            cached_tail_state = current_event_state
+                            cached_tail_total = current_cursor
                         self._write_sse_event(
                             handler,
-                            event="acp_update",
-                            data=update,
-                            event_id=update_cursor or None,
+                            event="cursor",
+                            data={"cursor": current_cursor, "quest_id": quest_id},
                         )
-                    current_cursor = int(payload.get("cursor") or current_cursor)
-                    self._write_sse_event(
-                        handler,
-                        event="cursor",
-                        data={"cursor": current_cursor, "quest_id": quest_id},
-                    )
-                    heartbeat_at = time.monotonic()
-                    idle_sleep_seconds = 0.2
+                        heartbeat_at = time.monotonic()
+                        force_fetch = bool(payload.get("has_more"))
+                        idle_sleep_seconds = 0.03 if force_fetch else 0.08
+                    else:
+                        if current_event_state is not None:
+                            event_offset = int(current_event_state[2])
+                            cached_tail_state = current_event_state
+                        force_fetch = False
+                        now = time.monotonic()
+                        if now - heartbeat_at >= 10:
+                            handler.wfile.write(b": keep-alive\n\n")
+                            handler.wfile.flush()
+                            heartbeat_at = now
+                        idle_sleep_seconds = min(0.9, idle_sleep_seconds * 1.25)
                 else:
                     now = time.monotonic()
                     if now - heartbeat_at >= 10:
                         handler.wfile.write(b": keep-alive\n\n")
                         handler.wfile.flush()
                         heartbeat_at = now
-                    idle_sleep_seconds = min(1.5, idle_sleep_seconds * 1.35)
+                    idle_sleep_seconds = min(0.9, idle_sleep_seconds * 1.25)
                 time.sleep(idle_sleep_seconds)
         except (BrokenPipeError, ConnectionResetError, TimeoutError):
             return
@@ -5839,6 +6914,7 @@ class DaemonApp:
         *,
         quest_id: str,
         path: str,
+        extra_headers: dict[str, str] | None = None,
     ) -> None:
         quest_root = self.quest_service._quest_root(quest_id)
         query = self.handlers.parse_query(path)
@@ -5875,55 +6951,83 @@ class DaemonApp:
         handler.send_header("Cache-Control", "no-cache, no-transform")
         handler.send_header("Connection", "keep-alive")
         handler.send_header("X-Accel-Buffering", "no")
+        for key, value in (extra_headers or {}).items():
+            handler.send_header(key, value)
         handler.end_headers()
         handler.wfile.write(b"retry: 1000\n\n")
         handler.wfile.flush()
 
         previous_snapshot: dict[str, dict[str, object]] = {}
         heartbeat_at = time.monotonic()
+        summary_path = self.bash_exec_service.summary_path(quest_root)
+        index_path = self.bash_exec_service.index_path(quest_root)
+        previous_summary_state = None
+        previous_index_state = None
+        has_active_sessions = False
+        last_full_refresh_at = 0.0
         try:
             while True:
-                sessions = list_payload()
-                current_snapshot = {
-                    str(item.get("bash_id") or ""): item
-                    for item in sessions
-                    if item.get("bash_id")
-                }
-                if not previous_snapshot:
-                    self._write_sse_event(
-                        handler,
-                        event="snapshot",
-                        data={"sessions": sessions},
+                current_summary_state = self.quest_service._path_state(summary_path)
+                current_index_state = self.quest_service._path_state(index_path)
+                should_refresh = (
+                    not previous_snapshot
+                    or current_summary_state != previous_summary_state
+                    or current_index_state != previous_index_state
+                    or (has_active_sessions and time.monotonic() - last_full_refresh_at >= 3.0)
+                )
+                if should_refresh:
+                    sessions = list_payload()
+                    current_snapshot = {
+                        str(item.get("bash_id") or ""): item
+                        for item in sessions
+                        if item.get("bash_id")
+                    }
+                    has_active_sessions = any(
+                        str(item.get("status") or "").strip().lower() in {"running", "terminating"}
+                        for item in current_snapshot.values()
                     )
-                    previous_snapshot = current_snapshot
-                    heartbeat_at = time.monotonic()
-                else:
-                    changed = [
-                        session
-                        for bash_id, session in current_snapshot.items()
-                        if previous_snapshot.get(bash_id) != session
-                    ]
-                    removed = set(previous_snapshot) - set(current_snapshot)
-                    for session in changed:
-                        self._write_sse_event(
-                            handler,
-                            event="session",
-                            data={"session": session},
-                        )
-                    for bash_id in removed:
+                    previous_summary_state = self.quest_service._path_state(summary_path)
+                    previous_index_state = self.quest_service._path_state(index_path)
+                    last_full_refresh_at = time.monotonic()
+                    if not previous_snapshot:
                         self._write_sse_event(
                             handler,
-                            event="session",
-                            data={"session": {"bash_id": bash_id, "status": "terminated"}},
+                            event="snapshot",
+                            data={"sessions": sessions},
                         )
-                    if changed or removed:
                         previous_snapshot = current_snapshot
                         heartbeat_at = time.monotonic()
-                    elif time.monotonic() - heartbeat_at >= 10:
-                        handler.wfile.write(b": keep-alive\n\n")
-                        handler.wfile.flush()
-                        heartbeat_at = time.monotonic()
-                time.sleep(0.4)
+                    else:
+                        changed = [
+                            session
+                            for bash_id, session in current_snapshot.items()
+                            if previous_snapshot.get(bash_id) != session
+                        ]
+                        removed = set(previous_snapshot) - set(current_snapshot)
+                        for session in changed:
+                            self._write_sse_event(
+                                handler,
+                                event="session",
+                                data={"session": session},
+                            )
+                        for bash_id in removed:
+                            self._write_sse_event(
+                                handler,
+                                event="session",
+                                data={"session": {"bash_id": bash_id, "status": "terminated"}},
+                            )
+                        if changed or removed:
+                            previous_snapshot = current_snapshot
+                            heartbeat_at = time.monotonic()
+                        elif time.monotonic() - heartbeat_at >= 10:
+                            handler.wfile.write(b": keep-alive\n\n")
+                            handler.wfile.flush()
+                            heartbeat_at = time.monotonic()
+                elif time.monotonic() - heartbeat_at >= 10:
+                    handler.wfile.write(b": keep-alive\n\n")
+                    handler.wfile.flush()
+                    heartbeat_at = time.monotonic()
+                time.sleep(0.5 if has_active_sessions else 2.0)
         except (BrokenPipeError, ConnectionResetError, TimeoutError):
             return
 
@@ -5934,6 +7038,7 @@ class DaemonApp:
         quest_id: str,
         bash_id: str,
         headers: dict[str, str] | None = None,
+        extra_headers: dict[str, str] | None = None,
     ) -> None:
         quest_root = self.quest_service._quest_root(quest_id)
         last_event_raw = str((headers or {}).get("Last-Event-ID") or (headers or {}).get("last-event-id") or "").strip()
@@ -5944,6 +7049,8 @@ class DaemonApp:
         handler.send_header("Cache-Control", "no-cache, no-transform")
         handler.send_header("Connection", "keep-alive")
         handler.send_header("X-Accel-Buffering", "no")
+        for key, value in (extra_headers or {}).items():
+            handler.send_header(key, value)
         handler.end_headers()
         handler.wfile.write(b"retry: 1000\n\n")
         handler.wfile.flush()
@@ -6144,35 +7251,84 @@ class DaemonApp:
                 if route_name is None:
                     self._write_json(404, {"ok": False, "message": "Not Found"})
                     return
-                if route_name == "quest_events" and app._wants_event_stream(self.path, dict(self.headers.items())):
+                request_headers = dict(self.headers.items())
+                auth_state = app.browser_auth_state_for_request(self.path, request_headers)
+                auth_headers = app._auth_response_headers(auth_state)
+                if app._route_requires_browser_auth(route_name) and not auth_state.authenticated:
+                    self._write_json(
+                        401,
+                        {
+                            "ok": False,
+                            "message": "Authentication required.",
+                            "auth_required": True,
+                            "auth_enabled": True,
+                        },
+                        extra_headers={
+                            **auth_headers,
+                            "WWW-Authenticate": f'Bearer realm="{_BROWSER_AUTH_REALM}"',
+                            "Cache-Control": "no-store, max-age=0, must-revalidate",
+                        },
+                    )
+                    return
+                if route_name == "quest_events" and app._wants_event_stream(self.path, request_headers):
                     try:
-                        app.stream_quest_events(self, **params, path=self.path, headers=dict(self.headers.items()))
+                        app.stream_quest_events(self, **params, path=self.path, headers=request_headers, extra_headers=auth_headers)
                     except Exception as exc:
-                        self._write_json(500, {"ok": False, "message": str(exc)})
+                        app.logger.log(
+                            "error",
+                            "http.stream_quest_events_failed",
+                            path=self.path,
+                            error=str(exc),
+                        )
+                        self.close_connection = True
                     return
                 if route_name == "bash_sessions_stream":
                     try:
-                        app.stream_bash_sessions(self, **params, path=self.path)
+                        app.stream_bash_sessions(self, **params, path=self.path, extra_headers=auth_headers)
                     except Exception as exc:
-                        self._write_json(500, {"ok": False, "message": str(exc)})
+                        app.logger.log(
+                            "error",
+                            "http.stream_bash_sessions_failed",
+                            path=self.path,
+                            error=str(exc),
+                        )
+                        self.close_connection = True
                     return
                 if route_name == "bash_log_stream":
                     try:
-                        app.stream_bash_logs(self, **params, headers=dict(self.headers.items()))
+                        app.stream_bash_logs(self, **params, headers=request_headers, extra_headers=auth_headers)
                     except Exception as exc:
-                        self._write_json(500, {"ok": False, "message": str(exc)})
+                        app.logger.log(
+                            "error",
+                            "http.stream_bash_logs_failed",
+                            path=self.path,
+                            error=str(exc),
+                        )
+                        self.close_connection = True
                     return
                 if route_name == "terminal_stream":
                     try:
-                        app.stream_bash_logs(self, quest_id=params["quest_id"], bash_id=params["session_id"], headers=dict(self.headers.items()))
+                        app.stream_bash_logs(
+                            self,
+                            quest_id=params["quest_id"],
+                            bash_id=params["session_id"],
+                            headers=request_headers,
+                            extra_headers=auth_headers,
+                        )
                     except Exception as exc:
-                        self._write_json(500, {"ok": False, "message": str(exc)})
+                        app.logger.log(
+                            "error",
+                            "http.stream_terminal_logs_failed",
+                            path=self.path,
+                            error=str(exc),
+                        )
+                        self.close_connection = True
                     return
                 if route_name == "lingzhu_sse":
                     content_length = int(self.headers.get("Content-Length", "0"))
                     raw_body = self.rfile.read(content_length) if content_length else b""
                     try:
-                        app.stream_lingzhu_sse(self, raw_body=raw_body, headers=dict(self.headers.items()))
+                        app.stream_lingzhu_sse(self, raw_body=raw_body, headers=request_headers)
                     except Exception as exc:
                         self._write_json(500, {"ok": False, "message": str(exc)})
                     return
@@ -6187,11 +7343,12 @@ class DaemonApp:
                     result = getattr(app.handlers, route_name)
                     if route_name == "asset":
                         status, headers, content = result(**params)
-                        self.send_response(status)
-                        for key, value in headers.items():
-                            self.send_header(key, value)
-                        self.end_headers()
-                        self.wfile.write(content)
+                        app._write_handler_response(
+                            self,
+                            code=status,
+                            content=content,
+                            extra_headers=app._merge_response_headers(headers, auth_headers),
+                        )
                         return
                     if route_name in {
                         "quest_events",
@@ -6218,7 +7375,7 @@ class DaemonApp:
                         payload = result(**params, path=self.path)
                     elif method == "GET":
                         payload = result(**params) if params else result()
-                    elif route_name in {"document_open", "document_asset_upload", "chat", "command", "quest_control", "config_save", "quest_create", "quest_baseline_binding", "run_create", "qq_inbound", "connector_inbound", "docs_open", "admin_shutdown", "bash_stop", "quest_settings", "quest_bindings", "quest_delete", "quest_layout_update", "terminal_session_ensure", "terminal_attach", "terminal_input", "stage_view", "latex_init", "latex_compile", "system_update_action", "weixin_login_qr_start", "weixin_login_qr_wait", "arxiv_import", "annotation_create"}:
+                    elif route_name in {"document_open", "document_asset_upload", "chat", "command", "quest_control", "config_save", "quest_create", "quest_baseline_binding", "run_create", "qq_inbound", "connector_inbound", "docs_open", "admin_shutdown", "bash_stop", "quest_settings", "quest_bindings", "quest_delete", "quest_layout_update", "terminal_session_ensure", "terminal_attach", "terminal_input", "stage_view", "latex_init", "latex_compile", "system_update_action", "weixin_login_qr_start", "weixin_login_qr_wait", "arxiv_import", "annotation_create", "auth_login", "auth_rotate"}:
                         payload = result(**params, body=body)
                     elif route_name == "config_validate":
                         payload = result(body)
@@ -6231,33 +7388,43 @@ class DaemonApp:
                     else:
                         payload = result(**params) if params else result()
                 except Exception as exc:
-                    self._write_json(500, {"ok": False, "message": str(exc)})
+                    self._write_json(500, {"ok": False, "message": str(exc)}, extra_headers=auth_headers)
                     return
 
                 if isinstance(payload, tuple) and len(payload) == 2:
                     status, body = payload
-                    self._write_json(status, body)
+                    self._write_json(status, body, extra_headers=auth_headers)
                     return
                 if isinstance(payload, tuple) and len(payload) == 3:
                     status, headers, content = payload
-                    self.send_response(status)
-                    for key, value in headers.items():
-                        self.send_header(key, value)
-                    self.end_headers()
                     if isinstance(content, str):
-                        self.wfile.write(content.encode("utf-8"))
+                        encoded = content.encode("utf-8")
                     else:
-                        self.wfile.write(content)
+                        encoded = content
+                    app._write_handler_response(
+                        self,
+                        code=status,
+                        content=encoded,
+                        extra_headers=app._merge_response_headers(headers, auth_headers),
+                    )
                     return
-                self._write_json(200, payload)
-
-            def _write_json(self, code: int, payload: dict | list) -> None:
+                self._write_json(200, payload, extra_headers=auth_headers)
+
+            def _write_json(
+                self,
+                code: int,
+                payload: dict | list,
+                *,
+                extra_headers: dict[str, str] | None = None,
+            ) -> None:
                 encoded = json.dumps(payload, ensure_ascii=False, indent=2).encode("utf-8")
-                self.send_response(code)
-                self.send_header("Content-Type", "application/json; charset=utf-8")
-                self.send_header("Content-Length", str(len(encoded)))
-                self.end_headers()
-                self.wfile.write(encoded)
+                app._write_handler_response(
+                    self,
+                    code=code,
+                    content=encoded,
+                    content_type="application/json; charset=utf-8",
+                    extra_headers=extra_headers,
+                )
 
         server = ThreadingHTTPServer((host, port), RequestHandler)
         server.daemon_threads = True
@@ -6269,6 +7436,8 @@ class DaemonApp:
         self._start_background_connectors()
         self._resume_reconciled_quests()
         print(f"DeepScientist daemon listening on http://{host}:{port}")
+        if self.browser_auth_enabled and self.browser_auth_token:
+            print(f"DeepScientist auth token: {self.browser_auth_token}")
         try:
             server.serve_forever()
         except KeyboardInterrupt: