@researai/deepscientist 1.5.16 → 1.6.0

package/src/deepscientist/daemon/app.py

@@ -3,10 +3,12 @@ from __future__ import annotations
 import base64
 from collections import deque
 from dataclasses import dataclass
+import errno
 import faulthandler
 import hashlib
 import hmac
 import json
+import logging
 import mimetypes
 import os
 import re
@@ -28,8 +30,12 @@ from urllib.request import Request
 
 from .. import __version__
 from ..annotations import AnnotationService
+from ..admin import AdminTaskService
+from ..admin.repairs import AdminRepairService
+from ..admin.service import AdminService
 from ..acp import build_session_update
 from ..artifact import ArtifactService
+from ..benchstore import BenchStoreService
 from ..bash_exec import BashExecService
 from ..bash_exec.models import TerminalClient
 from ..bash_exec.service import DEFAULT_TERMINAL_SESSION_ID
@@ -55,6 +61,7 @@ from ..connector.connector_profiles import (
 from ..connector_runtime import conversation_identity_key, format_conversation_id, normalize_conversation_id, parse_conversation_id
 from ..config import ConfigManager
 from ..config.models import SYSTEM_CONNECTOR_NAMES
+from ..diagnostics import FailureDiagnosis, diagnose_runner_failure
 from ..home import repo_root
 from ..memory import MemoryService
 from ..network import urlopen_with_proxy as urlopen
@@ -77,10 +84,11 @@ from ..connector.lingzhu_support import (
 from ..prompts import PromptBuilder
 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
+from ..quest import AUTONOMOUS_BLOCKING_WAIT_REASONS, QuestService
+from ..runners import ClaudeRunner, CodexRunner, KimiRunner, OpenCodeRunner, RunRequest, get_runner_factory, register_builtin_runners
+from ..runners.metadata import get_runner_metadata
 from ..runtime_logs import JsonlLogger
-from ..shared import append_jsonl, ensure_dir, generate_id, iter_jsonl, read_json, read_jsonl, read_jsonl_tail, read_text, resolve_within, run_command, slugify, utc_now, which, write_json
+from ..shared import append_jsonl, ensure_dir, generate_id, iter_jsonl, read_json, read_jsonl, read_jsonl_tail, read_text, resolve_within, run_command, slugify, utc_now, utf8_text_subprocess_kwargs, which, write_json
 from ..skills import SkillInstaller
 from ..team import SingleTeamService
 from ..connector.weixin_support import (
@@ -105,7 +113,12 @@ TERMINAL_STREAM_IDLE_SLEEP_SECONDS = 0.02
 _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
+_STALLED_RUNNING_TURN_INACTIVITY_SECONDS = 30 * 60
+_STALLED_RUNNING_TURN_INTERRUPT_TIMEOUT_SECONDS = 5.0
+_IMMEDIATE_READ_INTERRUPT_TIMEOUT_SECONDS = 5.0
+_RESUME_CONTINUE_TEXT = "Continue"
+CODEX_RETRY_DEFAULT_MAX_ATTEMPTS = 7
+PREVIOUS_CODEX_RETRY_DEFAULT_MAX_ATTEMPTS = 5
 CODEX_RETRY_DEFAULT_INITIAL_BACKOFF_SEC = 10.0
 CODEX_RETRY_DEFAULT_BACKOFF_MULTIPLIER = 6.0
 CODEX_RETRY_DEFAULT_MAX_BACKOFF_SEC = 1800.0
@@ -199,6 +212,7 @@ class DaemonApp:
         self.memory_service = MemoryService(home)
         self.annotation_service = AnnotationService(home)
         self.artifact_service = ArtifactService(home)
+        self.benchstore_service = BenchStoreService(home, repo_root=self.repo_root)
         self.bash_exec_service = BashExecService(home)
         self.team_service = SingleTeamService(home)
         self.cloud_service = CloudLinkService(home)
@@ -210,6 +224,16 @@ class DaemonApp:
             sync_existing_quests_enabled=bool(skill_config.get("sync_quest_on_open", True)),
         )
         self.logger = JsonlLogger(home / "logs", level=config.get("logging", {}).get("level", "info"))
+        self.admin_task_service = AdminTaskService(
+            home,
+            repo_root=self.repo_root,
+            logger=self.logger,
+            system_update_status_fn=self.system_update_status,
+            system_update_action_fn=self.request_system_update,
+        )
+        self.admin_task_service.logger = self.logger
+        self.admin_repair_service = AdminRepairService(self)
+        self.admin_service = AdminService(self)
         self.reconciled_quests = self.quest_service.reconcile_runtime_state()
         for item in self.reconciled_quests:
             self.logger.log(
@@ -233,11 +257,41 @@ class DaemonApp:
             prompt_builder=self.prompt_builder,
             artifact_service=self.artifact_service,
         )
-        register_builtin_runners(codex_runner=self.codex_runner)
+        self.claude_runner = ClaudeRunner(
+            home=home,
+            repo_root=self.repo_root,
+            binary=self.runners_config.get("claude", {}).get("binary", "claude"),
+            logger=self.logger,
+            prompt_builder=self.prompt_builder,
+            artifact_service=self.artifact_service,
+        )
+        self.kimi_runner = KimiRunner(
+            home=home,
+            repo_root=self.repo_root,
+            binary=self.runners_config.get("kimi", {}).get("binary", "kimi"),
+            logger=self.logger,
+            prompt_builder=self.prompt_builder,
+            artifact_service=self.artifact_service,
+        )
+        self.opencode_runner = OpenCodeRunner(
+            home=home,
+            repo_root=self.repo_root,
+            binary=self.runners_config.get("opencode", {}).get("binary", "opencode"),
+            logger=self.logger,
+            prompt_builder=self.prompt_builder,
+            artifact_service=self.artifact_service,
+        )
+        register_builtin_runners(
+            codex_runner=self.codex_runner,
+            claude_runner=self.claude_runner,
+            kimi_runner=self.kimi_runner,
+            opencode_runner=self.opencode_runner,
+        )
         register_builtin_connector_bridges()
         register_builtin_channels(home=home, connectors_config=self.connectors_config)
         self.runners = {
-            "codex": self._create_runner("codex"),
+            name: self._create_runner(name)
+            for name in ("codex", "claude", "kimi", "opencode")
         }
         self.channels = {name: self._create_channel(name) for name in list_channel_names()}
         self.sessions = SessionStore()
@@ -755,7 +809,23 @@ class DaemonApp:
                     if int(snapshot.get("pending_user_message_count") or 0) > 0
                     else "auto_continue"
                 )
-                scheduled = self.schedule_turn(quest_id, reason=reason)
+                retry_delay_seconds = self._recovery_retry_delay_seconds(snapshot) if reason == "auto_continue" else None
+                if retry_delay_seconds is not None and retry_delay_seconds > 0:
+                    self._schedule_turn_later(
+                        quest_id,
+                        reason=reason,
+                        delay_seconds=retry_delay_seconds,
+                    )
+                    scheduled = {
+                        "scheduled": True,
+                        "started": False,
+                        "queued": True,
+                        "reason": reason,
+                        "delayed": True,
+                        "delay_seconds": retry_delay_seconds,
+                    }
+                else:
+                    scheduled = self.schedule_turn(quest_id, reason=reason)
                 event = {
                     "event_id": generate_id("evt"),
                     "type": "quest.runtime_auto_resumed",
@@ -767,6 +837,8 @@ class DaemonApp:
                     "scheduled": bool(scheduled.get("scheduled")),
                     "started": bool(scheduled.get("started")),
                     "queued": bool(scheduled.get("queued")),
+                    "delayed": bool(scheduled.get("delayed")),
+                    "delay_seconds": scheduled.get("delay_seconds"),
                     "created_at": utc_now(),
                 }
                 append_jsonl(self.home / "quests" / quest_id / ".ds" / "events.jsonl", event)
@@ -781,6 +853,8 @@ class DaemonApp:
                     scheduled=bool(scheduled.get("scheduled")),
                     started=bool(scheduled.get("started")),
                     queued=bool(scheduled.get("queued")),
+                    delayed=bool(scheduled.get("delayed")),
+                    delay_seconds=scheduled.get("delay_seconds"),
                 )
                 self._recovered_quest_ids.add(quest_id)
                 resumed.append(
@@ -834,6 +908,63 @@ class DaemonApp:
             count += 1
         return count
 
+    def _recovery_retry_delay_seconds(self, snapshot: dict[str, Any]) -> float | None:
+        retry_state = snapshot.get("retry_state") if isinstance(snapshot.get("retry_state"), dict) else None
+        if not retry_state:
+            return None
+        next_retry_at = str(retry_state.get("next_retry_at") or "").strip()
+        if not next_retry_at:
+            return None
+        parsed = self._parse_event_timestamp(next_retry_at)
+        if parsed is None:
+            return None
+        return max((parsed - datetime.now(UTC)).total_seconds(), 0.0)
+
+    def _resume_retry_state(
+        self,
+        snapshot: dict[str, Any],
+        *,
+        max_attempts: int,
+    ) -> tuple[int, str | None, dict[str, Any] | None]:
+        retry_state = snapshot.get("retry_state") if isinstance(snapshot.get("retry_state"), dict) else None
+        resume_source = str(snapshot.get("last_resume_source") or "").strip()
+        if not retry_state or not resume_source.startswith("auto:daemon-recovery"):
+            return 1, None, None
+
+        try:
+            recorded_attempt = int(retry_state.get("attempt_index") or 0)
+        except (TypeError, ValueError):
+            recorded_attempt = 0
+        if recorded_attempt <= 0:
+            return 1, None, None
+
+        next_retry_at = str(retry_state.get("next_retry_at") or "").strip()
+        start_attempt = recorded_attempt + 1 if next_retry_at else recorded_attempt
+        if start_attempt > max_attempts:
+            start_attempt = max_attempts
+        if start_attempt <= 1:
+            return 1, None, None
+
+        turn_id = str(retry_state.get("turn_id") or "").strip() or None
+        previous_run_id = str(retry_state.get("last_run_id") or "").strip() or None
+        failure_summary = str(retry_state.get("last_error") or "").strip() or None
+        retry_context = {
+            "turn_id": turn_id,
+            "attempt_index": recorded_attempt,
+            "max_attempts": max_attempts,
+            "previous_run_id": previous_run_id,
+            "failure_kind": "daemon_recovery",
+            "failure_summary": failure_summary or "Recovered retry state after daemon restart.",
+            "previous_exit_code": None,
+            "previous_output_text": "",
+            "stderr_tail": "",
+            "recent_messages": [],
+            "tool_progress": [],
+            "workspace_summary": {},
+            "recent_artifacts": [],
+        }
+        return start_attempt, turn_id, retry_context
+
     def _record_auto_resume_suppressed(
         self,
         *,
@@ -948,10 +1079,10 @@ class DaemonApp:
                 command,
                 cwd=str(self.repo_root),
                 capture_output=True,
-                text=True,
                 timeout=8,
                 check=False,
                 env=os.environ.copy(),
+                **utf8_text_subprocess_kwargs(),
                 **_windows_hidden_subprocess_kwargs(),
             )
         except subprocess.TimeoutExpired as exc:
@@ -996,10 +1127,10 @@ class DaemonApp:
                 command,
                 cwd=str(self.repo_root),
                 capture_output=True,
-                text=True,
                 timeout=8,
                 check=False,
                 env=os.environ.copy(),
+                **utf8_text_subprocess_kwargs(),
                 **_windows_hidden_subprocess_kwargs(),
             )
         except subprocess.TimeoutExpired as exc:
@@ -1014,6 +1145,24 @@ class DaemonApp:
             raise RuntimeError("DeepScientist update request returned an invalid payload.")
         return payload
 
+    def start_benchstore_install(self, entry_id: str) -> dict[str, Any]:
+        entry_payload = self.benchstore_service.get_entry(entry_id)
+        entry = entry_payload.get("entry") if isinstance(entry_payload.get("entry"), dict) else {}
+        normalized_id = str(entry.get("id") or entry_id).strip() or str(entry_id).strip()
+        entry_name = str(entry.get("name") or normalized_id).strip() or normalized_id
+        return self.admin_task_service.start_task(
+            "benchstore_install",
+            metadata={
+                "entry_id": normalized_id,
+                "entry_name": entry_name,
+            },
+            target=lambda reporter, current_task: self.benchstore_service.run_install_task(
+                entry_id=normalized_id,
+                reporter=reporter,
+                task_id=str(current_task.get("task_id") or ""),
+            ),
+        )
+
     def _process_terminal_attach_request(
         self,
         connection: ServerConnection,
@@ -1358,6 +1507,9 @@ class DaemonApp:
     def _start_terminal_attach_server(self, host: str, port: int) -> None:
         if self._terminal_attach_server is not None:
             return
+        terminal_ws_logger = logging.getLogger("deepscientist.terminal_attach.websocket")
+        terminal_ws_logger.setLevel(logging.CRITICAL + 1)
+        terminal_ws_logger.propagate = False
         candidates: list[int] = []
         if port > 0 and port < 65535:
             candidates.append(port + 1)
@@ -1373,6 +1525,7 @@ class DaemonApp:
                     compression=None,
                     max_size=None,
                     max_queue=None,
+                    logger=terminal_ws_logger,
                 )
                 self._terminal_attach_server = server
                 self._terminal_attach_host = host
@@ -1486,19 +1639,31 @@ class DaemonApp:
 
     def reload_runners_config(self) -> dict[str, object]:
         self.runners_config = self.config_manager.load_runners_config()
-        codex_config = self.runners_config.get("codex", {})
-        if isinstance(codex_config, dict):
-            self.codex_runner.binary = str(codex_config.get("binary") or "codex")
-        return {
+        runner_instances = {
+            "codex": self.codex_runner,
+            "claude": self.claude_runner,
+            "kimi": self.kimi_runner,
+            "opencode": self.opencode_runner,
+        }
+        payload: dict[str, object] = {
             "ok": True,
             "runners": sorted(name for name, config in self.runners_config.items() if isinstance(config, dict)),
-            "codex": {
-                "binary": self.codex_runner.binary,
-                "approval_policy": codex_config.get("approval_policy") if isinstance(codex_config, dict) else None,
-                "sandbox_mode": codex_config.get("sandbox_mode") if isinstance(codex_config, dict) else None,
-                "mcp_tool_timeout_sec": codex_config.get("mcp_tool_timeout_sec") if isinstance(codex_config, dict) else None,
-            },
         }
+        for runner_name, instance in runner_instances.items():
+            runner_config = self.runners_config.get(runner_name, {})
+            if isinstance(runner_config, dict):
+                instance.binary = str(runner_config.get("binary") or getattr(instance, "binary", runner_name))
+            payload[runner_name] = {
+                "binary": getattr(instance, "binary", None),
+                "enabled": runner_config.get("enabled") if isinstance(runner_config, dict) else None,
+                "model": runner_config.get("model") if isinstance(runner_config, dict) else None,
+                "config_dir": runner_config.get("config_dir") if isinstance(runner_config, dict) else None,
+            }
+            if runner_name == "codex" and isinstance(runner_config, dict):
+                payload[runner_name]["approval_policy"] = runner_config.get("approval_policy")
+                payload[runner_name]["sandbox_mode"] = runner_config.get("sandbox_mode")
+                payload[runner_name]["mcp_tool_timeout_sec"] = runner_config.get("mcp_tool_timeout_sec")
+        return payload
 
     def _preferred_locale(self) -> str:
         return str(self.runtime_config.get("default_locale") or "en-US").lower()
@@ -1506,6 +1671,14 @@ class DaemonApp:
     def _polite_copy(self, *, zh: str, en: str) -> str:
         return zh if self._preferred_locale().startswith("zh") else en
 
+    @staticmethod
+    def _resume_continue_source(source: str) -> str:
+        normalized = normalize_conversation_id(source)
+        parsed = parse_conversation_id(normalized)
+        if parsed is not None and str(parsed.get("connector") or "").strip().lower() != "local":
+            return normalized
+        return "local"
+
     def submit_user_message(
         self,
         quest_id: str,
@@ -1543,7 +1716,36 @@ class DaemonApp:
             )
         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:
+        retry_wait_details = self._retry_waiting_turn_details(
+            quest_id,
+            snapshot=snapshot,
+            turn_state=turn_state,
+            turn_reason="user_message",
+        )
+        stalled_details = self._stalled_running_turn_details(
+            quest_id,
+            snapshot=snapshot,
+            turn_state=turn_state,
+            turn_reason="user_message",
+        )
+        if retry_wait_details is not None:
+            restart = self._interrupt_retry_wait_for_new_user_message(
+                quest_id,
+                snapshot=snapshot,
+                turn_state=turn_state,
+                details=retry_wait_details,
+                source=source,
+            )
+            if restart is not None:
+                scheduled = restart
+            else:
+                scheduled = {
+                    "scheduled": True,
+                    "started": False,
+                    "queued": True,
+                    "reason": "queued_for_artifact_interact",
+                }
+        elif runtime_status == "running" and has_live_turn and stalled_details is None:
             scheduled = {
                 "scheduled": True,
                 "started": False,
@@ -1559,6 +1761,151 @@ class DaemonApp:
             **scheduled,
         }
 
+    def _retry_waiting_turn_details(
+        self,
+        quest_id: str,
+        *,
+        snapshot: dict | None,
+        turn_state: dict[str, object] | None,
+        turn_reason: str,
+    ) -> dict[str, Any] | None:
+        if str(turn_reason or "").strip() != "user_message":
+            return None
+        snapshot = dict(snapshot or self.quest_service.snapshot(quest_id))
+        runtime_status = str(snapshot.get("runtime_status") or snapshot.get("status") or "").strip().lower()
+        if runtime_status != "running":
+            return None
+        state = dict(turn_state or self._refresh_turn_worker_state(quest_id))
+        if not state.get("running"):
+            return None
+        retry_state = snapshot.get("retry_state") if isinstance(snapshot.get("retry_state"), dict) else None
+        if not retry_state:
+            return None
+        next_retry_at = str(retry_state.get("next_retry_at") or "").strip()
+        if not next_retry_at:
+            return None
+        if str(snapshot.get("active_run_id") or "").strip():
+            return None
+        pending_user_count = int(snapshot.get("pending_user_message_count") or 0)
+        if pending_user_count <= 0:
+            return None
+        try:
+            attempt_index = int(retry_state.get("attempt_index") or 0)
+        except (TypeError, ValueError):
+            attempt_index = 0
+        try:
+            max_attempts = int(retry_state.get("max_attempts") or 0)
+        except (TypeError, ValueError):
+            max_attempts = 0
+        delay_seconds = self._recovery_retry_delay_seconds(snapshot) or 0.0
+        return {
+            "retry_state": dict(retry_state),
+            "attempt_index": attempt_index,
+            "max_attempts": max_attempts,
+            "pending_user_count": pending_user_count,
+            "delay_seconds": max(0.0, float(delay_seconds)),
+        }
+
+    def _interrupt_retry_wait_for_new_user_message(
+        self,
+        quest_id: str,
+        *,
+        snapshot: dict[str, Any],
+        turn_state: dict[str, object],
+        details: dict[str, Any],
+        source: str,
+    ) -> dict[str, Any] | None:
+        try:
+            restart = self._quiet_interrupt_for_turn_restart(quest_id, source=source)
+        except RuntimeError as exc:
+            self.logger.log(
+                "warning",
+                "runner.turn_retry_interrupt_failed",
+                quest_id=quest_id,
+                source=source,
+                error=str(exc),
+                pending_user_message_count=int(details.get("pending_user_count") or 0),
+            )
+            return None
+
+        retry_state = details.get("retry_state") if isinstance(details.get("retry_state"), dict) else {}
+        turn_id = str(retry_state.get("turn_id") or "").strip() or None
+        previous_run_id = str(retry_state.get("last_run_id") or "").strip() or None
+        attempt_index = max(0, int(details.get("attempt_index") or 0))
+        max_attempts = max(0, int(details.get("max_attempts") or 0))
+        pending_user_count = max(0, int(details.get("pending_user_count") or 0))
+        delay_seconds = max(0.0, float(details.get("delay_seconds") or 0.0))
+        runner_name = self._runner_name_for(snapshot)
+        skill_id = self._turn_skill_for(snapshot, None, turn_reason="user_message", turn_mode=self._turn_mode_for(snapshot, None, turn_reason="user_message"))
+        model = str((self.runners_config.get(runner_name) or {}).get("model", "gpt-5.4"))
+        summary = (
+            f"Retry wait aborted after attempt {attempt_index}/{max_attempts or attempt_index or 1} "
+            f"because a newer user message arrived. "
+            f"Pending queued user messages: {pending_user_count}. "
+            f"Skipped remaining backoff wait: {delay_seconds:.1f}s."
+        )
+        self.quest_service.update_runtime_state(
+            quest_root=self.quest_service._quest_root(quest_id),
+            retry_state=None,
+        )
+        self._append_retry_event(
+            quest_id,
+            event_type="runner.turn_retry_aborted",
+            runner_name=runner_name,
+            run_id=previous_run_id,
+            turn_id=turn_id,
+            skill_id=skill_id,
+            model=model,
+            attempt_index=attempt_index,
+            max_attempts=max_attempts,
+            summary=summary,
+            failure_summary=str(retry_state.get("last_error") or "").strip() or None,
+            previous_run_id=previous_run_id,
+        )
+        self._relay_quest_message_to_bound_connectors(
+            quest_id,
+            message=self._polite_copy(
+                zh="我收到新的用户消息，已中断上一轮等待中的自动重试，先优先处理最新要求。",
+                en="A new user message arrived, so I interrupted the pending retry wait and will handle the latest request first.",
+            ),
+            kind="system",
+            response_phase="update",
+            importance="normal",
+            attachments=[
+                {
+                    "kind": "retry_interrupted",
+                    "run_id": previous_run_id,
+                    "runner": runner_name,
+                    "turn_id": turn_id,
+                }
+            ],
+        )
+        return self.schedule_turn(quest_id, reason="user_message")
+
+    def submit_web_user_message(
+        self,
+        quest_id: str,
+        *,
+        text: str,
+        source: str,
+        attachment_draft_ids: list[str],
+        reply_to_interaction_id: str | None = None,
+        client_message_id: str | None = None,
+    ) -> dict:
+        finalized_attachments = self.quest_service.finalize_chat_attachment_drafts(
+            quest_id,
+            draft_ids=attachment_draft_ids,
+            client_message_id=client_message_id,
+        )
+        return self.submit_user_message(
+            quest_id,
+            text=text,
+            source=source,
+            attachments=finalized_attachments,
+            reply_to_interaction_id=reply_to_interaction_id,
+            client_message_id=client_message_id,
+        )
+
     def create_quest(
         self,
         *,
@@ -1578,10 +1925,13 @@ class DaemonApp:
         normalized_requested_bindings = self._normalize_requested_connector_bindings(requested_connector_bindings)
         if len(normalized_requested_bindings) > 1:
             raise ValueError("A quest may bind at most one external connector target.")
+        configured = self.config_manager.load_named("config")
+        default_runner = str(configured.get("default_runner") or "codex").strip().lower() or "codex"
         snapshot = self.quest_service.create(
             goal=goal,
             title=title,
             quest_id=quest_id,
+            runner=default_runner,
             requested_baseline_ref=dict(requested_baseline_ref) if isinstance(requested_baseline_ref, dict) else None,
             startup_contract=dict(startup_contract) if isinstance(startup_contract, dict) else None,
         )
@@ -1712,18 +2062,30 @@ class DaemonApp:
         return snapshot
 
     def schedule_turn(self, quest_id: str, *, reason: str = "user_message") -> dict:
+        snapshot = self.quest_service.snapshot(quest_id)
+        snapshot = self._reconcile_stale_active_turn(quest_id, snapshot=snapshot)
+        recovery = self._recover_stalled_running_turn(quest_id, snapshot=snapshot, turn_reason=reason)
+        snapshot = dict(recovery.get("snapshot") or snapshot)
+        if recovery.get("blocked"):
+            return {
+                "scheduled": True,
+                "started": False,
+                "queued": True,
+                "reason": "stalled_turn_recovery_pending",
+            }
         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
             state["stop_requested"] = False
+            state.pop("recovery_pending", None)
             state["reason"] = reason
             if state.get("running"):
                 return {
                     "scheduled": True,
                     "started": False,
                     "queued": True,
-                    "reason": reason,
+                    "reason": "queued_for_artifact_interact" if reason == "user_message" else reason,
                 }
             state["running"] = True
             worker = threading.Thread(
@@ -1804,6 +2166,110 @@ class DaemonApp:
                 state.pop("worker", None)
             return dict(state)
 
+    def _wait_for_turn_worker_exit(self, quest_id: str, *, timeout_seconds: float) -> dict[str, object]:
+        deadline = time.monotonic() + max(0.0, float(timeout_seconds))
+        state = self._refresh_turn_worker_state(quest_id)
+        while state.get("running") and time.monotonic() < deadline:
+            time.sleep(0.05)
+            state = self._refresh_turn_worker_state(quest_id)
+        return state
+
+    def _ensure_recovery_resume_watch(self, quest_id: str, *, turn_reason: str) -> None:
+        with self._turn_lock:
+            state = self._turn_state.setdefault(quest_id, {"running": False, "pending": False})
+            if state.get("recovery_watch_active"):
+                return
+            state["recovery_watch_active"] = True
+        watcher = threading.Thread(
+            target=self._wait_and_resume_recovered_turn,
+            args=(quest_id, turn_reason),
+            daemon=True,
+            name=f"deepscientist-recovery-watch-{quest_id}",
+        )
+        watcher.start()
+
+    def _wait_and_resume_recovered_turn(self, quest_id: str, turn_reason: str) -> None:
+        try:
+            while True:
+                state = self._refresh_turn_worker_state(quest_id)
+                if not state.get("recovery_pending"):
+                    return
+                if not state.get("running"):
+                    break
+                time.sleep(0.1)
+
+            snapshot = self.quest_service.snapshot(quest_id)
+            runtime_status = str(snapshot.get("runtime_status") or snapshot.get("status") or "").strip().lower()
+            if runtime_status in {"paused", "stopped", "completed", "error"}:
+                with self._turn_lock:
+                    state = self._turn_state.setdefault(quest_id, {"running": False, "pending": False})
+                    state.pop("recovery_pending", None)
+                    state["stop_requested"] = runtime_status in {"paused", "stopped"}
+                return
+            pending_user_count = int(snapshot.get("pending_user_message_count") or 0)
+            if pending_user_count > 0:
+                with self._turn_lock:
+                    state = self._turn_state.setdefault(quest_id, {"running": False, "pending": False})
+                    state.pop("recovery_pending", None)
+                self.schedule_turn(quest_id, reason=turn_reason)
+                return
+
+            with self._turn_lock:
+                state = self._turn_state.setdefault(quest_id, {"running": False, "pending": False})
+                state.pop("recovery_pending", None)
+                state["stop_requested"] = False
+        except Exception as exc:
+            self.logger.log(
+                "warning",
+                "quest.turn_state_recovery_watch_failed",
+                quest_id=quest_id,
+                reason=turn_reason,
+                error=str(exc),
+            )
+        finally:
+            with self._turn_lock:
+                state = self._turn_state.setdefault(quest_id, {"running": False, "pending": False})
+                state.pop("recovery_watch_active", None)
+
+    def _stalled_running_turn_details(
+        self,
+        quest_id: str,
+        *,
+        snapshot: dict | None = None,
+        turn_state: dict[str, object] | None = None,
+        turn_reason: str,
+    ) -> dict[str, int] | None:
+        if str(turn_reason or "").strip() not in {"user_message", "queued_user_messages"}:
+            return None
+        snapshot = dict(snapshot or self.quest_service.snapshot(quest_id))
+        runtime_status = str(snapshot.get("runtime_status") or snapshot.get("status") or "").strip().lower()
+        active_run_id = str(snapshot.get("active_run_id") or "").strip()
+        if runtime_status != "running" or not active_run_id:
+            return None
+        state = dict(turn_state or self._refresh_turn_worker_state(quest_id))
+        if not state.get("running"):
+            return None
+        pending_user_count = int(snapshot.get("pending_user_message_count") or 0)
+        if pending_user_count <= 0:
+            return None
+        counts = snapshot.get("counts") if isinstance(snapshot.get("counts"), dict) else {}
+        if int(counts.get("bash_running_count") or 0) > 0:
+            return None
+        silent_seconds = snapshot.get("seconds_since_last_tool_activity")
+        if silent_seconds is None:
+            watchdog = snapshot.get("interaction_watchdog") if isinstance(snapshot.get("interaction_watchdog"), dict) else {}
+            silent_seconds = watchdog.get("seconds_since_last_tool_activity")
+        try:
+            silent_seconds_int = int(silent_seconds or 0)
+        except (TypeError, ValueError):
+            return None
+        if silent_seconds_int < _STALLED_RUNNING_TURN_INACTIVITY_SECONDS:
+            return None
+        return {
+            "pending_user_count": pending_user_count,
+            "silent_seconds": silent_seconds_int,
+        }
+
     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()
@@ -1855,6 +2321,139 @@ class DaemonApp:
         )
         return self.quest_service.mark_turn_finished(quest_id, status=normalized_status)
 
+    def _recover_stalled_running_turn(
+        self,
+        quest_id: str,
+        *,
+        snapshot: dict | None = None,
+        turn_reason: str,
+    ) -> dict[str, object]:
+        snapshot = dict(snapshot or self.quest_service.snapshot(quest_id))
+        turn_state = self._refresh_turn_worker_state(quest_id)
+        with self._turn_lock:
+            state = self._turn_state.setdefault(quest_id, {"running": False, "pending": False})
+            if state.get("recovery_pending"):
+                return {
+                    "snapshot": snapshot,
+                    "blocked": True,
+                }
+        details = self._stalled_running_turn_details(
+            quest_id,
+            snapshot=snapshot,
+            turn_state=turn_state,
+            turn_reason=turn_reason,
+        )
+        if details is None:
+            return {
+                "snapshot": snapshot,
+                "blocked": False,
+            }
+
+        active_run_id = str(snapshot.get("active_run_id") or "").strip()
+        runner_name = self._runner_name_for(snapshot)
+        with self._turn_lock:
+            state = self._turn_state.setdefault(quest_id, {"running": False, "pending": False})
+            if state.get("recovery_pending"):
+                return {
+                    "snapshot": snapshot,
+                    "blocked": True,
+                }
+            state["pending"] = False
+            state["stop_requested"] = True
+            state["recovery_pending"] = True
+        interrupted = False
+        try:
+            try:
+                runner = self.get_runner(runner_name)
+            except KeyError:
+                runner = None
+            if runner is not None and hasattr(runner, "interrupt"):
+                interrupted = bool(getattr(runner, "interrupt")(quest_id))
+            stopped_bash_session_ids = self._stop_active_bash_exec_sessions(
+                quest_id,
+                run_id=active_run_id or None,
+                reason="stalled_turn_recovery",
+                user_id="auto:stalled-turn-recovery",
+            )
+            turn_state = self._wait_for_turn_worker_exit(
+                quest_id,
+                timeout_seconds=_STALLED_RUNNING_TURN_INTERRUPT_TIMEOUT_SECONDS,
+            )
+            if turn_state.get("running"):
+                self._ensure_recovery_resume_watch(quest_id, turn_reason="queued_user_messages")
+                self.logger.log(
+                    "warning",
+                    "quest.turn_state_recovery_pending",
+                    quest_id=quest_id,
+                    abandoned_run_id=active_run_id or None,
+                    reason=turn_reason,
+                    silent_seconds=int(details.get("silent_seconds") or 0),
+                    pending_user_message_count=int(details.get("pending_user_count") or 0),
+                    interrupted=interrupted,
+                )
+                return {
+                    "snapshot": snapshot,
+                    "blocked": True,
+                }
+
+            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"Recovered stalled running turn `{active_run_id}` after "
+                f"{int(details.get('silent_seconds') or 0)} seconds without tool activity while "
+                f"{int(details.get('pending_user_count') or 0)} queued user message(s) were waiting."
+            )
+            if interrupted:
+                summary = f"{summary} The active runner process was interrupted."
+            if stopped_bash_session_ids:
+                summary = f"{summary} Stopped {len(stopped_bash_session_ids)} bash_exec session(s)."
+            quest_root = self.quest_service._quest_root(quest_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 or None,
+                    "previous_status": previous_status,
+                    "status": normalized_status,
+                    "completed_at": None,
+                    "exit_code": None,
+                    "summary": summary,
+                    "recovery_kind": "stalled_live_turn",
+                    "interrupted": interrupted,
+                    "stopped_bash_session_ids": stopped_bash_session_ids,
+                    "created_at": utc_now(),
+                },
+            )
+            self.logger.log(
+                "warning",
+                "quest.turn_state_reconciled",
+                quest_id=quest_id,
+                abandoned_run_id=active_run_id or None,
+                previous_status=previous_status,
+                status=normalized_status,
+                recovery_kind="stalled_live_turn",
+                interrupted=interrupted,
+                stopped_bash_session_count=len(stopped_bash_session_ids),
+            )
+            snapshot = self.quest_service.mark_turn_finished(quest_id, status=normalized_status)
+            with self._turn_lock:
+                state = self._turn_state.setdefault(quest_id, {"running": False, "pending": False})
+                state.pop("recovery_pending", None)
+            return {
+                "snapshot": snapshot,
+                "blocked": False,
+            }
+        except Exception:
+            with self._turn_lock:
+                state = self._turn_state.setdefault(quest_id, {"running": False, "pending": False})
+                state.pop("recovery_pending", None)
+            raise
+
     def control_quest(self, quest_id: str, *, action: str, source: str = "local") -> dict:
         normalized_action = str(action or "").strip().lower()
         if normalized_action == "pause":
@@ -1927,25 +2526,319 @@ class DaemonApp:
         )
         notice = self._announce_control_state(
             quest_id,
-            action=action,
+            action=action,
+            source=source,
+            snapshot=snapshot,
+            interrupted=interrupted,
+            cancelled_pending_user_message_count=cancelled_count,
+            previous_snapshot=previous_snapshot,
+        )
+        return {
+            "ok": True,
+            "quest_id": quest_id,
+            "action": action,
+            "interrupted": interrupted,
+            "cancelled_pending_user_message_count": cancelled_count,
+            "stopped_bash_session_ids": stopped_bash_session_ids,
+            "snapshot": snapshot,
+            "message": summary,
+            "event": event,
+            "notice": notice,
+        }
+
+    def _quiet_interrupt_for_turn_restart(self, quest_id: str, *, source: str) -> dict[str, Any]:
+        snapshot = self.quest_service.snapshot(quest_id)
+        snapshot = self._reconcile_stale_active_turn(quest_id, snapshot=snapshot)
+        runner_name = self._runner_name_for(snapshot)
+        active_run_id = str(snapshot.get("active_run_id") or "").strip() or None
+        turn_state = self._refresh_turn_worker_state(quest_id)
+        runtime_status = str(snapshot.get("runtime_status") or snapshot.get("status") or "").strip().lower()
+        if not active_run_id and not turn_state.get("running"):
+            if runtime_status in {"stopped", "paused", "completed", "error"}:
+                snapshot = self.quest_service.set_status(quest_id, "active")
+            return {
+                "snapshot": snapshot,
+                "interrupted": False,
+                "stopped_bash_session_ids": [],
+            }
+
+        interrupted = False
+        try:
+            runner = self.get_runner(runner_name)
+        except KeyError:
+            runner = None
+        with self._turn_lock:
+            state = self._turn_state.setdefault(quest_id, {"running": False, "pending": False})
+            state["pending"] = False
+            state["stop_requested"] = True
+        runner_supports_interrupt = runner is not None and hasattr(runner, "interrupt")
+        if runner_supports_interrupt:
+            interrupted = bool(getattr(runner, "interrupt")(quest_id))
+        stopped_bash_session_ids = self._stop_active_bash_exec_sessions(
+            quest_id,
+            run_id=active_run_id,
+            reason="immediate_read",
+            user_id=source,
+        )
+        turn_state = self._wait_for_turn_worker_exit(
+            quest_id,
+            timeout_seconds=_IMMEDIATE_READ_INTERRUPT_TIMEOUT_SECONDS,
+        )
+        if turn_state.get("running"):
+            detail_parts = [
+                f"runner={runner_name or 'unknown'}",
+                f"interrupt_attempted={runner_supports_interrupt}",
+                f"interrupt_returned={interrupted}",
+                f"active_run_id={active_run_id or 'none'}",
+                f"runtime_status={runtime_status or 'unknown'}",
+                f"timeout_seconds={_IMMEDIATE_READ_INTERRUPT_TIMEOUT_SECONDS:g}",
+            ]
+            worker = turn_state.get("worker")
+            if isinstance(worker, threading.Thread):
+                detail_parts.append(f"worker_alive={worker.is_alive()}")
+                detail_parts.append(f"worker_name={worker.name}")
+            stopped_count = len(stopped_bash_session_ids)
+            if stopped_count > 0:
+                detail_parts.append(f"stopped_bash_sessions={stopped_count}")
+            if runner is None:
+                detail_parts.append("reason=runner_not_available")
+            elif not runner_supports_interrupt:
+                detail_parts.append("reason=runner_has_no_interrupt")
+            elif not interrupted:
+                detail_parts.append("reason=runner_interrupt_returned_false")
+            else:
+                detail_parts.append("reason=worker_did_not_exit_before_timeout")
+            raise RuntimeError(
+                "The active agent turn could not be interrupted for immediate read. "
+                + "; ".join(detail_parts)
+            )
+        normalized_status = "active" if runtime_status == "running" else (runtime_status or "active")
+        if normalized_status in {"stopped", "paused", "completed", "error"}:
+            snapshot = self.quest_service.set_status(quest_id, "active")
+        else:
+            snapshot = self.quest_service.mark_turn_finished(quest_id, status=normalized_status)
+        with self._turn_lock:
+            state = self._turn_state.setdefault(quest_id, {"running": False, "pending": False})
+            state["stop_requested"] = False
+            state["running"] = False
+            state.pop("worker", None)
+        return {
+            "snapshot": snapshot,
+            "interrupted": interrupted,
+            "stopped_bash_session_ids": stopped_bash_session_ids,
+        }
+
+    def read_queued_user_messages_now(
+        self,
+        quest_id: str,
+        *,
+        message_id: str | None = None,
+        client_message_id: str | None = None,
+        source: str = "local",
+    ) -> dict[str, Any]:
+        snapshot = self.quest_service.snapshot(quest_id)
+        snapshot = self._reconcile_stale_active_turn(quest_id, snapshot=snapshot)
+        quest_root = self.quest_service._quest_root(quest_id)
+        target_message_id = str(message_id or "").strip() or None
+        target_client_message_id = str(client_message_id or "").strip() or None
+        if target_message_id or target_client_message_id:
+            status_payload = self.quest_service.pending_user_message_status(
+                quest_root,
+                message_id=target_message_id,
+                client_message_id=target_client_message_id,
+            )
+            queue_state = str(status_payload.get("queue_state") or "missing")
+            current_message_state = (
+                dict(status_payload.get("message_state") or {})
+                if isinstance(status_payload.get("message_state"), dict)
+                else None
+            )
+            if queue_state == "read":
+                return {
+                    "ok": True,
+                    "status": "already_read",
+                    "quest_id": quest_id,
+                    "message": "This message was already sent to the agent.",
+                    "message_ids": [target_message_id] if target_message_id else [],
+                    "client_message_ids": [target_client_message_id] if target_client_message_id else [],
+                    "current_message_state": current_message_state,
+                    "snapshot": snapshot,
+                }
+            if queue_state == "withdrawn":
+                return {
+                    "ok": False,
+                    "status": "withdrawn",
+                    "quest_id": quest_id,
+                    "message": "This message was already withdrawn from the waiting queue.",
+                    "message_ids": [target_message_id] if target_message_id else [],
+                    "client_message_ids": [target_client_message_id] if target_client_message_id else [],
+                    "current_message_state": current_message_state,
+                    "snapshot": snapshot,
+                }
+            if queue_state == "missing":
+                target_label = target_message_id or f"client:{target_client_message_id}"
+                return {
+                    "ok": False,
+                    "status": "missing",
+                    "quest_id": quest_id,
+                    "message": f"Message `{target_label}` is not waiting in the queue.",
+                    "message_ids": [target_message_id] if target_message_id else [],
+                    "client_message_ids": [target_client_message_id] if target_client_message_id else [],
+                    "current_message_state": current_message_state,
+                    "snapshot": snapshot,
+                }
+        queue_payload = self.quest_service._read_message_queue(quest_root)
+        pending = [dict(item) for item in (queue_payload.get("pending") or [])]
+        runtime_status = str(snapshot.get("runtime_status") or snapshot.get("status") or "").strip().lower()
+        self.logger.log(
+            "info",
+            "quest.user_message.read_now.requested",
+            quest_id=quest_id,
+            source=source,
+            message_id=target_message_id,
+            client_message_id=target_client_message_id,
+            pending_user_message_count=len(pending),
+            runtime_status=runtime_status or None,
+        )
+        if not pending:
+            return {
+                "ok": False,
+                "status": "empty",
+                "quest_id": quest_id,
+                "message": "No unread user message is waiting in the queue.",
+                "snapshot": snapshot,
+            }
+
+        try:
+            restart = self._quiet_interrupt_for_turn_restart(quest_id, source=source)
+        except RuntimeError as exc:
+            failed_message_ids = (
+                [target_message_id]
+                if target_message_id
+                else [
+                    str(item.get("message_id") or "").strip()
+                    for item in pending
+                    if str(item.get("message_id") or "").strip()
+                ]
+            )
+            self.logger.log(
+                "warning",
+                "quest.user_message.read_now.interrupt_failed",
+                quest_id=quest_id,
+                source=source,
+                message_id=target_message_id,
+                client_message_id=target_client_message_id,
+                pending_user_message_count=len(pending),
+                error=str(exc),
+            )
+            return {
+                "ok": False,
+                "status": "interrupt_failed",
+                "quest_id": quest_id,
+                "message": str(exc),
+                "message_ids": failed_message_ids,
+                "snapshot": snapshot,
+            }
+        mailbox_payload = self.quest_service.consume_pending_user_messages(
+            quest_root,
+            interaction_id=None,
+            delivery_reason="immediate_read",
+        )
+        recent_inbound_messages = [
+            dict(item)
+            for item in (mailbox_payload.get("recent_inbound_messages") or [])
+            if isinstance(item, dict)
+        ]
+        if not recent_inbound_messages:
+            return {
+                "ok": False,
+                "quest_id": quest_id,
+                "message": "No unread user message remained after the restart.",
+            }
+
+        self.quest_service.set_turn_message_override(
+            quest_root,
+            turn_reason="immediate_read",
+            message=str(mailbox_payload.get("agent_instruction") or "").strip(),
+            message_ids=[
+                str(item.get("message_id") or "").strip()
+                for item in recent_inbound_messages
+                if str(item.get("message_id") or "").strip()
+            ],
+            delivery_batch_id=str(((mailbox_payload.get("delivery_batch") or {}).get("batch_id") or "")).strip() or None,
+            source=source,
+        )
+        post_snapshot = self.quest_service.snapshot(quest_id)
+        runtime_status = str(post_snapshot.get("runtime_status") or post_snapshot.get("status") or "").strip().lower()
+        if runtime_status in {"stopped", "paused", "completed", "error"}:
+            post_snapshot = self.quest_service.set_status(quest_id, "active")
+        scheduling = self.schedule_turn(quest_id, reason="immediate_read")
+        message_states = [
+            dict(item)
+            for item in (mailbox_payload.get("message_states") or [])
+            if isinstance(item, dict)
+        ]
+        self.logger.log(
+            "info",
+            "quest.user_message.read_now.scheduled",
+            quest_id=quest_id,
+            source=source,
+            message_ids=[
+                str(item.get("message_id") or "").strip()
+                for item in recent_inbound_messages
+                if str(item.get("message_id") or "").strip()
+            ],
+            client_message_ids=[
+                str(item.get("client_message_id") or "").strip()
+                for item in recent_inbound_messages
+                if str(item.get("client_message_id") or "").strip()
+            ],
+            scheduled=bool(scheduling.get("scheduled")),
+            started=bool(scheduling.get("started")),
+            queued=bool(scheduling.get("queued")),
+            interrupted=bool(restart.get("interrupted")),
+        )
+        return {
+            "ok": True,
+            "status": "scheduled",
+            "quest_id": quest_id,
+            "snapshot": self.quest_service.snapshot(quest_id),
+            "message_ids": [
+                str(item.get("message_id") or "").strip()
+                for item in recent_inbound_messages
+                if str(item.get("message_id") or "").strip()
+            ],
+            "client_message_ids": [
+                str(item.get("client_message_id") or "").strip()
+                for item in recent_inbound_messages
+                if str(item.get("client_message_id") or "").strip()
+            ],
+            "message_states": message_states,
+            "current_message_state": message_states[0] if message_states else None,
+            "delivery_batch": mailbox_payload.get("delivery_batch"),
+            "recent_inbound_messages": recent_inbound_messages,
+            "interrupted": bool(restart.get("interrupted")),
+            "stopped_bash_session_ids": list(restart.get("stopped_bash_session_ids") or []),
+            "message": "Queued user messages were forced into an immediate-read turn.",
+            **scheduling,
+        }
+
+    def withdraw_queued_user_message(
+        self,
+        quest_id: str,
+        *,
+        message_id: str,
+        source: str = "local",
+    ) -> dict[str, Any]:
+        quest_root = self.quest_service._quest_root(quest_id)
+        result = self.quest_service.withdraw_pending_user_message(
+            quest_id,
+            message_id=message_id,
             source=source,
-            snapshot=snapshot,
-            interrupted=interrupted,
-            cancelled_pending_user_message_count=cancelled_count,
-            previous_snapshot=previous_snapshot,
         )
-        return {
-            "ok": True,
-            "quest_id": quest_id,
-            "action": action,
-            "interrupted": interrupted,
-            "cancelled_pending_user_message_count": cancelled_count,
-            "stopped_bash_session_ids": stopped_bash_session_ids,
-            "snapshot": snapshot,
-            "message": summary,
-            "event": event,
-            "notice": notice,
-        }
+        result.setdefault("quest_id", quest_id)
+        result["snapshot"] = self.quest_service.snapshot(quest_id)
+        return result
 
     def _stop_active_bash_exec_sessions(
         self,
@@ -2010,6 +2903,23 @@ class DaemonApp:
             last_recovery_abandoned_run_id=recovery_abandoned_run_id,
             last_recovery_summary=recovery_summary,
         )
+        scheduling: dict[str, Any] | None = None
+        if not source.startswith("auto:"):
+            if int(snapshot.get("pending_user_message_count") or 0) > 0:
+                scheduling = self.schedule_turn(quest_id, reason="queued_user_messages")
+            else:
+                continue_payload = self.submit_user_message(
+                    quest_id,
+                    text=_RESUME_CONTINUE_TEXT,
+                    source=self._resume_continue_source(source),
+                )
+                scheduling = {
+                    "scheduled": bool(continue_payload.get("scheduled")),
+                    "started": bool(continue_payload.get("started")),
+                    "queued": bool(continue_payload.get("queued")),
+                    "reason": str(continue_payload.get("reason") or "user_message"),
+                    "resume_trigger_message": continue_payload.get("message"),
+                }
         summary = f"Quest {quest_id} resumed."
         event = self._append_control_event(
             quest_id,
@@ -2038,6 +2948,7 @@ class DaemonApp:
             "message": summary,
             "event": event,
             "notice": notice,
+            **(dict(scheduling or {})),
         }
 
     def _append_control_event(
@@ -2249,8 +3160,17 @@ class DaemonApp:
         runtime_status = str(snapshot.get("runtime_status") or snapshot.get("status") or "").strip()
         if runtime_status in {"stopped", "paused", "completed", "error"} and not snapshot.get("active_run_id"):
             return
-        latest_user_message = self._latest_user_message(quest_id)
-        if turn_reason != "auto_continue" and latest_user_message is None:
+        quest_root = Path(snapshot["quest_root"])
+        turn_override = (
+            self.quest_service.consume_turn_message_override(
+                quest_root,
+                expected_turn_reason=turn_reason,
+            )
+            if turn_reason == "immediate_read"
+            else None
+        )
+        latest_user_message = self._latest_actionable_user_message(quest_id, turn_reason=turn_reason)
+        if turn_reason not in {"auto_continue", "immediate_read"} and latest_user_message is None:
             return
 
         runner_name = self._runner_name_for(snapshot)
@@ -2262,7 +3182,11 @@ class DaemonApp:
         model = str(runner_cfg.get("model", "gpt-5.4"))
         run_message = ""
         claimed_message_id: str | None = None
-        if turn_reason != "auto_continue":
+        if turn_reason == "immediate_read":
+            run_message = str((turn_override or {}).get("message") or "").strip()
+            if not run_message:
+                return
+        elif turn_reason != "auto_continue":
             run_message = str((latest_user_message or {}).get("content") or "").strip()
             claimed_message_id = str((latest_user_message or {}).get("id") or "").strip() or None
             if not run_message:
@@ -2321,12 +3245,14 @@ class DaemonApp:
             )
         retry_policy = self._runner_retry_policy(runner_name, runner_cfg if isinstance(runner_cfg, dict) else {})
         max_attempts = int(retry_policy.get("max_attempts") or 1)
-        turn_id = generate_id("turn")
-        retry_context: dict[str, Any] | None = None
-        quest_root = Path(snapshot["quest_root"])
+        resumed_start_attempt, resumed_turn_id, retry_context = self._resume_retry_state(
+            snapshot,
+            max_attempts=max_attempts,
+        )
+        turn_id = resumed_turn_id or generate_id("turn")
         worktree_root = Path(str(snapshot["current_workspace_root"])) if snapshot.get("current_workspace_root") else None
 
-        for attempt_index in range(1, max_attempts + 1):
+        for attempt_index in range(resumed_start_attempt, max_attempts + 1):
             current_run_id = run_id if attempt_index == 1 else generate_id("run")
             if attempt_index > 1:
                 self._append_retry_event(
@@ -2395,6 +3321,31 @@ class DaemonApp:
                         previous_output_text="",
                         stderr_text=str(exc),
                     )
+                    diagnosis = self._non_retryable_failure_diagnosis(
+                        runner_name=runner_name,
+                        summary=failure_summary,
+                        stderr_text=str(exc),
+                        output_text="",
+                    )
+                    if diagnosis is not None:
+                        self.quest_service.update_runtime_state(
+                            quest_root=quest_root,
+                            continuation_policy="wait_for_user_or_resume",
+                            continuation_reason="non_retryable_runner_error",
+                            continuation_updated_at=utc_now(),
+                        )
+                        self._record_turn_error(
+                            quest_id=quest_id,
+                            runner_name=runner_name,
+                            run_id=current_run_id,
+                            skill_id=skill_id,
+                            model=model,
+                            summary=f"{diagnosis.problem} {failure_summary}".strip(),
+                            retry_state=None,
+                            diagnosis_code=diagnosis.code,
+                            guidance=list(diagnosis.guidance),
+                        )
+                        return
                     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)
@@ -2444,6 +3395,19 @@ class DaemonApp:
                         )
                         return
                     exhausted_summary = f"{failure_summary} Retry budget exhausted after {attempt_index} attempt(s)."
+                    diagnosis = self._runner_failure_diagnosis(
+                        runner_name=runner_name,
+                        summary=exhausted_summary,
+                        stderr_text=str(exc),
+                        output_text="",
+                    )
+                    if diagnosis is not None and diagnosis.retriable:
+                        self.quest_service.update_runtime_state(
+                            quest_root=quest_root,
+                            continuation_policy="wait_for_user_or_resume",
+                            continuation_reason=self._retry_exhausted_continuation_reason(diagnosis),
+                            continuation_updated_at=utc_now(),
+                        )
                     self._append_retry_event(
                         quest_id,
                         event_type="runner.turn_retry_exhausted",
@@ -2456,6 +3420,7 @@ class DaemonApp:
                         max_attempts=max_attempts,
                         summary=exhausted_summary,
                         failure_summary=failure_summary,
+                        diagnosis=diagnosis,
                     )
                     self._record_turn_error(
                         quest_id=quest_id,
@@ -2465,6 +3430,8 @@ class DaemonApp:
                         model=model,
                         summary=exhausted_summary,
                         retry_state=None,
+                        diagnosis_code=diagnosis.code if diagnosis is not None else None,
+                        guidance=list(diagnosis.guidance) if diagnosis is not None else None,
                     )
                     return
 
@@ -2543,6 +3510,31 @@ class DaemonApp:
                     previous_output_text=result.output_text,
                     stderr_text=result.stderr_text,
                 )
+                diagnosis = self._non_retryable_failure_diagnosis(
+                    runner_name=runner_name,
+                    summary=failure_summary,
+                    stderr_text=result.stderr_text,
+                    output_text=result.output_text,
+                )
+                if diagnosis is not None:
+                    self.quest_service.update_runtime_state(
+                        quest_root=quest_root,
+                        continuation_policy="wait_for_user_or_resume",
+                        continuation_reason="non_retryable_runner_error",
+                        continuation_updated_at=utc_now(),
+                    )
+                    self._record_turn_error(
+                        quest_id=quest_id,
+                        runner_name=runner_name,
+                        run_id=result.run_id,
+                        skill_id=skill_id,
+                        model=model,
+                        summary=f"{diagnosis.problem} {failure_summary}".strip(),
+                        retry_state=None,
+                        diagnosis_code=diagnosis.code,
+                        guidance=list(diagnosis.guidance),
+                    )
+                    return
                 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)
@@ -2593,6 +3585,19 @@ class DaemonApp:
                     return
 
                 exhausted_summary = f"{failure_summary} Retry budget exhausted after {attempt_index} attempt(s)."
+                diagnosis = self._runner_failure_diagnosis(
+                    runner_name=runner_name,
+                    summary=exhausted_summary,
+                    stderr_text=result.stderr_text,
+                    output_text=result.output_text,
+                )
+                if diagnosis is not None and diagnosis.retriable:
+                    self.quest_service.update_runtime_state(
+                        quest_root=quest_root,
+                        continuation_policy="wait_for_user_or_resume",
+                        continuation_reason=self._retry_exhausted_continuation_reason(diagnosis),
+                        continuation_updated_at=utc_now(),
+                    )
                 self._append_retry_event(
                     quest_id,
                     event_type="runner.turn_retry_exhausted",
@@ -2605,6 +3610,7 @@ class DaemonApp:
                     max_attempts=max_attempts,
                     summary=exhausted_summary,
                     failure_summary=failure_summary,
+                    diagnosis=diagnosis,
                 )
                 self._record_turn_error(
                     quest_id=quest_id,
@@ -2614,6 +3620,8 @@ class DaemonApp:
                     model=model,
                     summary=exhausted_summary,
                     retry_state=None,
+                    diagnosis_code=diagnosis.code if diagnosis is not None else None,
+                    guidance=list(diagnosis.guidance) if diagnosis is not None else None,
                 )
                 return
             finally:
@@ -2624,8 +3632,37 @@ class DaemonApp:
                 )
 
     def _runner_name_for(self, snapshot: dict) -> str:
+        return self._resolve_enabled_runner_name(snapshot)
+
+    def _resolve_enabled_runner_name(self, snapshot: dict, requested_runner: str | None = None) -> str:
         configured = self.config_manager.load_named("config")
-        return str(snapshot.get("runner") or configured.get("default_runner", "codex")).strip().lower()
+        candidates = [
+            requested_runner,
+            snapshot.get("runner"),
+            snapshot.get("default_runner"),
+            configured.get("default_runner", "codex"),
+            "codex",
+        ]
+        enabled: list[str] = []
+        seen_enabled: set[str] = set()
+        for name, cfg in self.runners_config.items():
+            normalized = str(name or "").strip().lower()
+            if not normalized or normalized in seen_enabled:
+                continue
+            seen_enabled.add(normalized)
+            if isinstance(cfg, dict) and cfg.get("enabled") is not False:
+                enabled.append(normalized)
+
+        checked: set[str] = set()
+        for raw in candidates:
+            normalized = str(raw or "").strip().lower()
+            if not normalized or normalized in checked:
+                continue
+            checked.add(normalized)
+            cfg = self.runners_config.get(normalized, {})
+            if isinstance(cfg, dict) and cfg.get("enabled") is not False:
+                return normalized
+        return enabled[0] if enabled else "codex"
 
     @staticmethod
     def _stage_state_fingerprint(snapshot: dict) -> str:
@@ -2699,14 +3736,54 @@ class DaemonApp:
                 return value
         return "autonomous"
 
+    @staticmethod
+    def _decision_policy_for(snapshot: dict) -> str:
+        startup_contract = snapshot.get("startup_contract")
+        if isinstance(startup_contract, dict):
+            value = str(startup_contract.get("decision_policy") or "").strip().lower()
+            if value in {"autonomous", "user_gated"}:
+                return value
+        return "user_gated"
+
+    def _auto_resume_wait_if_allowed(self, quest_id: str, snapshot: dict) -> tuple[dict, bool]:
+        if str(snapshot.get("continuation_policy") or "").strip().lower() != "wait_for_user_or_resume":
+            return snapshot, False
+        if self._decision_policy_for(snapshot) != "autonomous":
+            return snapshot, False
+        reason = str(snapshot.get("continuation_reason") or "").strip() or "wait_for_user_or_resume"
+        if reason in AUTONOMOUS_BLOCKING_WAIT_REASONS:
+            return snapshot, False
+        quest_root = self.quest_service._quest_root(quest_id)
+        message = self.quest_service.localized_copy(
+            quest_root=quest_root,
+            zh=f"【自动继续】系统检测到当前为无需询问模式，本次“等待反馈”已自动转换为继续执行。原因：{reason}。",
+            en=f"[Auto-resumed] This quest is in autonomous decision mode, so the waiting state was converted back to automatic continuation. Reason: {reason}.",
+        )
+        notice = {
+            "status": "auto_resumed",
+            "reason": reason,
+            "message": message,
+            "decision_policy": "autonomous",
+            "label": self.quest_service.localized_copy(quest_root=quest_root, zh="自动继续", en="Auto-resumed"),
+            "created_at": utc_now(),
+        }
+        self.quest_service.update_runtime_state(
+            quest_root=quest_root,
+            continuation_policy="auto",
+            continuation_reason=f"{reason}_auto_resumed",
+            waiting_notice=notice,
+        )
+        snapshot = self.quest_service.snapshot(quest_id)
+        return snapshot, True
+
     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"
+        if self._workspace_mode_for(snapshot) == "copilot":
+            return "wait_for_user_or_resume", "copilot_mode"
         return "auto", "autonomous_prepare_or_launch_long_run"
 
     @staticmethod
@@ -2736,6 +3813,29 @@ class DaemonApp:
 
         return skill
 
+    @staticmethod
+    def _direct_user_turn_skill(snapshot: dict) -> str:
+        available_stage_skills = current_standard_skills(repo_root())
+        workspace_mode = DaemonApp._workspace_mode_for(snapshot)
+        has_explicit_baseline_context = bool(
+            isinstance(snapshot.get("confirmed_baseline_ref"), dict)
+            or isinstance(snapshot.get("requested_baseline_ref"), dict)
+            or str(snapshot.get("active_baseline_id") or "").strip()
+        )
+        for candidate in (
+            str(snapshot.get("active_anchor") or "").strip(),
+            str(snapshot.get("continuation_anchor") or "").strip(),
+        ):
+            if candidate in available_stage_skills and candidate != "decision":
+                if workspace_mode == "copilot" and candidate == "baseline" and not has_explicit_baseline_context:
+                    continue
+                return DaemonApp._turn_skill_stage_gate(snapshot, candidate)
+        if workspace_mode == "copilot" and "scout" in available_stage_skills:
+            fallback = "scout"
+        else:
+            fallback = "baseline" if "baseline" in available_stage_skills else "scout"
+        return DaemonApp._turn_skill_stage_gate(snapshot, fallback)
+
     @staticmethod
     def _turn_skill_for(
         snapshot: dict,
@@ -2747,16 +3847,6 @@ class DaemonApp:
         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()
-            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 []):
@@ -2783,8 +3873,8 @@ class DaemonApp:
                 ):
                     return "decision"
                 if str(item.get("reply_mode") or "") == "threaded":
-                    if workspace_mode == "copilot":
-                        return copilot_default_skill()
+                    if workspace_mode == "copilot" or turn_mode in {"answering", "command_execution"}:
+                        return DaemonApp._direct_user_turn_skill(snapshot)
                     return DaemonApp._turn_skill_stage_gate(
                         snapshot,
                         DaemonApp._continuation_anchor_for(snapshot),
@@ -2792,9 +3882,9 @@ class DaemonApp:
         if turn_mode == "recovering":
             return "decision"
         if workspace_mode == "copilot" and latest_user_message is not None:
-            return copilot_default_skill()
+            return DaemonApp._direct_user_turn_skill(snapshot)
         if turn_mode in {"answering", "command_execution"}:
-            return "decision"
+            return DaemonApp._direct_user_turn_skill(snapshot)
         if str(turn_reason or "").strip() == "auto_continue" or latest_user_message is None:
             return DaemonApp._turn_skill_stage_gate(
                 snapshot,
@@ -2818,6 +3908,14 @@ class DaemonApp:
                 return item
         return None
 
+    def _latest_actionable_user_message(self, quest_id: str, *, turn_reason: str) -> dict | None:
+        normalized_reason = str(turn_reason or "").strip() or "user_message"
+        if normalized_reason in {"user_message", "queued_user_messages"}:
+            pending_message = self.quest_service.latest_pending_user_message(quest_id)
+            if pending_message is not None:
+                return pending_message
+        return self._latest_user_message(quest_id)
+
     @staticmethod
     def _runner_binary_issue(runner_name: str, runner: object) -> str | None:
         binary = getattr(runner, "binary", None)
@@ -2896,6 +3994,14 @@ class DaemonApp:
             initial_backoff = CODEX_RETRY_DEFAULT_INITIAL_BACKOFF_SEC
             multiplier = CODEX_RETRY_DEFAULT_BACKOFF_MULTIPLIER
             max_backoff = CODEX_RETRY_DEFAULT_MAX_BACKOFF_SEC
+        if (
+            runner_name == "codex"
+            and max_attempts == PREVIOUS_CODEX_RETRY_DEFAULT_MAX_ATTEMPTS
+            and self._float_matches(initial_backoff, CODEX_RETRY_DEFAULT_INITIAL_BACKOFF_SEC)
+            and self._float_matches(multiplier, CODEX_RETRY_DEFAULT_BACKOFF_MULTIPLIER)
+            and self._float_matches(max_backoff, CODEX_RETRY_DEFAULT_MAX_BACKOFF_SEC)
+        ):
+            max_attempts = CODEX_RETRY_DEFAULT_MAX_ATTEMPTS
         return {
             "enabled": enabled,
             "max_attempts": max_attempts,
@@ -2954,6 +4060,7 @@ class DaemonApp:
         backoff_seconds: float | None = None,
         next_attempt_index: int | None = None,
         previous_run_id: str | None = None,
+        diagnosis: FailureDiagnosis | None = None,
     ) -> dict[str, Any]:
         payload = {
             "event_id": generate_id("evt"),
@@ -2977,6 +4084,9 @@ class DaemonApp:
             payload["next_attempt_index"] = next_attempt_index
         if previous_run_id:
             payload["previous_run_id"] = previous_run_id
+        if diagnosis is not None:
+            payload["diagnosis_code"] = diagnosis.code
+            payload["diagnosis"] = self._failure_diagnosis_payload(diagnosis)
         append_jsonl(self.home / "quests" / quest_id / ".ds" / "events.jsonl", payload)
         self.logger.log(
             "warning" if "scheduled" in event_type or "exhausted" in event_type else "info",
@@ -2990,6 +4100,7 @@ class DaemonApp:
             backoff_seconds=backoff_seconds,
             next_attempt_index=next_attempt_index,
             previous_run_id=previous_run_id,
+            diagnosis_code=diagnosis.code if diagnosis is not None else None,
         )
         return payload
 
@@ -3108,8 +4219,11 @@ class DaemonApp:
         summary: str,
         display_status: str = "error",
         retry_state: dict[str, Any] | None = None,
+        diagnosis_code: str | None = None,
+        guidance: list[str] | None = None,
     ) -> None:
         quest_root = self.home / "quests" / quest_id
+        normalized_guidance = [str(line) for line in (guidance or []) if str(line).strip()]
         append_jsonl(
             quest_root / ".ds" / "events.jsonl",
             {
@@ -3121,6 +4235,8 @@ class DaemonApp:
                 "skill_id": skill_id,
                 "model": model,
                 "summary": summary,
+                "diagnosis_code": str(diagnosis_code or "").strip() or None,
+                "guidance": normalized_guidance,
                 "created_at": utc_now(),
             },
         )
@@ -3131,6 +4247,23 @@ class DaemonApp:
             active_run_id=None,
             retry_state=retry_state,
         )
+        runner_label = self._connector_runner_label(runner_name)
+        user_notice = self._polite_copy(
+            zh=f"DeepScientist 意外停止运行，请检查你所绑定的{runner_label}是否能够顺利连接。",
+            en=f"DeepScientist stopped unexpectedly. Please check whether the bound {runner_label} can connect normally.",
+        )
+        notice_message = "\n".join([user_notice, "", summary]).strip()
+        if normalized_guidance:
+            notice_message = "\n".join(
+                [
+                    user_notice,
+                    "",
+                    summary,
+                    "",
+                    "Suggested fix:",
+                    *[f"- {line}" for line in normalized_guidance[:3]],
+                ]
+            ).strip()
         self.logger.log(
             "error",
             "runner.turn_error",
@@ -3143,7 +4276,7 @@ class DaemonApp:
         )
         self._relay_quest_message_to_bound_connectors(
             quest_id,
-            message=summary,
+            message=notice_message,
             kind="error",
             response_phase="final",
             importance="warning",
@@ -3154,10 +4287,63 @@ class DaemonApp:
                     "skill_id": skill_id,
                     "runner": runner_name,
                     "model": model,
+                    "diagnosis_code": str(diagnosis_code or "").strip() or None,
                 }
             ],
         )
 
+    @staticmethod
+    def _failure_diagnosis_payload(diagnosis: FailureDiagnosis) -> dict[str, Any]:
+        fix = [str(line) for line in diagnosis.guidance if str(line).strip()]
+        return {
+            "code": diagnosis.code,
+            "problem": diagnosis.problem,
+            "why": diagnosis.why,
+            "fix": fix,
+            "guidance": fix,
+            "retriable": bool(diagnosis.retriable),
+            "matched_text": diagnosis.matched_text,
+        }
+
+    @staticmethod
+    def _runner_failure_diagnosis(
+        *,
+        runner_name: str,
+        summary: str,
+        stderr_text: str,
+        output_text: str,
+    ) -> FailureDiagnosis | None:
+        return diagnose_runner_failure(
+            runner_name=runner_name,
+            summary=summary,
+            stderr_text=stderr_text,
+            output_text=output_text,
+        )
+
+    @staticmethod
+    def _non_retryable_failure_diagnosis(
+        *,
+        runner_name: str,
+        summary: str,
+        stderr_text: str,
+        output_text: str,
+    ) -> FailureDiagnosis | None:
+        diagnosis = DaemonApp._runner_failure_diagnosis(
+            runner_name=runner_name,
+            summary=summary,
+            stderr_text=stderr_text,
+            output_text=output_text,
+        )
+        if diagnosis is None or diagnosis.retriable:
+            return None
+        return diagnosis
+
+    @staticmethod
+    def _retry_exhausted_continuation_reason(diagnosis: FailureDiagnosis) -> str:
+        if diagnosis.code == "codex_upstream_provider_error":
+            return "external_codex_upstream_provider_error"
+        return "runner_retry_budget_exhausted"
+
     def _record_turn_postprocess_warning(
         self,
         *,
@@ -3289,11 +4475,13 @@ class DaemonApp:
                 self.schedule_turn(quest_id, reason="queued_user_messages")
             else:
                 continuation_policy = str(snapshot.get("continuation_policy") or "auto").strip().lower() or "auto"
+                resolved_external_progress = False
                 if continuation_policy == "auto":
                     continuation_policy, continuation_reason = self._resolve_continuation_policy(
                         snapshot,
                         current_policy=continuation_policy,
                     )
+                    resolved_external_progress = continuation_policy == "when_external_progress"
                     self.quest_service.update_runtime_state(
                         quest_root=self.quest_service._quest_root(quest_id),
                         continuation_policy=continuation_policy,
@@ -3311,12 +4499,22 @@ class DaemonApp:
         if int(snapshot.get("pending_user_message_count") or 0) > 0:
             self.schedule_turn(quest_id, reason="queued_user_messages")
             return
+        snapshot, auto_resumed_wait = self._auto_resume_wait_if_allowed(quest_id, snapshot)
+        if auto_resumed_wait:
+            self._schedule_turn_later(
+                quest_id,
+                reason="auto_continue",
+                delay_seconds=self._auto_continue_delay_for_policy("auto"),
+            )
+            return
         continuation_policy = str(snapshot.get("continuation_policy") or "auto").strip().lower() or "auto"
+        resolved_external_progress = False
         if continuation_policy == "auto":
             continuation_policy, continuation_reason = self._resolve_continuation_policy(
                 snapshot,
                 current_policy=continuation_policy,
             )
+            resolved_external_progress = continuation_policy == "when_external_progress"
             self.quest_service.update_runtime_state(
                 quest_root=self.quest_service._quest_root(quest_id),
                 continuation_policy=continuation_policy,
@@ -3329,7 +4527,7 @@ class DaemonApp:
         if continuation_policy == "wait_for_user_or_resume":
             return
         if continuation_policy == "when_external_progress":
-            if not self._has_external_progress(snapshot):
+            if not resolved_external_progress and 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(
@@ -3361,11 +4559,13 @@ class DaemonApp:
             if status in {"completed", "paused", "stopped", "error", "waiting_for_user"}:
                 return
             continuation_policy = str(snapshot.get("continuation_policy") or "auto").strip().lower() or "auto"
+            resolved_external_progress = False
             if continuation_policy == "auto":
                 continuation_policy, continuation_reason = self._resolve_continuation_policy(
                     snapshot,
                     current_policy=continuation_policy,
                 )
+                resolved_external_progress = continuation_policy == "when_external_progress"
                 self.quest_service.update_runtime_state(
                     quest_root=self.quest_service._quest_root(quest_id),
                     continuation_policy=continuation_policy,
@@ -3373,10 +4573,15 @@ class DaemonApp:
                     continuation_updated_at=utc_now(),
                 )
                 snapshot = self.quest_service.snapshot(quest_id)
+            snapshot, auto_resumed_wait = self._auto_resume_wait_if_allowed(quest_id, snapshot)
+            if auto_resumed_wait:
+                self.schedule_turn(quest_id, reason=reason)
+                return
+            continuation_policy = str(snapshot.get("continuation_policy") or "auto").strip().lower() or "auto"
             if continuation_policy in {"none", "wait_for_user_or_resume"}:
                 return
             if continuation_policy == "when_external_progress":
-                if not self._has_external_progress(snapshot):
+                if not resolved_external_progress and 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(
@@ -3400,16 +4605,18 @@ class DaemonApp:
         quest_id = str(snapshot.get("quest_id") or "").strip()
         if not quest_id:
             return False
+        counts = snapshot.get("counts") if isinstance(snapshot.get("counts"), dict) else {}
         try:
             quest_root = self.quest_service._quest_root(quest_id)
         except FileNotFoundError:
-            return False
+            return int(counts.get("bash_running_count") or 0) > 0
         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))
+            if any(str(item.get("status") or "").strip().lower() == "running" for item in sessions if isinstance(item, dict)):
+                return True
         except Exception:
-            counts = snapshot.get("counts") if isinstance(snapshot.get("counts"), dict) else {}
-            return int(counts.get("bash_running_count") or 0) > 0
+            pass
+        return int(counts.get("bash_running_count") or 0) > 0
 
     def _relay_quest_message_to_bound_connectors(
         self,
@@ -3467,6 +4674,7 @@ class DaemonApp:
         self._shutdown_requested.set()
         self._stop_background_connectors()
         self._stop_terminal_attach_server()
+        self.admin_service.system_monitor.stop()
         self.bash_exec_service.shutdown()
         self.logger.log(
             "info",
@@ -4215,10 +5423,21 @@ class DaemonApp:
         removed_conversations = self._unbind_external_bindings(quest_id)
         self.sessions.forget(quest_id)
 
-        try:
-            shutil.rmtree(quest_root)
-        except FileNotFoundError:
-            return {"ok": True, "quest_id": quest_id, "deleted": False}
+        last_delete_error: OSError | None = None
+        for attempt in range(5):
+            try:
+                shutil.rmtree(quest_root)
+                last_delete_error = None
+                break
+            except FileNotFoundError:
+                return {"ok": True, "quest_id": quest_id, "deleted": False}
+            except OSError as exc:
+                last_delete_error = exc
+                if exc.errno not in {errno.ENOTEMPTY, errno.EBUSY} or attempt == 4:
+                    raise
+                time.sleep(0.05 * (attempt + 1))
+        if last_delete_error is not None and quest_root.exists():
+            raise last_delete_error
 
         self.logger.log(
             "info",
@@ -4333,11 +5552,17 @@ class DaemonApp:
                     exclude_conversation_id=conversation_id,
                 )
                 self.update_quest_binding(created["quest_id"], binding_conversation_id, force=True)
-                self.submit_user_message(
+                startup = self.submit_user_message(
                     created["quest_id"],
                     text=goal_text,
                     source=conversation_id,
                 )
+                created_snapshot = self.quest_service.snapshot(created["quest_id"])
+                startup_message = self._connector_turn_start_message(
+                    quest_id=created["quest_id"],
+                    startup=startup,
+                    snapshot=created_snapshot,
+                )
                 return channel.send(
                     {
                         "conversation_id": conversation_id,
@@ -4350,7 +5575,9 @@ class DaemonApp:
                                 quest_id=created["quest_id"],
                                 goal=goal_text,
                                 previous_quest_id=previous_quest_id,
-                            ),
+                            )
+                            + "\n"
+                            + startup_message,
                         ),
                     }
                 )
@@ -4759,7 +5986,7 @@ class DaemonApp:
             message_id=str(message.get("message_id") or "").strip() or None,
             attachments=[dict(item) for item in (message.get("attachments") or []) if isinstance(item, dict)],
         )
-        self.submit_user_message(
+        startup = self.submit_user_message(
             quest_id,
             text=self._connector_message_text_with_attachment_notice(
                 original_text=text,
@@ -4768,18 +5995,18 @@ class DaemonApp:
             source=conversation_id,
             attachments=materialized_attachments,
         )
+        snapshot = self.quest_service.snapshot(quest_id)
+        startup_message = self._connector_turn_start_message(
+            quest_id=quest_id,
+            startup=startup,
+            snapshot=snapshot,
+        )
         return channel.send(
             {
                 "conversation_id": conversation_id,
                 "quest_id": quest_id,
                 "kind": "ack",
-                "message": self._with_qq_main_chat_notice(
-                    message,
-                    self._polite_copy(
-                        zh=f"老师，已收到您的消息，当前会话已绑定到 {quest_id}。我会继续推进，并通过后续消息同步进展。",
-                        en=f"Received. This conversation is bound to {quest_id}; I’ll continue the work and keep you updated with the next progress checkpoint.",
-                    ),
-                ),
+                "message": self._with_qq_main_chat_notice(message, startup_message),
             }
         )
 
@@ -5772,6 +6999,78 @@ class DaemonApp:
             en="I will clarify the current task first, then keep moving. ✨",
         )
 
+    def _connector_runner_label(self, runner_name: str) -> str:
+        normalized = str(runner_name or "codex").strip().lower() or "codex"
+        if normalized == "claude":
+            return "Claude Code"
+        if normalized == "opencode":
+            return "Open Code"
+        try:
+            metadata = get_runner_metadata(normalized)
+        except Exception:
+            return runner_name or "Codex"
+        return str(metadata.label or runner_name or "Codex")
+
+    def _connector_runner_readiness(self, runner_name: str) -> dict[str, Any]:
+        try:
+            state = self.config_manager.runner_bootstrap_state(runner_name)
+        except Exception:
+            return {"runner": runner_name, "ready": True, "last_result": {}}
+        if not isinstance(state, dict):
+            return {"runner": runner_name, "ready": True, "last_result": {}}
+        return state
+
+    def _connector_turn_start_message(
+        self,
+        *,
+        quest_id: str,
+        startup: dict[str, Any],
+        snapshot: dict[str, Any],
+    ) -> str:
+        runner_name = self._runner_name_for(snapshot)
+        runner_label = self._connector_runner_label(runner_name)
+        readiness = self._connector_runner_readiness(runner_name)
+        readiness_result = readiness.get("last_result") if isinstance(readiness.get("last_result"), dict) else {}
+        readiness_summary = str(readiness_result.get("summary") or "").strip()
+        readiness_errors = [str(item).strip() for item in (readiness_result.get("errors") or []) if str(item).strip()]
+        readiness_guidance = [str(item).strip() for item in (readiness_result.get("guidance") or []) if str(item).strip()]
+        ready = bool(readiness.get("ready", True))
+        reason = str(startup.get("reason") or "").strip().lower()
+        started = bool(startup.get("started"))
+        queued = bool(startup.get("queued"))
+        auto_resumed = bool(startup.get("auto_resumed"))
+        has_explicit_runner_failure = bool(readiness_summary or readiness_errors or readiness_guidance)
+        if reason == "stalled_turn_recovery_pending":
+            return self._polite_copy(
+                zh=f"正在启动 DeepScientist，当前会先恢复 `{quest_id}` 里停滞的运行，再继续处理您的新消息。",
+                en=f"DeepScientist is starting up. I’m recovering the stalled run in `{quest_id}` first, then I’ll continue with your new message.",
+            )
+        if not ready and has_explicit_runner_failure:
+            status_line = f" 当前状态：{readiness_summary}" if readiness_summary else ""
+            return self._polite_copy(
+                zh=(
+                    f"DeepScientist 仍然不在线哟，请检查你所绑定的{runner_label}是否能够顺利连接。{status_line}"
+                ),
+                en=(
+                    f"DeepScientist is still offline. Please check whether the bound {runner_label} can connect normally."
+                    f"{(' Current status: ' + readiness_summary) if readiness_summary else ''}"
+                ),
+            )
+        if started or auto_resumed:
+            return self._polite_copy(
+                zh=f"已经成功收到消息，DeepScientist 已经启动并开始处理 `{quest_id}` 啦。",
+                en=f"Message received successfully. DeepScientist has started and is now processing `{quest_id}`.",
+            )
+        if queued:
+            return self._polite_copy(
+                zh=f"已经成功收到消息，`{quest_id}` 当前正在运行中，这条消息也已经排进队列了。",
+                en=f"Message received successfully. `{quest_id}` is already running, and this message has been queued.",
+            )
+        return self._polite_copy(
+            zh=f"已经成功收到消息，我会继续推进 `{quest_id}` 并同步后续进展。",
+            en=f"Message received successfully. I’ll continue `{quest_id}` and keep you updated.",
+        )
+
     def _quest_created_connector_message(
         self,
         connector_name: str,
@@ -6828,6 +8127,10 @@ class DaemonApp:
                                     "event_id": event.get("event_id") or f"evt-{quest_id}-{current_cursor}",
                                     **event,
                                 }
+                                enriched_event = self.quest_service.enrich_conversation_message_event(
+                                    quest_id,
+                                    enriched_event,
+                                )
                                 update = build_session_update(
                                     enriched_event,
                                     quest_id=quest_id,
@@ -6908,6 +8211,75 @@ class DaemonApp:
         except (BrokenPipeError, ConnectionResetError, TimeoutError):
             return
 
+    def stream_admin_task(
+        self,
+        handler: BaseHTTPRequestHandler,
+        *,
+        task_id: str,
+        headers: dict[str, str] | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> None:
+        try:
+            task = self.admin_task_service.get_task(task_id)
+        except FileNotFoundError:
+            self._write_handler_response(
+                handler,
+                code=404,
+                content=json.dumps(
+                    {"ok": False, "message": f"Unknown admin task `{task_id}`."},
+                    ensure_ascii=False,
+                ).encode("utf-8"),
+                content_type="application/json; charset=utf-8",
+                extra_headers=extra_headers,
+            )
+            return
+
+        last_event_raw = str((headers or {}).get("Last-Event-ID") or (headers or {}).get("last-event-id") or "").strip()
+        cursor = int(last_event_raw) if last_event_raw.isdigit() else 0
+
+        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()
+
+        self._write_sse_event(
+            handler,
+            event="task.snapshot",
+            data={"task": task},
+        )
+        heartbeat_at = time.monotonic()
+        terminal_statuses = {"completed", "failed", "cancelled"}
+        try:
+            while True:
+                current_task = self.admin_task_service.get_task(task_id)
+                events = self.admin_task_service.read_events(task_id, after=cursor, limit=200)
+                if events:
+                    for item in events:
+                        cursor = max(cursor, int(item.get("seq") or 0))
+                        self._write_sse_event(
+                            handler,
+                            event=str(item.get("event") or "task.log"),
+                            data=item,
+                            event_id=str(cursor),
+                        )
+                    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()
+                current_status = str(current_task.get("status") or "").strip().lower()
+                if current_status in terminal_statuses and cursor >= int(current_task.get("last_event_seq") or 0):
+                    return
+                time.sleep(0.2 if current_status == "running" else 0.6)
+        except (BrokenPipeError, ConnectionResetError, TimeoutError):
+            return
+
     def stream_bash_sessions(
         self,
         handler: BaseHTTPRequestHandler,
@@ -7227,6 +8599,13 @@ class DaemonApp:
         app = self
 
         class RequestHandler(BaseHTTPRequestHandler):
+            def handle(self) -> None:
+                try:
+                    super().handle()
+                except (BrokenPipeError, ConnectionResetError, TimeoutError):
+                    self.close_connection = True
+                    return
+
             def log_message(self, format: str, *args) -> None:
                 return
 
@@ -7270,6 +8649,18 @@ class DaemonApp:
                         },
                     )
                     return
+                if route_name in {"admin_task_stream", "system_task_stream"}:
+                    try:
+                        app.stream_admin_task(self, **params, headers=request_headers, extra_headers=auth_headers)
+                    except Exception as exc:
+                        app.logger.log(
+                            "error",
+                            "http.stream_admin_task_failed",
+                            path=self.path,
+                            error=str(exc),
+                        )
+                        self.close_connection = True
+                    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=request_headers, extra_headers=auth_headers)
@@ -7341,6 +8732,7 @@ class DaemonApp:
 
                 try:
                     result = getattr(app.handlers, route_name)
+                    route_alias = route_name.removeprefix("admin_").removeprefix("system_")
                     if route_name == "asset":
                         status, headers, content = result(**params)
                         app._write_handler_response(
@@ -7350,7 +8742,17 @@ class DaemonApp:
                             extra_headers=app._merge_response_headers(headers, auth_headers),
                         )
                         return
-                    if route_name in {
+                    if route_alias in {
+                        "quests",
+                        "runtime_sessions",
+                        "log_tail",
+                        "failures",
+                        "errors",
+                        "audit",
+                        "search",
+                        "repairs",
+                        "tasks",
+                    } or route_name in {
                         "quest_events",
                         "bash_sessions",
                         "bash_logs",
@@ -7373,9 +8775,28 @@ class DaemonApp:
                         "annotations_project",
                     }:
                         payload = result(**params, path=self.path)
+                    elif route_name in {
+                        "benchstore_entries",
+                        "benchstore_entry",
+                        "benchstore_entry_image",
+                        "benchstore_entry_setup_packet",
+                    }:
+                        payload = result(**params, path=self.path) if params else result(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", "auth_login", "auth_rotate"}:
+                    elif route_alias in {
+                        "shutdown",
+                        "chart_query",
+                        "task_doctor_start",
+                        "task_system_update_check_start",
+                        "task_system_update_action_start",
+                        "issue_draft",
+                        "controller_run",
+                        "controller_toggle",
+                        "repair_create",
+                        "repair_close",
+                        "hardware_update",
+                    } or route_name in {"document_open", "document_asset_upload", "quest_file_create_folder", "quest_file_upload", "quest_file_rename", "quest_file_move", "quest_file_delete", "chat_upload_create", "chat_upload_delete", "chat", "command", "quest_control", "quest_message_read_now", "quest_message_withdraw", "config_save", "quest_create", "quest_baseline_binding", "run_create", "qq_inbound", "connector_inbound", "docs_open", "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)
@@ -7385,6 +8806,8 @@ class DaemonApp:
                         payload = result(**params, body=body)
                     elif route_name == "memory":
                         payload = result(app.handlers.parse_query(self.path))
+                    elif route_name == "benchstore_entry_launch":
+                        payload = result(**params, path=self.path, body=body)
                     else:
                         payload = result(**params) if params else result()
                 except Exception as exc:
@@ -7432,6 +8855,8 @@ class DaemonApp:
         self._serve_host = host
         self._serve_port = port
         self._shutdown_requested.clear()
+        self.admin_service.system_monitor.start()
+        self.admin_service.metrics_collector.start()
         self._start_terminal_attach_server(host, port)
         self._start_background_connectors()
         self._resume_reconciled_quests()
@@ -7453,6 +8878,8 @@ class DaemonApp:
         finally:
             self._stop_background_connectors()
             self._stop_terminal_attach_server()
+            self.admin_service.metrics_collector.stop()
+            self.admin_service.system_monitor.stop()
             self.bash_exec_service.shutdown()
             self._server = None
             self._serve_host = None