@researai/deepscientist 1.5.14 → 1.5.16

package/src/deepscientist/prompts/builder.py

@@ -6,29 +6,21 @@ from pathlib import Path
 
 from ..connector_runtime import normalize_conversation_id, parse_conversation_id
 from ..config import ConfigManager
+from ..home import repo_root
 from ..memory import MemoryService
 from ..memory.frontmatter import load_markdown_document
 from ..quest import QuestService
 from ..registries import BaselineRegistry
 from ..shared import read_json, read_text, read_yaml
+from ..skills import SkillInstaller, companion_skill_ids, stage_skill_ids
 
-STANDARD_SKILLS = (
-    "scout",
-    "baseline",
-    "idea",
-    "experiment",
-    "analysis-campaign",
-    "write",
-    "finalize",
-    "decision",
-)
-
-COMPANION_SKILLS = (
-    "figure-polish",
-    "intake-audit",
-    "review",
-    "rebuttal",
-)
+# Backward-compatible snapshots for modules or tests that still import these names directly.
+# Runtime routing should call `current_standard_skills(...)` / `current_companion_skills(...)`.
+STANDARD_SKILLS = stage_skill_ids(repo_root())
+
+_AUTO_CONTINUE_MONITOR_INTERVAL_SECONDS = 240
+
+COMPANION_SKILLS = companion_skill_ids(repo_root())
 
 STAGE_MEMORY_PLAN = {
     "scout": {
@@ -43,6 +35,10 @@ STAGE_MEMORY_PLAN = {
         "quest": ("papers", "ideas", "decisions", "knowledge"),
         "global": ("papers", "knowledge", "templates"),
     },
+    "optimize": {
+        "quest": ("episodes", "decisions", "ideas", "knowledge"),
+        "global": ("knowledge", "templates"),
+    },
     "experiment": {
         "quest": ("ideas", "decisions", "episodes", "knowledge"),
         "global": ("knowledge", "templates"),
@@ -66,14 +62,56 @@ STAGE_MEMORY_PLAN = {
 }
 
 
+def current_standard_skills(repo_root_path: Path | None = None) -> tuple[str, ...]:
+    return stage_skill_ids(repo_root_path or repo_root())
+
+
+def current_companion_skills(repo_root_path: Path | None = None) -> tuple[str, ...]:
+    return companion_skill_ids(repo_root_path or repo_root())
+
+
+def classify_turn_intent(user_message: str) -> str:
+    text = str(user_message or "").strip()
+    if not text:
+        return "continue_stage"
+    normalized = " ".join(text.split()).lower()
+    structured_bootstrap_markers = (
+        "project bootstrap",
+        "primary research request",
+        "research goals",
+        "baseline context",
+        "reference papers",
+        "operational constraints",
+        "research delivery mode",
+        "decision handling mode",
+        "launch mode",
+        "research contract",
+        "mandatory working rules",
+    )
+    structured_hit_count = sum(1 for marker in structured_bootstrap_markers if marker in normalized)
+    if structured_hit_count >= 2:
+        return "continue_stage"
+    if normalized.startswith("/new ") or normalized.startswith("/new\n"):
+        return "continue_stage"
+    question_markers = ["?", "？", "现在进展", "全局", "多久", "什么情况", "在哪", "在哪里", "how long", "what", "where"]
+    if any(marker in normalized for marker in question_markers):
+        return "answer_user_question_first"
+    command_markers = ["继续", "发给我", "发送", "运行", "启动", "resume", "send", "run", "launch"]
+    if any(marker in normalized for marker in command_markers):
+        return "execute_user_command_first"
+    return "continue_stage"
+
+
 class PromptBuilder:
-    def __init__(self, repo_root: Path, home: Path) -> None:
+    def __init__(self, repo_root: Path, home: Path, *, prompt_version_selection: str | None = None) -> None:
         self.repo_root = repo_root
         self.home = home
         self.quest_service = QuestService(home)
         self.memory_service = MemoryService(home)
         self.baseline_registry = BaselineRegistry(home)
         self.config_manager = ConfigManager(home)
+        self.skill_installer = SkillInstaller(repo_root, home)
+        self.prompt_version_selection = str(prompt_version_selection or "").strip() or None
 
     def build(
         self,
@@ -83,15 +121,22 @@ class PromptBuilder:
         user_message: str,
         model: str,
         turn_reason: str = "user_message",
+        turn_intent: str | None = None,
+        turn_mode: str | None = None,
         retry_context: dict | None = None,
     ) -> str:
         snapshot = self.quest_service.snapshot(quest_id)
         runtime_config = self.config_manager.load_named("config")
         connectors_config = self.config_manager.load_named_normalized("connectors")
         quest_root = Path(snapshot["quest_root"])
+        self.skill_installer.sync_quest_prompts(quest_root)
         active_anchor = str(snapshot.get("active_anchor") or skill_id)
         default_locale = str(runtime_config.get("default_locale") or "en-US")
-        system_block = self._prompt_fragment("system.md", quest_root=quest_root)
+        workspace_mode = self._workspace_mode(snapshot)
+        system_block = self._prompt_fragment(
+            "system_copilot.md" if workspace_mode == "copilot" else "system.md",
+            quest_root=quest_root,
+        )
         shared_interaction_block = self._prompt_fragment(
             Path("contracts") / "shared_interaction.md",
             quest_root=quest_root,
@@ -120,7 +165,7 @@ class PromptBuilder:
             f"conversation_id: quest:{quest_id}",
             f"default_locale: {default_locale}",
             "built_in_mcp_namespaces: memory, artifact, bash_exec",
-            "mcp_namespace_note: any shell-like command execution must use bash_exec, including curl/python/bash/node and similar CLI tools; do not use transient shell snippets.",
+            "mcp_namespace_note: **any shell-like command execution must use `bash_exec(...)`, including curl/python/bash/node/git/npm/uv and similar CLI tools; do not use native `shell_command` / `command_execution`.**",
             "",
             "Canonical stage skills root:",
             str((self.repo_root / "src" / "skills").resolve()),
@@ -151,7 +196,12 @@ class PromptBuilder:
             [
                 "",
                 "## Turn Driver",
-                self._turn_driver_block(turn_reason=turn_reason, user_message=user_message),
+                self._turn_driver_block(
+                    turn_reason=turn_reason,
+                    user_message=user_message,
+                    turn_intent=turn_intent,
+                    turn_mode=turn_mode,
+                ),
                 "",
                 "## Continuation Guard",
                 self._continuation_guard_block(
@@ -173,12 +223,26 @@ class PromptBuilder:
                 "## Research Delivery Policy",
                 self._research_delivery_policy_block(snapshot),
                 "",
+                "## Optimization Frontier Snapshot",
+                self._optimization_frontier_block(snapshot, quest_root),
+                "",
                 "## Paper And Evidence Snapshot",
                 self._paper_and_evidence_block(snapshot, quest_root),
                 "",
                 "## Retry Recovery Packet",
                 self._retry_recovery_block(retry_context),
                 "",
+                "## Recovery Resume Packet",
+                self._recovery_resume_block(snapshot=snapshot, turn_reason=turn_reason),
+                "",
+                "## Resume Context Spine",
+                self._resume_context_spine_block(
+                    quest_id=quest_id,
+                    quest_root=quest_root,
+                    snapshot=snapshot,
+                    turn_reason=turn_reason,
+                ),
+                "",
                 "## Interaction Style",
                 self._interaction_style_block(default_locale=default_locale, user_message=user_message, snapshot=snapshot),
                 "",
@@ -206,7 +270,14 @@ class PromptBuilder:
         )
         return "\n\n".join(sections).strip() + "\n"
 
-    def _turn_driver_block(self, *, turn_reason: str, user_message: str) -> str:
+    def _turn_driver_block(
+        self,
+        *,
+        turn_reason: str,
+        user_message: str,
+        turn_intent: str | None = None,
+        turn_mode: str | None = None,
+    ) -> str:
         normalized_reason = str(turn_reason or "user_message").strip() or "user_message"
         lines = [f"- turn_reason: {normalized_reason}"]
         if normalized_reason == "auto_continue":
@@ -228,9 +299,28 @@ class PromptBuilder:
             preview = " ".join(str(user_message or "").split())
             if len(preview) > 220:
                 preview = preview[:217].rstrip() + "..."
+            resolved_turn_intent = str(turn_intent or self._turn_intent(user_message)).strip() or "continue_stage"
+            resolved_turn_mode = str(turn_mode or "stage_execution").strip() or "stage_execution"
+            lines.append(f"- turn_intent: {resolved_turn_intent}")
+            lines.append(f"- turn_mode: {resolved_turn_mode}")
+            if resolved_turn_intent == "answer_user_question_first":
+                lines.append(
+                    "- answer_first_rule: the user primarily asked a direct question. Answer it in plain language before resuming any background stage work or generating new route artifacts."
+                )
+                lines.append(
+                    "- direct_answer_tool_rule: if the question is about overall progress, paper readiness, current best result, or next step, call artifact.get_global_status(detail='brief'|'full', locale='zh'|'en') before answering from memory or local stage context."
+                )
+            elif resolved_turn_intent == "execute_user_command_first":
+                lines.append(
+                    "- command_first_rule: the user primarily gave a concrete instruction. Execute or acknowledge that instruction first before resuming background stage narration."
+                )
             lines.append(f"- direct_user_message_preview: {preview or 'none'}")
         return "\n".join(lines)
 
+    @staticmethod
+    def _turn_intent(user_message: str) -> str:
+        return classify_turn_intent(user_message)
+
     def _active_communication_surface_block(
         self,
         *,
@@ -245,8 +335,6 @@ class PromptBuilder:
         connector = surface_context["active_connector"]
         chat_type = surface_context["active_chat_type"]
         chat_id = surface_context["active_chat_id"]
-        qq_config = connectors_config.get("qq") if isinstance(connectors_config.get("qq"), dict) else {}
-
         lines = [
             f"- latest_user_source: {source}",
             f"- active_surface: {surface}",
@@ -264,38 +352,16 @@ class PromptBuilder:
             lines.extend(
                 [
                     "- qq_surface_rule: QQ is a milestone-report surface, not a full artifact browser.",
-                    "- qq_default_mode: keep outbound replies concise, respectful, text-first, and progress-aware.",
-                    "- qq_detail_rule: do not proactively dump file inventories, path lists, or low-level file details unless the user explicitly asked for them.",
-                    "- qq_length_rule: for ordinary QQ progress replies, normally use only 2 to 4 short sentences, or 3 very short bullets at most.",
-                    "- qq_summary_first_rule: start with the user-facing conclusion, then the immediate meaning, then the next action; do not make the user reverse-engineer the status from telemetry.",
-                    "- qq_internal_signal_rule: omit worker names, heartbeat timestamps, retry counters, pending/running/completed counts, file names, and monitor-window narration unless that detail is necessary for a user decision or to explain a real risk.",
-                    "- qq_translation_rule: translate internal actions into user value, for example say that you organized the baseline record for easier comparison later instead of listing the files you touched.",
-                    "- qq_eta_rule: for baseline reproduction, main experiments, analysis experiments, and other important long-running research phases, include a rough ETA for the next meaningful result, next step, or next update; if the runtime is uncertain, say that directly and still give the next check-in window.",
-                    f"- qq_auto_send_main_experiment_png: {bool(qq_config.get('auto_send_main_experiment_png', True))}",
-                    f"- qq_auto_send_analysis_summary_png: {bool(qq_config.get('auto_send_analysis_summary_png', True))}",
-                    f"- qq_auto_send_slice_png: {bool(qq_config.get('auto_send_slice_png', False))}",
-                    f"- qq_auto_send_paper_pdf: {bool(qq_config.get('auto_send_paper_pdf', True))}",
-                    f"- qq_enable_markdown_send: {bool(qq_config.get('enable_markdown_send', False))}",
-                    f"- qq_enable_file_upload_experimental: {bool(qq_config.get('enable_file_upload_experimental', False))}",
-                    "- qq_visual_rule: follow the fixed Morandi palette guide defined in the system prompt and active stage skill; do not assume per-install palette config exists.",
-                    "- qq_media_rule: auto-send only high-value milestone media such as a main-experiment summary PNG, an aggregated analysis summary PNG, or the final paper PDF when available and configured.",
-                    "- qq_media_rule_2: do not auto-send every slice image, every debug plot, or draft paper figures unless the user explicitly asked for them.",
-                    "- qq_structured_delivery_rule: when you want native QQ markdown or native QQ image/file delivery, request it through artifact.interact(connector_hints=..., attachments=[...]) instead of inventing connector-specific inline tag syntax.",
+                    "- qq_reply_rule: keep outbound replies concise, respectful, text-first, and progress-aware.",
+                    "- qq_detail_rule: rely on the QQ connector contract for detailed surface formatting instead of expanding it here.",
                 ]
             )
         elif connector == "weixin":
             lines.extend(
                 [
                     "- weixin_surface_rule: Weixin is a concise operator surface, not a full artifact browser.",
-                    "- weixin_default_mode: keep outbound replies concise, respectful, text-first, and progress-aware.",
-                    "- weixin_length_rule: for ordinary Weixin progress replies, normally use only 2 to 4 short sentences, or 3 very short bullets at most.",
-                    "- weixin_summary_first_rule: start with the user-facing conclusion, then the immediate meaning, then the next action.",
-                    "- weixin_progress_shape_rule: make the current task, the main difficulty or latest real progress, and the next concrete next step explicit whenever possible.",
-                    "- weixin_eta_rule: for important long-running phases, include a rough ETA or next check-in window when it is helpful and defensible.",
-                    "- weixin_internal_detail_rule: do not proactively dump file inventories, path lists, retry counters, or monitor-log style telemetry unless the user asked for them or they explain a real risk.",
-                    "- weixin_context_token_rule: reply continuity is managed by the runtime through `context_token`; do not invent your own reply token scheme.",
-                    "- weixin_media_rule: when you want native Weixin image, video, or file delivery, request it through artifact.interact(..., attachments=[...]) with `connector_delivery={'weixin': {'media_kind': ...}}` instead of inventing connector-specific inline tag syntax.",
-                    "- weixin_inbound_media_rule: inbound Weixin image, video, and file messages can arrive as quest-local attachments under `userfiles/weixin/...`; read those files when the user sent media.",
+                    "- weixin_reply_rule: keep outbound replies concise, respectful, text-first, and progress-aware.",
+                    "- weixin_detail_rule: rely on the Weixin connector contract for detailed transport formatting instead of expanding it here.",
                 ]
             )
         else:
@@ -434,8 +500,14 @@ class PromptBuilder:
                 ]
             )
         if str(turn_reason or "").strip() == "auto_continue":
-            lines.append(
-                "- auto_continue_rule: this turn has no new user message; continue from the active requirements, durable artifacts, and current quest state instead of replaying the previous user message"
+            lines.extend(
+                [
+                    "- auto_continue_rule: this turn has no new user message; continue from the active requirements, durable artifacts, current quest state, and resume context spine instead of replaying the previous user message",
+                    f"- auto_continue_interval_rule: when a real long-running external task is already active, background-progress auto-continue becomes a low-frequency monitoring pass, about every {_AUTO_CONTINUE_MONITOR_INTERVAL_SECONDS} seconds rather than sub-minute polling",
+                    "- auto_continue_fast_prepare_rule: in autonomous mode before a real external long-running task exists, auto-continue may advance quickly, around 0.2 seconds between turns, so the agent can keep preparing or launching the real work without idling",
+                    "- autonomous_prepare_rule: in autonomous mode, if no real long-running external task is active yet, use the next turns to keep preparing, launching, or durably deciding the next real unit of work instead of parking idly",
+                    "- copilot_park_rule: in copilot mode, once the current requested unit is complete, it is normal to park and wait for the next user message or `/resume` instead of continuing autonomously",
+                ]
             )
         else:
             lines.append(
@@ -472,7 +544,20 @@ class PromptBuilder:
         pending_user_count = int(snapshot.get("pending_user_message_count") or 0)
         if pending_user_count > 0:
             return f"Poll artifact.interact(...) and handle the {pending_user_count} queued user message(s) first."
+        continuation_policy = str(snapshot.get("continuation_policy") or "auto").strip().lower() or "auto"
+        continuation_anchor = str(snapshot.get("continuation_anchor") or "").strip()
+        if continuation_policy == "wait_for_user_or_resume":
+            if continuation_anchor:
+                return (
+                    f"The quest is intentionally parked after the latest durable checkpoint. Wait for a new user message or "
+                    f"`/resume`, then continue from `{continuation_anchor}` instead of auto-continuing the previous stage."
+                )
+            return "The quest is intentionally parked after the latest durable checkpoint. Wait for a new user message or `/resume`."
+        if continuation_policy == "none":
+            return "Do not auto-continue this quest. Wait for an explicit new user instruction before doing more work."
         active_anchor = str(snapshot.get("active_anchor") or "decision").strip() or "decision"
+        if continuation_anchor:
+            active_anchor = continuation_anchor
         active_idea_id = str(snapshot.get("active_idea_id") or "").strip()
         next_slice_id = str(snapshot.get("next_pending_slice_id") or "").strip()
         active_campaign_id = str(snapshot.get("active_analysis_campaign_id") or "").strip()
@@ -489,6 +574,8 @@ class PromptBuilder:
                 "Continue idea analysis and route selection until the next durable idea branch is submitted "
                 "with `lineage_intent='continue_line'` or `lineage_intent='branch_alternative'`."
             )
+        if active_anchor == "optimize":
+            return "Continue the optimization loop from the current frontier, candidate pool, durable runs, and branch state."
         if active_anchor == "experiment":
             return "Continue the main experiment workflow from the current workspace, logs, and recorded evidence."
         if active_anchor == "analysis-campaign":
@@ -547,6 +634,76 @@ class PromptBuilder:
             lines.append(f"- remaining_attachment_count: {len(attachments) - 6}")
         return "\n".join(lines)
 
+    def _resume_context_spine_block(self, *, quest_id: str, quest_root: Path, snapshot: dict, turn_reason: str) -> str:
+        if str(turn_reason or "").strip() != "auto_continue":
+            return "- none"
+        lines = [
+            "- resume_spine_rule: on auto_continue turns, first continue from the latest durable user requirement, the latest assistant checkpoint, the latest run summary, and recent memory cues instead of reconstructing intent from scratch",
+        ]
+        bash_running_count = int(((snapshot.get("counts") or {}).get("bash_running_count")) or 0)
+        latest_bash_session = (
+            dict((snapshot.get("summary") or {}).get("latest_bash_session") or {})
+            if isinstance((snapshot.get("summary") or {}).get("latest_bash_session"), dict)
+            else {}
+        )
+        lines.append(f"- active_bash_exec_run_count: {bash_running_count}")
+        if latest_bash_session:
+            command_preview = " ".join(str(latest_bash_session.get("command") or "").split())
+            if len(command_preview) > 180:
+                command_preview = command_preview[:177].rstrip() + "..."
+            lines.append(
+                f"- latest_bash_exec_session: bash_id={str(latest_bash_session.get('bash_id') or 'none')} | "
+                f"status={str(latest_bash_session.get('status') or 'unknown')} | "
+                f"command={command_preview or 'none'}"
+            )
+        latest_user = self._latest_user_message(quest_id)
+        if latest_user is not None:
+            preview = " ".join(str(latest_user.get("content") or "").split())
+            if len(preview) > 320:
+                preview = preview[:317].rstrip() + "..."
+            lines.append(
+                f"- latest_user_message: {str(latest_user.get('created_at') or 'unknown')} | "
+                f"source={str(latest_user.get('source') or 'unknown')} | "
+                f"reply_to={str(latest_user.get('reply_to_interaction_id') or 'none')} | "
+                f"preview={preview or 'none'}"
+            )
+        latest_assistant = self._latest_assistant_message(quest_id)
+        if latest_assistant is not None:
+            preview = " ".join(str(latest_assistant.get("content") or "").split())
+            if len(preview) > 360:
+                preview = preview[:357].rstrip() + "..."
+            lines.append(
+                f"- latest_assistant_checkpoint: {str(latest_assistant.get('created_at') or 'unknown')} | "
+                f"skill={str(latest_assistant.get('skill_id') or 'none')} | "
+                f"run_id={str(latest_assistant.get('run_id') or 'none')} | "
+                f"preview={preview or 'none'}"
+            )
+        latest_run = self._latest_run_result(quest_root)
+        if latest_run is not None:
+            preview = " ".join(str(latest_run.get("preview") or "").split())
+            if len(preview) > 360:
+                preview = preview[:357].rstrip() + "..."
+            lines.append(
+                f"- latest_run_result: {str(latest_run.get('completed_at') or 'unknown')} | "
+                f"run_id={str(latest_run.get('run_id') or 'none')} | "
+                f"exit_code={latest_run.get('exit_code') if latest_run.get('exit_code') is not None else 'none'} | "
+                f"preview={preview or 'none'}"
+            )
+        recent_memory = self.memory_service.list_recent(scope="quest", quest_root=quest_root, limit=3)
+        if recent_memory:
+            lines.append("- recent_memory_cues:")
+            for item in recent_memory:
+                title = str(item.get("title") or "memory").strip() or "memory"
+                card_type = str(item.get("type") or "memory").strip() or "memory"
+                excerpt = " ".join(str(item.get("excerpt") or "").split())
+                if len(excerpt) > 200:
+                    excerpt = excerpt[:197].rstrip() + "..."
+                lines.append(f"  - [{card_type}] {title}: {excerpt or 'no excerpt'}")
+        else:
+            lines.append("- recent_memory_cues: none")
+        lines.append("- resume_spine_conflict_rule: if these spine items conflict with newer durable files or artifacts, trust the newer durable state and update the summary rather than replaying the older plan verbatim")
+        return "\n".join(lines)
+
     def _retry_recovery_block(self, retry_context: dict | None) -> str:
         if not isinstance(retry_context, dict) or not retry_context:
             return "- none"
@@ -634,6 +791,24 @@ class PromptBuilder:
 
         return "\n".join(lines)
 
+    @staticmethod
+    def _recovery_resume_block(*, snapshot: dict, turn_reason: str) -> str:
+        if str(turn_reason or "").strip() != "auto_continue":
+            return "- none"
+        source = str(snapshot.get("last_resume_source") or "").strip()
+        if not source.startswith("auto:daemon-recovery"):
+            return "- none"
+        lines = [
+            f"- resume_source: {source}",
+            f"- resumed_at: {snapshot.get('last_resume_at') or 'unknown'}",
+            f"- abandoned_run_id: {snapshot.get('last_recovery_abandoned_run_id') or 'none'}",
+            f"- recovery_summary: {snapshot.get('last_recovery_summary') or 'none'}",
+            "- recovery_rule: this turn exists because the daemon/runtime previously died or stale running state was reconciled; first re-establish the current truth before continuing any old stage loop.",
+            "- recovery_rule_2: if there is any new user message, handle that before blindly resuming the older subtask.",
+            "- recovery_rule_3: do not assume the previous branch-local route is still the right immediate action until branch/workspace, run state, and user intent are checked together.",
+        ]
+        return "\n".join(lines)
+
     def _prompt_fragment(self, relative_path: str | Path, *, quest_root: Path | None = None) -> str:
         path = self._prompt_path(relative_path, quest_root=quest_root)
         return self._markdown_body(path)
@@ -641,6 +816,19 @@ class PromptBuilder:
     def _prompt_path(self, relative_path: str | Path, *, quest_root: Path | None = None) -> Path:
         normalized = Path(relative_path)
         if quest_root is not None:
+            selected_version = str(self.prompt_version_selection or "").strip()
+            if selected_version and selected_version not in {"latest", "current", "active"}:
+                selected_root = self.skill_installer.resolve_prompt_version_root(quest_root, selected_version)
+                if selected_root is None:
+                    raise FileNotFoundError(
+                        f"Prompt version `{selected_version}` is unavailable for quest `{quest_root.name}`."
+                    )
+                selected_path = selected_root / normalized
+                if not selected_path.exists():
+                    raise FileNotFoundError(
+                        f"Prompt version `{selected_version}` does not include `{normalized.as_posix()}` for quest `{quest_root.name}`."
+                    )
+                return selected_path
             quest_path = quest_root / ".codex" / "prompts" / normalized
             if quest_path.exists():
                 return quest_path
@@ -652,16 +840,45 @@ class PromptBuilder:
                 return item
         return None
 
+    def _latest_assistant_message(self, quest_id: str) -> dict | None:
+        for item in reversed(self.quest_service.history(quest_id, limit=120)):
+            if str(item.get("role") or "") == "assistant":
+                return item
+        return None
+
+    @staticmethod
+    def _latest_run_result(quest_root: Path) -> dict[str, object] | None:
+        runs_root = quest_root / ".ds" / "runs"
+        if not runs_root.exists():
+            return None
+        candidates = [path for path in runs_root.glob("*/result.json") if path.is_file()]
+        if not candidates:
+            return None
+        latest = max(candidates, key=lambda path: path.stat().st_mtime)
+        payload = read_json(latest, {})
+        if not isinstance(payload, dict):
+            return None
+        preview = (
+            str(payload.get("output_text") or "").strip()
+            or str(payload.get("stderr_text") or "").strip()
+        )
+        return {
+            "run_id": latest.parent.name,
+            "completed_at": str(payload.get("completed_at") or "").strip() or None,
+            "exit_code": payload.get("exit_code"),
+            "preview": preview,
+        }
+
     def _skill_paths_block(self) -> str:
         lines = []
-        for skill_id in STANDARD_SKILLS:
+        for skill_id in current_standard_skills(self.repo_root):
             primary = (self.repo_root / "src" / "skills" / skill_id / "SKILL.md").resolve()
             lines.append(f"- {skill_id}: primary={primary}")
         return "\n".join(lines)
 
     def _companion_skill_paths_block(self) -> str:
         lines = []
-        for skill_id in COMPANION_SKILLS:
+        for skill_id in current_companion_skills(self.repo_root):
             primary = (self.repo_root / "src" / "skills" / skill_id / "SKILL.md").resolve()
             lines.append(f"- {skill_id}: primary={primary}")
         return "\n".join(lines)
@@ -675,6 +892,18 @@ class PromptBuilder:
                 return value
         return True
 
+    @staticmethod
+    def _workspace_mode(snapshot: dict) -> str:
+        value = str(snapshot.get("workspace_mode") or "").strip().lower()
+        if value in {"copilot", "autonomous"}:
+            return value
+        startup_contract = snapshot.get("startup_contract")
+        if isinstance(startup_contract, dict):
+            value = str(startup_contract.get("workspace_mode") or "").strip().lower()
+            if value in {"copilot", "autonomous"}:
+                return value
+        return "autonomous"
+
     @staticmethod
     def _decision_policy(snapshot: dict) -> str:
         startup_contract = snapshot.get("startup_contract")
@@ -693,6 +922,15 @@ class PromptBuilder:
                 return value
         return "standard"
 
+    @staticmethod
+    def _standard_profile(snapshot: dict) -> str:
+        startup_contract = snapshot.get("startup_contract")
+        if isinstance(startup_contract, dict):
+            value = str(startup_contract.get("standard_profile") or "").strip().lower()
+            if value in {"canonical_research_graph", "optimization_task"}:
+                return value
+        return "canonical_research_graph"
+
     @staticmethod
     def _custom_profile(snapshot: dict) -> str:
         startup_contract = snapshot.get("startup_contract")
@@ -730,8 +968,21 @@ class PromptBuilder:
         return "none"
 
     def _research_delivery_policy_block(self, snapshot: dict) -> str:
+        if self._workspace_mode(snapshot) == "copilot":
+            return "\n".join(
+                [
+                    "- workspace_mode: copilot",
+                    "- delivery_goal: complete the user-requested unit of work instead of forcing the full research graph by default.",
+                    "- task_scope_rule: arbitrary research tasks such as reading, coding, debugging, experiment design, run inspection, analysis, writing, and planning can all be handled directly in this mode.",
+                    "- autonomy_boundary: only expand into longer autonomous continuation when the user explicitly asks for end-to-end or unattended progress.",
+                    "- routing_rule: open only the skills actually needed for the current request.",
+                    "- durability_rule: keep important plan, evidence, decisions, and outputs durable in quest files or artifacts so later turns can resume cleanly.",
+                    "- completion_rule: after the requested unit is complete, summarize what changed and stop instead of auto-continuing.",
+                ]
+            )
         need_research_paper = self._need_research_paper(snapshot)
         launch_mode = self._launch_mode(snapshot)
+        standard_profile = self._standard_profile(snapshot)
         custom_profile = self._custom_profile(snapshot)
         baseline_execution_policy = self._baseline_execution_policy(snapshot)
         review_followup_policy = self._review_followup_policy(snapshot)
@@ -739,6 +990,7 @@ class PromptBuilder:
         lines = [
             f"- need_research_paper: {need_research_paper}",
             f"- launch_mode: {launch_mode}",
+            f"- standard_profile: {standard_profile if launch_mode == 'standard' else 'n/a'}",
             f"- custom_profile: {custom_profile if launch_mode == 'custom' else 'n/a'}",
             f"- review_followup_policy: {review_followup_policy if custom_profile == 'review_audit' else 'n/a'}",
             f"- baseline_execution_policy: {baseline_execution_policy if launch_mode == 'custom' else 'n/a'}",
@@ -833,6 +1085,15 @@ class PromptBuilder:
                         "- manuscript_edit_rule: when manuscript revision is needed, provide section-level copy-ready replacement text and explicit deltas even if no LaTeX source is available.",
                     ]
                 )
+        elif standard_profile == "optimization_task":
+            lines.extend(
+                [
+                    "- standard_optimization_entry_rule: this standard entry is explicitly optimization-only; treat repeated implementation attempts and measured main-experiment results as the primary progress loop.",
+                    "- standard_optimization_no_analysis_default: do not route into `analysis-campaign` by default; only run extra analysis when it directly validates a suspected win, disambiguates a frontier decision, or exposes a concrete failure mode that changes the next optimization move.",
+                    "- standard_optimization_no_writing_default: do not route into `write`, `review`, or `finalize` while this optimization task profile remains active unless the user explicitly broadens scope.",
+                    "- standard_optimization_iteration_rule: prefer more justified optimization attempts, branch promotion, or frontier cleanup over paper-facing packaging.",
+                ]
+            )
         if need_research_paper:
             lines.extend(
                 [
@@ -847,6 +1108,9 @@ class PromptBuilder:
             lines.extend(
                 [
                     "- delivery_goal: the quest should pursue the strongest justified algorithmic result rather than paper packaging.",
+                    "- optimization_object_rule: distinguish candidate briefs, durable optimization lines, and implementation-level optimization candidates; do not treat them as one object type.",
+                    "- optimization_frontier_rule: before major route selection in algorithm-first work, read `artifact.get_optimization_frontier(...)` and treat the current frontier as the primary optimize-state summary.",
+                    "- optimization_promotion_rule: `submission_mode='candidate'` is branchless pre-promotion state, while `submission_mode='line'` is a committed durable line with a branch/worktree.",
                     "- main_result_rule: use each measured main-experiment result to decide whether to create a `continue_line` child branch, create a `branch_alternative` sibling-like branch, run more analysis, or stop.",
                     "- no_paper_rule: do not default into `artifact.submit_paper_outline(...)`, `artifact.submit_paper_bundle(...)`, or `finalize` while this mode remains active.",
                     "- autonomy_rule: choose the next optimization foundation from durable evidence such as baseline state, the current research head, and recent main-experiment results; do not routinely ask the user to choose that.",
@@ -855,13 +1119,101 @@ class PromptBuilder:
             )
         return "\n".join(lines)
 
+    def _optimization_frontier_block(self, snapshot: dict, quest_root: Path) -> str:
+        active_anchor = str(snapshot.get("active_anchor") or "").strip().lower()
+        if self._need_research_paper(snapshot) and active_anchor != "optimize":
+            return "- not primary in the current delivery mode"
+
+        try:
+            from ..artifact import ArtifactService
+
+            payload = ArtifactService(self.home).get_optimization_frontier(quest_root)
+        except Exception:
+            payload = {"ok": False}
+
+        frontier = (
+            dict(payload.get("optimization_frontier") or {})
+            if isinstance(payload, dict) and isinstance(payload.get("optimization_frontier"), dict)
+            else {}
+        )
+        if not frontier:
+            return "- unavailable"
+
+        best_branch = dict(frontier.get("best_branch") or {}) if isinstance(frontier.get("best_branch"), dict) else {}
+        best_run = dict(frontier.get("best_run") or {}) if isinstance(frontier.get("best_run"), dict) else {}
+        backlog = dict(frontier.get("candidate_backlog") or {}) if isinstance(frontier.get("candidate_backlog"), dict) else {}
+        next_actions = [str(item).strip() for item in (frontier.get("recommended_next_actions") or []) if str(item).strip()]
+        stagnant = frontier.get("stagnant_branches") or []
+        fusion = frontier.get("fusion_candidates") or []
+        local_attempts = [
+            dict(item)
+            for item in (frontier.get("best_branch_recent_candidates") or [])
+            if isinstance(item, dict)
+        ]
+
+        lines = [
+            f"- frontier_mode: {str(frontier.get('mode') or 'unknown')}",
+            f"- frontier_reason: {str(frontier.get('frontier_reason') or 'none')}",
+            f"- frontier_best_branch: {str(best_branch.get('branch_name') or best_branch.get('branch_no') or 'none')}",
+            f"- frontier_best_run: {str(best_run.get('run_id') or 'none')}",
+            f"- frontier_candidate_briefs: {int(backlog.get('candidate_brief_count') or 0)}",
+            f"- frontier_active_implementation_candidates: {int(backlog.get('active_implementation_candidate_count') or 0)}",
+            f"- frontier_failed_implementation_candidates: {int(backlog.get('failed_implementation_candidate_count') or 0)}",
+            f"- frontier_stagnant_branch_count: {len([item for item in stagnant if isinstance(item, dict)])}",
+            f"- frontier_fusion_candidate_count: {len([item for item in fusion if isinstance(item, dict)])}",
+            "- optimization_frontier_rule: in algorithm-first work, treat this block as the primary route-selection surface before relying on paper-facing state.",
+        ]
+        if local_attempts:
+            parts: list[str] = []
+            for item in local_attempts[-3:]:
+                summary_bits = [
+                    str(item.get("candidate_id") or "").strip() or "candidate",
+                    str(item.get("status") or "").strip() or "unknown",
+                    str(item.get("strategy") or "").strip() or None,
+                    str(item.get("mechanism_family") or "").strip() or None,
+                    str(item.get("failure_kind") or "").strip() or None,
+                ]
+                parts.append(" / ".join(bit for bit in summary_bits if bit))
+            lines.append(f"- frontier_same_line_local_attempt_memory: {' | '.join(parts)}")
+            lines.append(
+                "- optimization_local_memory_rule: before seed, loop, or debug work on the leading line, inspect this same-line local attempt memory so you do not repeat a near-duplicate change blindly."
+            )
+        if next_actions:
+            lines.append(f"- frontier_next_actions: {' | '.join(next_actions[:3])}")
+        return "\n".join(lines)
+
     def _interaction_style_block(self, *, default_locale: str, user_message: str, snapshot: dict) -> str:
         normalized_locale = str(default_locale or "").lower()
         chinese_turn = normalized_locale.startswith("zh") or bool(re.search(r"[\u4e00-\u9fff]", user_message))
+        if self._workspace_mode(snapshot) == "copilot":
+            lines = [
+                f"- configured_default_locale: {default_locale}",
+                f"- current_turn_language_bias: {'zh' if chinese_turn else 'en'}",
+                "- collaboration_mode: user-directed copilot",
+                "- freeform_task_rule: if the user asks for a concrete research task, solve that task directly before introducing stage-routing language.",
+                "- requested_skill_hint_rule: in copilot mode, treat `requested_skill` as a lightweight routing hint, not as an instruction to default into `decision` for ordinary direct tasks.",
+                "- response_pattern: say what changed -> say what it means -> say what happens next",
+                "- mailbox_protocol: artifact.interact(include_recent_inbound_messages=True) remains the queued human-message mailbox and should be checked whenever human continuity matters.",
+                "- planning_rule: before non-trivial execution, make the immediate plan explicit and keep the first step small.",
+                "- tool_rule: use memory for durable recall, artifact for quest state and git-aware research operations, and bash_exec for terminal execution.",
+                "- copilot_sop_rule: classify the request first, choose the narrowest correct tool path, execute the smallest useful unit, persist the important result, then answer plainly.",
+                "- shell_tool_mandate: **for any shell, CLI, Python, bash, node, git, npm, uv, or environment command execution, use `bash_exec(...)`; do not use native `shell_command` or Codex `command_execution`.**",
+                "- git_tool_mandate: for git work inside the current quest repository or worktree, prefer `artifact.git(...)` before raw shell git commands.",
+                "- git_test_rule: if the user wants a generic git smoke test rather than a quest-repo mutation, use `bash_exec(...)` in an isolated scratch repository.",
+                "- decision_entry_rule: use `decision` only for real route, scope, cost, branch, or scientific-direction judgments; do not default to it for ordinary repo, code, environment, or execution tasks.",
+                "- stop_rule: once the current requested unit is done, send a concise update and wait for the next message or `/resume`.",
+                "- escalation_rule: if a route change materially affects cost, scope, or scientific direction, ask before proceeding.",
+            ]
+            if chinese_turn:
+                lines.append("- tone_hint: 使用自然、礼貌、专业的中文，先解释结论，再说明下一步。")
+            else:
+                lines.append("- tone_hint: use concise, natural, professional English and lead with the conclusion.")
+            return "\n".join(lines)
         bound_conversations = snapshot.get("bound_conversations") or []
         need_research_paper = self._need_research_paper(snapshot)
         decision_policy = self._decision_policy(snapshot)
         launch_mode = self._launch_mode(snapshot)
+        standard_profile = self._standard_profile(snapshot)
         custom_profile = self._custom_profile(snapshot)
         lines = [
             f"- configured_default_locale: {default_locale}",
@@ -869,11 +1221,13 @@ class PromptBuilder:
             f"- bound_conversation_count: {len(bound_conversations)}",
             f"- decision_policy: {decision_policy}",
             f"- launch_mode: {launch_mode}",
+            f"- standard_profile: {standard_profile if launch_mode == 'standard' else 'n/a'}",
             f"- custom_profile: {custom_profile if launch_mode == 'custom' else 'n/a'}",
             "- collaboration_mode: long-horizon, continuity-first, artifact-aware",
             "- response_pattern: say what changed -> say what it means -> say what happens next",
             "- interaction_protocol: first message may be plain conversation; after that, treat artifact.interact threads and mailbox polls as the main continuity spine across TUI, web, and connectors",
             "- shared_interaction_contract_precedence: use the shared interaction contract as the default user-facing cadence; the rules below add runtime-specific execution behavior instead of restating the same chat cadence",
+            "- shell_tool_mandate: **native `shell_command` / `command_execution` is forbidden; all shell-like execution must use `bash_exec(...)`.**",
             "- mailbox_protocol: artifact.interact(include_recent_inbound_messages=True) is the queued human-message mailbox; when it returns user text, treat that input as higher priority than background subtasks until it has been acknowledged",
             "- acknowledgment_protocol: after artifact.interact returns any human message, immediately send one substantive artifact.interact(...) follow-up; if the active connector runtime already emitted a transport-level receipt acknowledgement, do not send a redundant receipt-only message; if answerable, answer directly, otherwise state the short plan, nearest checkpoint, and that the current background subtask is paused",
             "- subtask_boundary_protocol: send a user-visible update whenever the active subtask changes materially, especially across intake -> audit, audit -> experiment planning, experiment planning -> run launch, run result -> drafting, or drafting -> review/rebuttal",
@@ -882,23 +1236,29 @@ class PromptBuilder:
             "- long_run_reporting_protocol: inspect real logs/status after each meaningful await cycle and at least once every 30 minutes at worst, but only send a user-visible update when there is a human-meaningful delta, blocker, recovery, route change, or the visibility bound would otherwise be exceeded",
             "- intervention_threshold_protocol: do not kill or restart a run merely because a short watch window passed without final completion; intervene only on explicit failure, clear invalidity, process exit, or no meaningful delta across a sufficiently long observation window",
             "- timeout_protocol: before using bash_exec(mode='await', ...), estimate whether the command can finish within the selected wait window; if runtime is uncertain or likely longer, use bash_exec(mode='detach', ...) and monitor instead of guessing a fake deadline",
+            f"- auto_continue_monitoring_protocol: if the runtime schedules background-progress auto_continue turns while a real external task is already active, treat them as low-frequency monitoring passes roughly every {_AUTO_CONTINUE_MONITOR_INTERVAL_SECONDS} seconds rather than as a fast polling loop",
+            "- auto_continue_prepare_protocol: in autonomous mode before a real long-running external task exists, rapid auto-continue passes around 0.2 seconds apart are acceptable only for active preparation, launch, or durable route closure work; they are not a substitute for starting the real task",
+            "- long_run_ownership_protocol: real long-running execution should stay alive in detached bash_exec sessions or the runtime process it launched; do not rely on repeated model turns to simulate continuous execution",
+            "- auto_continue_resume_protocol: on auto_continue turns, read the resume context spine first and continue from the latest durable user requirement, latest assistant checkpoint, latest run summary, recent memory cues, and current bash_exec state before changing route",
             "- blocking_protocol: use reply_mode='blocking' only for true unresolved user decisions; ordinary progress updates should stay threaded and non-blocking",
             "- credential_blocking_protocol: if continuation requires user-supplied external credentials or secrets such as an API key, GitHub key/token, or Hugging Face key/token, emit one structured blocking decision request that asks the user to provide the credential or choose an alternative route; do not invent placeholders or silently skip the blocked step",
             "- credential_wait_protocol: if that credential request remains unanswered, keep the quest waiting rather than self-resolving; if you are resumed without new credentials and no other work is possible, a long low-frequency park such as `bash_exec(command='sleep 3600', mode='await', timeout_seconds=3700)` is acceptable to avoid busy-looping",
             f"- standby_prefix_rule: when you intentionally leave one blocking standby interaction after task completion, prefix it with {'[等待决策]' if chinese_turn else '[Waiting for decision]'} and wait for a new user reply before continuing",
             "- stop_notice_protocol: if work must pause or stop, send a user-visible notice that explains why, confirms preserved context, and states that any new message or `/resume` will continue from the same quest",
             "- respect_protocol: write user-facing updates as natural, respectful, easy-to-follow chat; do not sound like a formal status report or internal tool log",
-            "- omission_protocol: for ordinary user-facing updates, omit file paths, artifact ids, branch/worktree ids, session ids, raw commands, raw logs, and internal tool names unless the user asked for them or needs them to act",
+            "- novice_context_protocol: assume the user may not know the repo layout, branch model, artifact schema, or tool names; explain progress in task language first.",
+            "- structure_protocol: when explaining 2 to 3 options, tradeoffs, or next steps, prefer a short numbered structure so the user can scan the decision surface quickly.",
+            "- example_and_numbers_protocol: when it materially improves understanding, include one short example or 1 to 3 key numbers or comparisons instead of relying only on vague adjectives such as better, slower, or more stable.",
+            "- omission_protocol: for ordinary user-facing updates, omit file paths, file names, artifact ids, branch/worktree ids, session ids, raw commands, raw logs, and internal tool names unless the user asked for them or needs them to act",
             "- compaction_protocol: ordinary artifact.interact progress updates should usually fit in 2 to 4 short sentences and should not read like a monitoring transcript or execution diary",
-            "- watchdog_payload_protocol: if a tool result includes `watchdog_notes`, `progress_watchdog_note`, `visibility_watchdog_note`, or `state_change_watchdog_note`, treat that as an action item and send the required artifact.interact(...) update before doing more background work",
+            "- watchdog_payload_protocol: if a tool result includes `watchdog_notes`, `progress_watchdog_note`, `visibility_watchdog_note`, or `state_change_watchdog_note`, treat that as an action item to inspect state and decide whether a fresh user-visible update is actually needed; do not emit duplicate progress by reflex",
             "- human_progress_shape_protocol: ordinary progress updates should usually make three things explicit in human language: the current task, the main difficulty or latest real progress, and the concrete next measure you will take",
             "- stage_contract_protocol: stage-specific plan/checklist rules, milestone rules, literature rules, and writing rules belong in the requested skill; do not expect this runtime block to restate them",
             "- teammate_voice_protocol: write like a calm capable teammate using natural first-person phrasing when helpful, for example 'I'm working on ...', 'The main issue right now is ...', 'Next I'll ...'; do not sound like a dashboard or incident log",
-            "- translation_protocol: convert internal actions into user-facing meaning; describe what was finished and why it matters instead of naming every touched file, counter, timestamp, or subprocess",
+            "- translation_protocol: convert internal actions into user-facing meaning; describe what was finished and why it matters instead of naming every touched file, path, branch, counter, timestamp, or subprocess",
             "- detail_gate_protocol: include exact counters, worker labels, timestamps, retry counts, or file names only when the user explicitly asked for them, when they change the recommended action, or when they are the only honest way to explain a real blocker",
             "- monitoring_summary_protocol: for long-running monitoring loops, summarize the frontier state in plain language such as still progressing, temporarily stalled, recovered, or needs intervention; do not narrate each watch window",
             "- preflight_rewrite_protocol: before sending artifact.interact, quickly self-check whether the draft reads like a monitoring log, file inventory, or internal diary; if it mentions watch windows, heartbeats, retry counters, raw counts, timestamps, or multiple file names without being necessary for user action, rewrite it into conclusion -> meaning -> next step first",
-            "- non_research_mode_protocol: if the user message looks like a non-research request, ask for a second confirmation before engaging stage skills or research workflow; after completion, leave one blocking standby interaction instead of repeatedly pinging",
             "- workspace_discipline: read and modify code inside current_workspace_root; treat quest_root as the canonical repo identity and durable runtime root",
             "- binary_safety: do not open or rewrite large binary assets unless truly necessary; prefer summaries, metadata, and targeted inspection first",
         ]
@@ -913,7 +1273,7 @@ class PromptBuilder:
         else:
             lines.extend(
                 [
-                    "- user_gated_decision_protocol: when continuation truly depends on user preference, approval, or scope choice, use one structured blocking decision request with 1 to 3 concrete options.",
+                    "- user_gated_decision_protocol: when continuation truly depends on user preference, approval, or scope choice, use one structured blocking decision request with 1 to 3 concrete options; for each option say what it means, how strongly you recommend it, and what impact it would have on speed, quality, cost, or risk.",
                     "- user_gated_restraint: even in user-gated mode, do not turn ordinary progress or ordinary stage completion into blocking interrupts.",
                 ]
             )
@@ -925,6 +1285,10 @@ class PromptBuilder:
             lines.append(
                 "- completion_protocol: when `startup_contract.need_research_paper` is false, the quest goal is the strongest justified algorithmic result; keep iterating from measured main-experiment results and do not self-route into paper work by default"
             )
+        if launch_mode == "standard" and standard_profile == "optimization_task":
+            lines.append(
+                "- standard_optimization_completion_protocol: in this entry profile, do not treat missing paper artifacts or missing analysis-campaign artifacts as unfinished work by themselves; keep pushing the optimization frontier until the result plateaus, a blocker appears, or the user changes scope."
+            )
         if chinese_turn:
             lines.extend(
                 [
@@ -942,141 +1306,40 @@ class PromptBuilder:
         return "\n".join(lines)
 
     def _quest_context_block(self, quest_root: Path) -> str:
-        parts = []
-        for title, filename in (
-            ("Brief", "brief.md"),
-            ("Plan", "plan.md"),
-            ("Status", "status.md"),
-            ("Summary", "SUMMARY.md"),
-        ):
-            text = read_text(quest_root / filename).strip() or "(empty)"
-            parts.extend([f"{title} ({filename}):", text, ""])
-        return "\n".join(parts).strip()
+        return "\n".join(
+            [
+                "- quest_context_rule: quest documents are durable but not pre-expanded here.",
+                "- quest_documents_tool: call artifact.read_quest_documents(names=['brief','plan','status','summary'], mode='excerpt'|'full') when document detail is needed.",
+                "- active_user_requirements_tool: call artifact.read_quest_documents(names=['active_user_requirements'], mode='full') when exact current durable user requirements matter.",
+            ]
+        )
 
     def _durable_state_block(self, snapshot: dict, quest_root: Path) -> str:
-        requested_baseline_ref = (
-            dict(snapshot.get("requested_baseline_ref") or {})
-            if isinstance(snapshot.get("requested_baseline_ref"), dict)
-            else None
-        )
-        startup_contract = (
-            dict(snapshot.get("startup_contract") or {})
-            if isinstance(snapshot.get("startup_contract"), dict)
-            else None
-        )
         confirmed_baseline_ref = (
             dict(snapshot.get("confirmed_baseline_ref") or {})
             if isinstance(snapshot.get("confirmed_baseline_ref"), dict)
-            else None
+            else {}
         )
-        requested_baseline_id = str((requested_baseline_ref or {}).get("baseline_id") or "").strip()
-        confirmed_baseline_id = str((confirmed_baseline_ref or {}).get("baseline_id") or "").strip()
-        confirmed_baseline_rel_path = str(
-            (confirmed_baseline_ref or {}).get("baseline_root_rel_path") or ""
-        ).strip()
         confirmed_metric_contract_json_rel_path = str(
-            (confirmed_baseline_ref or {}).get("metric_contract_json_rel_path") or ""
+            confirmed_baseline_ref.get("metric_contract_json_rel_path") or ""
         ).strip()
-        prebound_baseline_ready = bool(
-            requested_baseline_id
-            and confirmed_baseline_id
-            and requested_baseline_id == confirmed_baseline_id
-            and str(snapshot.get("baseline_gate") or "").strip().lower() == "confirmed"
-        )
         lines = [
             f"- baseline_gate: {snapshot.get('baseline_gate') or 'pending'}",
             f"- active_baseline_id: {snapshot.get('active_baseline_id') or 'none'}",
-            f"- active_baseline_variant_id: {snapshot.get('active_baseline_variant_id') or 'none'}",
-            f"- requested_baseline_ref: {json.dumps(requested_baseline_ref, ensure_ascii=False, sort_keys=True) if requested_baseline_ref else 'none'}",
-            f"- startup_contract: {json.dumps(startup_contract, ensure_ascii=False, sort_keys=True) if startup_contract else 'none'}",
-            f"- startup_decision_policy: {self._decision_policy(snapshot)}",
-            f"- confirmed_baseline_ref: {json.dumps(confirmed_baseline_ref, ensure_ascii=False, sort_keys=True) if confirmed_baseline_ref else 'none'}",
-            f"- confirmed_baseline_import_root: {confirmed_baseline_rel_path or 'none'}",
-            f"- prebound_baseline_ready: {prebound_baseline_ready}",
             f"- active_run_id: {snapshot.get('active_run_id') or 'none'}",
-            f"- research_head_branch: {snapshot.get('research_head_branch') or 'none'}",
-            f"- research_head_worktree_root: {snapshot.get('research_head_worktree_root') or 'none'}",
-            f"- current_workspace_branch: {snapshot.get('current_workspace_branch') or 'none'}",
-            f"- current_workspace_root: {snapshot.get('current_workspace_root') or 'none'}",
             f"- active_idea_id: {snapshot.get('active_idea_id') or 'none'}",
-            f"- active_idea_md_path: {snapshot.get('active_idea_md_path') or 'none'}",
             f"- active_analysis_campaign_id: {snapshot.get('active_analysis_campaign_id') or 'none'}",
-            f"- next_pending_slice_id: {snapshot.get('next_pending_slice_id') or 'none'}",
+            f"- active_paper_line_ref: {snapshot.get('active_paper_line_ref') or 'none'}",
+            f"- current_workspace_branch: {snapshot.get('current_workspace_branch') or 'none'}",
+            f"- current_workspace_root: {snapshot.get('current_workspace_root') or 'none'}",
             f"- workspace_mode: {snapshot.get('workspace_mode') or 'quest'}",
             f"- runtime_status: {snapshot.get('runtime_status') or snapshot.get('status') or 'unknown'}",
-            f"- stop_reason: {snapshot.get('stop_reason') or 'none'}",
-            f"- pending_decisions: {', '.join(snapshot.get('pending_decisions') or []) or 'none'}",
-            f"- pending_user_message_count: {snapshot.get('pending_user_message_count') or 0}",
-            f"- active_interaction_count: {len(snapshot.get('active_interactions') or [])}",
             f"- waiting_interaction_id: {snapshot.get('waiting_interaction_id') or 'none'}",
-            f"- latest_thread_interaction_id: {snapshot.get('latest_thread_interaction_id') or 'none'}",
-            f"- default_reply_interaction_id: {snapshot.get('default_reply_interaction_id') or 'none'}",
-            f"- last_artifact_interact_at: {snapshot.get('last_artifact_interact_at') or 'none'}",
-            f"- seconds_since_last_artifact_interact: {snapshot.get('seconds_since_last_artifact_interact') if snapshot.get('seconds_since_last_artifact_interact') is not None else 'none'}",
-            f"- tool_calls_since_last_artifact_interact: {snapshot.get('tool_calls_since_last_artifact_interact') or 0}",
-            f"- last_tool_activity_at: {snapshot.get('last_tool_activity_at') or 'none'}",
-            f"- last_tool_activity_name: {snapshot.get('last_tool_activity_name') or 'none'}",
-            f"- last_delivered_batch_id: {snapshot.get('last_delivered_batch_id') or 'none'}",
-            f"- bound_conversations: {', '.join(snapshot.get('bound_conversations') or []) or 'none'}",
-            f"- cloud_linked: {snapshot.get('cloud', {}).get('linked', False)}",
+            f"- pending_user_message_count: {snapshot.get('pending_user_message_count') or 0}",
+            f"- continuation_policy: {snapshot.get('continuation_policy') or 'auto'}",
+            f"- continuation_anchor: {snapshot.get('continuation_anchor') or 'none'}",
+            "- quest_state_tool: call artifact.get_quest_state(detail='summary'|'full') for current runtime refs, interactions, recent artifacts, and recent runs.",
         ]
-        if prebound_baseline_ready and confirmed_baseline_rel_path:
-            lines.extend(
-                [
-                    "- prebound_baseline_execution_policy: runtime already attached and confirmed the requested baseline before this turn.",
-                    f"- prebound_baseline_runtime_path: {confirmed_baseline_rel_path}",
-                    "- prebound_baseline_agent_rule: do not redo baseline discovery or reproduction unless you find a concrete incompatibility, corruption, or missing evidence problem.",
-                ]
-            )
-        active_workspace_root = Path(str(snapshot.get("current_workspace_root") or quest_root))
-        attachment_root = active_workspace_root / "baselines" / "imported"
-        if attachment_root.exists():
-            attachments = [read_yaml(path, {}) for path in sorted(attachment_root.glob("*/attachment.yaml"))]
-            attachments = [
-                item
-                for item in attachments
-                if isinstance(item, dict)
-                and item
-                and (
-                    not str(item.get("source_baseline_id") or "").strip()
-                    or not self.baseline_registry.is_deleted(str(item.get("source_baseline_id") or "").strip())
-                )
-            ]
-            if attachments:
-                attachment = max(
-                    attachments,
-                    key=lambda item: (
-                        str(item.get("attached_at") or ""),
-                        str(item.get("source_baseline_id") or ""),
-                    ),
-                )
-                entry = attachment.get("entry") if isinstance(attachment.get("entry"), dict) else {}
-                confirmation = attachment.get("confirmation") if isinstance(attachment.get("confirmation"), dict) else {}
-                if not confirmed_metric_contract_json_rel_path:
-                    confirmed_metric_contract_json_rel_path = str(
-                        confirmation.get("metric_contract_json_rel_path") or ""
-                    ).strip()
-                contract = entry.get("metric_contract") if isinstance(entry.get("metric_contract"), dict) else {}
-                primary_metric_id = str(contract.get("primary_metric_id") or "").strip() or "none"
-                metric_ids = [
-                    str(item.get("metric_id") or "").strip()
-                    for item in contract.get("metrics", [])
-                    if isinstance(item, dict) and str(item.get("metric_id") or "").strip()
-                ]
-                lines.extend(
-                    [
-                        f"- active_baseline_primary_metric_id: {primary_metric_id}",
-                        f"- active_baseline_metric_ids: {', '.join(metric_ids) or 'none'}",
-                    ]
-                )
-        if (
-            not confirmed_metric_contract_json_rel_path
-            and confirmed_baseline_rel_path
-            and (quest_root / confirmed_baseline_rel_path / "json" / "metric_contract.json").exists()
-        ):
-            confirmed_metric_contract_json_rel_path = str(
-                Path(confirmed_baseline_rel_path, "json", "metric_contract.json").as_posix()
-            )
         if confirmed_metric_contract_json_rel_path:
             lines.extend(
                 [
@@ -1084,256 +1347,42 @@ class PromptBuilder:
                     "- active_baseline_metric_contract_rule: before planning or running `experiment` or `analysis-campaign`, read this JSON file and treat it as the canonical baseline comparison contract unless a newer confirmed baseline explicitly replaces it.",
                 ]
             )
-        analysis_baseline_inventory = read_json(quest_root / "artifacts" / "baselines" / "analysis_inventory.json", {})
-        analysis_baseline_inventory = analysis_baseline_inventory if isinstance(analysis_baseline_inventory, dict) else {}
-        analysis_inventory_entries = (
-            analysis_baseline_inventory.get("entries") if isinstance(analysis_baseline_inventory.get("entries"), list) else []
-        )
-        registered_count = sum(
-            1
-            for item in analysis_inventory_entries
-            if isinstance(item, dict) and str(item.get("status") or "").strip().lower() == "registered"
-        )
-        if analysis_inventory_entries:
-            lines.extend(
-                [
-                    f"- supplementary_baseline_inventory_status: artifacts/baselines/analysis_inventory.json [exists]",
-                    f"- supplementary_baseline_count: {len(analysis_inventory_entries)}",
-                    f"- supplementary_baseline_registered_count: {registered_count}",
-                ]
-            )
-        else:
-            lines.append("- supplementary_baseline_inventory_status: artifacts/baselines/analysis_inventory.json [missing]")
-        lines.extend(["", "Active interactions:"])
-        active_interactions = snapshot.get("active_interactions") or []
-        if active_interactions:
-            for item in active_interactions[-3:]:
-                interaction_id = item.get("interaction_id") or item.get("artifact_id") or "interaction"
-                status = item.get("status") or "unknown"
-                message = str(item.get("message") or "").strip().replace("\n", " ")
-                if len(message) > 180:
-                    message = message[:177].rstrip() + "..."
-                lines.append(f"- {interaction_id} [{status}] {message or '(no message)'}")
-        else:
-            lines.append("- none")
-        if int(snapshot.get("pending_user_message_count") or 0) > 0:
-            lines.extend(
-                [
-                    "",
-                    "Queued user-message notice:",
-                    "- There are queued user messages waiting to be picked up via artifact.interact(include_recent_inbound_messages=True).",
-                    "- Before continuing a resumed or follow-up turn, retrieve that mailbox payload first.",
-                    "- After the mailbox returns user text, immediately send a follow-up artifact.interact acknowledgement or direct answer before resuming background work.",
-                ]
-            )
-
-        lines.extend(
-            [
-                "",
-                "Recent artifacts:",
-            ]
-        )
-        recent_artifacts = snapshot.get("recent_artifacts") or []
-        if recent_artifacts:
-            for item in recent_artifacts[-5:]:
-                payload = item.get("payload") or {}
-                label = payload.get("artifact_id") or Path(item.get("path", "")).stem or "artifact"
-                summary = payload.get("summary") or payload.get("reason") or "No summary provided."
-                lines.append(f"- {item.get('kind')}: {label} -> {summary}")
-        else:
-            lines.append("- none")
-
-        lines.extend(["", "Recent runs:"])
-        recent_runs = snapshot.get("recent_runs") or []
-        if recent_runs:
-            for item in recent_runs[-5:]:
-                run_id = item.get("run_id") or "unknown-run"
-                summary = item.get("summary") or "No summary provided."
-                lines.append(f"- {run_id}: {summary}")
-        else:
-            lines.append("- none")
-
-        lines.extend(["", "Recent quest memory cards:"])
-        quest_cards = self.memory_service.list_recent(scope="quest", quest_root=quest_root, limit=5)
-        if quest_cards:
-            for card in quest_cards:
-                lines.append(f"- {card.get('type')}: {card.get('title')} ({card.get('path')})")
-        else:
-            lines.append("- none")
-
-        lines.extend(["", "Recent global memory cards:"])
-        global_cards = self.memory_service.list_recent(scope="global", limit=3)
-        if global_cards:
-            for card in global_cards:
-                lines.append(f"- {card.get('type')}: {card.get('title')} ({card.get('path')})")
-        else:
-            lines.append("- none")
-
-        lines.extend(["", "Reusable baselines:"])
-        baseline_entries = self.baseline_registry.list_entries()[-5:]
-        if baseline_entries:
-            for entry in baseline_entries:
-                baseline_id = entry.get("baseline_id") or entry.get("entry_id") or "unknown-baseline"
-                summary = entry.get("summary") or entry.get("task") or "No summary provided."
-                status = str(entry.get("status") or "unknown").strip() or "unknown"
-                lines.append(f"- {baseline_id} [{status}]: {summary}")
-        else:
-            lines.append("- none")
         return "\n".join(lines)
 
     def _paper_and_evidence_block(self, snapshot: dict, quest_root: Path) -> str:
-        workspace_root = Path(str(snapshot.get("active_workspace_root") or quest_root))
-        paper_root = workspace_root / "paper"
-        if not paper_root.exists():
-            paper_root = quest_root / "paper"
-        open_source_root = workspace_root / "release" / "open_source"
-        if not open_source_root.exists():
-            open_source_root = quest_root / "release" / "open_source"
-        selected_outline = read_json(paper_root / "selected_outline.json", {})
-        selected_outline = selected_outline if isinstance(selected_outline, dict) else {}
-        detailed_outline = (
-            dict(selected_outline.get("detailed_outline") or {})
-            if isinstance(selected_outline.get("detailed_outline"), dict)
+        paper_contract = (
+            dict(snapshot.get("paper_contract") or {})
+            if isinstance(snapshot.get("paper_contract"), dict)
             else {}
         )
-        bundle_manifest = read_json(paper_root / "paper_bundle_manifest.json", {})
-        bundle_manifest = bundle_manifest if isinstance(bundle_manifest, dict) else {}
-        paper_baseline_inventory = read_json(paper_root / "baseline_inventory.json", {})
-        paper_baseline_inventory = paper_baseline_inventory if isinstance(paper_baseline_inventory, dict) else {}
-        claim_evidence_map = read_json(paper_root / "claim_evidence_map.json", {})
-        claim_evidence_map = claim_evidence_map if isinstance(claim_evidence_map, dict) else {}
-        compile_report = read_json(paper_root / "build" / "compile_report.json", {})
-        compile_report = compile_report if isinstance(compile_report, dict) else {}
-        open_source_manifest = read_json(open_source_root / "manifest.json", {})
-        open_source_manifest = open_source_manifest if isinstance(open_source_manifest, dict) else {}
-        default_paper_prefix = (
-            paper_root.relative_to(quest_root).as_posix()
-            if paper_root.is_relative_to(quest_root)
-            else "paper"
-        )
-        default_release_prefix = (
-            open_source_root.relative_to(quest_root).as_posix()
-            if open_source_root.is_relative_to(quest_root)
-            else "release/open_source"
-        )
-
-        selected_outline_ref = str(
-            selected_outline.get("outline_id") or bundle_manifest.get("selected_outline_ref") or ""
-        ).strip()
-        selected_outline_title = str(
-            detailed_outline.get("title") or selected_outline.get("title") or bundle_manifest.get("title") or ""
-        ).strip()
-        research_questions_raw = detailed_outline.get("research_questions")
-        research_questions: list[str] = []
-        if isinstance(research_questions_raw, list):
-            for item in research_questions_raw:
-                if isinstance(item, dict):
-                    question = str(item.get("question_text") or item.get("title") or item.get("id") or "").strip()
-                else:
-                    question = str(item or "").strip()
-                if question:
-                    research_questions.append(question)
-
         lines = [
-            f"- selected_outline_ref: {selected_outline_ref or 'none'}",
-            f"- selected_outline_title: {selected_outline_title or 'none'}",
-            f"- selected_outline_story_present: {bool(selected_outline.get('story'))}",
-            f"- selected_outline_ten_questions_present: {bool(selected_outline.get('ten_questions'))}",
-            f"- active_research_question_count: {len(research_questions)}",
+            f"- selected_outline_ref: {str(paper_contract.get('selected_outline_ref') or 'none')}",
+            f"- selected_outline_title: {str(paper_contract.get('title') or 'none')}",
         ]
-        if research_questions:
-            for index, question in enumerate(research_questions[:3], start=1):
-                lines.append(f"- active_research_question_{index}: {question}")
-
-        def _path_status(path_str: str | None, *, fallback: str) -> str:
-            resolved = str(path_str or fallback).strip() or fallback
-            exists = (quest_root / resolved).exists()
-            return f"{resolved} [{'exists' if exists else 'missing'}]"
-
-        lines.extend(
-            [
-                f"- writing_plan_status: {_path_status(bundle_manifest.get('writing_plan_path'), fallback=f'{default_paper_prefix}/writing_plan.md')}",
-                f"- draft_status: {_path_status(bundle_manifest.get('draft_path'), fallback=f'{default_paper_prefix}/draft.md')}",
-                f"- references_status: {_path_status(bundle_manifest.get('references_path'), fallback=f'{default_paper_prefix}/references.bib')}",
-                f"- claim_evidence_map_status: {_path_status(bundle_manifest.get('claim_evidence_map_path'), fallback=f'{default_paper_prefix}/claim_evidence_map.json')}",
-                f"- baseline_inventory_status: {_path_status(bundle_manifest.get('baseline_inventory_path'), fallback=f'{default_paper_prefix}/baseline_inventory.json')}",
-                f"- review_status: {f'{default_paper_prefix}/review/review.md [exists]' if (paper_root / 'review' / 'review.md').exists() else f'{default_paper_prefix}/review/review.md [missing]'}",
-                f"- proofing_report_status: {f'{default_paper_prefix}/proofing/proofing_report.md [exists]' if (paper_root / 'proofing' / 'proofing_report.md').exists() else f'{default_paper_prefix}/proofing/proofing_report.md [missing]'}",
-                f"- page_images_manifest_status: {f'{default_paper_prefix}/proofing/page_images_manifest.json [exists]' if (paper_root / 'proofing' / 'page_images_manifest.json').exists() else f'{default_paper_prefix}/proofing/page_images_manifest.json [missing]'}",
-            ]
+        paper_contract_health = (
+            dict(snapshot.get("paper_contract_health") or {})
+            if isinstance(snapshot.get("paper_contract_health"), dict)
+            else {}
         )
-
-        if bundle_manifest:
-            pdf_rel_path = str(bundle_manifest.get("pdf_path") or "").strip()
-            compile_rel_path = str(bundle_manifest.get("compile_report_path") or "").strip()
-            latex_root_path = str(bundle_manifest.get("latex_root_path") or "").strip()
+        if paper_contract_health:
+            primary_blocker = str(
+                ((paper_contract_health.get("blocking_reasons") or [None])[0]) or "none"
+            ).strip() or "none"
             lines.extend(
                 [
-                    "- paper_bundle_manifest_present: True",
-                    f"- bundle_pdf_status: {_path_status(pdf_rel_path, fallback=f'{default_paper_prefix}/paper.pdf')}",
-                    f"- bundle_compile_report_status: {_path_status(compile_rel_path, fallback=f'{default_paper_prefix}/build/compile_report.json')}",
-                    f"- bundle_latex_root: {latex_root_path or 'none'}",
-                    f"- open_source_manifest_status: {_path_status(bundle_manifest.get('open_source_manifest_path'), fallback=f'{default_release_prefix}/manifest.json')}",
-                    f"- open_source_cleanup_plan_status: {_path_status(bundle_manifest.get('open_source_cleanup_plan_path'), fallback=f'{default_release_prefix}/cleanup_plan.md')}",
+                    f"- paper_contract_health: {'ready' if bool(paper_contract_health.get('writing_ready')) else 'blocked'}",
+                    f"- paper_health_counts: unresolved_required={int(paper_contract_health.get('unresolved_required_count') or 0)}, unmapped_completed={int(paper_contract_health.get('unmapped_completed_count') or 0)}, blocking_pending={int(paper_contract_health.get('blocking_open_supplementary_count') or 0)}",
+                    f"- paper_recommended_next_stage: {str(paper_contract_health.get('recommended_next_stage') or 'none')}",
+                    f"- paper_recommended_action: {str(paper_contract_health.get('recommended_action') or 'none')}",
+                    f"- paper_primary_blocker: {primary_blocker}",
+                    "- paper_health_tool: call artifact.get_paper_contract_health(detail='full') before paper-facing write/finalize work when the exact blocking items matter.",
+                    "- paper_outline_tool: call artifact.list_paper_outlines(...) when outline inventory or a valid outline_id is needed.",
+                    "- paper_campaign_tool: call artifact.get_analysis_campaign(campaign_id='active') when exact supplementary slice status matters.",
                 ]
             )
-        else:
-            lines.append("- paper_bundle_manifest_present: False")
-
-        claims = claim_evidence_map.get("claims") if isinstance(claim_evidence_map.get("claims"), list) else []
-        counts = {"supported": 0, "partial": 0, "unsupported": 0, "deferred": 0}
-        unresolved: list[str] = []
-        for item in claims:
-            if not isinstance(item, dict):
-                continue
-            status = str(item.get("support_status") or "").strip().lower()
-            if status in counts:
-                counts[status] += 1
-            if status in {"partial", "unsupported", "deferred"}:
-                claim_id = str(item.get("claim_id") or item.get("claim_text") or "claim").strip()
-                unresolved.append(f"{claim_id} [{status}]")
-        lines.append(
-            "- claim_status_counts: "
-            + ", ".join(f"{key}={value}" for key, value in counts.items())
-        )
-        if unresolved:
-            lines.append(f"- downgrade_watchlist: {'; '.join(unresolved[:5])}")
-        else:
-            lines.append("- downgrade_watchlist: none")
-
-        if compile_report:
-            lines.append(f"- compile_report_ok: {compile_report.get('ok') if 'ok' in compile_report else 'unknown'}")
-        supplementary_baselines = (
-            paper_baseline_inventory.get("supplementary_baselines")
-            if isinstance(paper_baseline_inventory.get("supplementary_baselines"), list)
-            else []
-        )
-        if paper_baseline_inventory:
-            lines.append(f"- paper_supplementary_baseline_count: {len(supplementary_baselines)}")
-        if open_source_manifest:
             lines.append(
-                f"- open_source_release_branch: {str(open_source_manifest.get('release_branch') or '').strip() or 'none'}"
+                "- paper_contract_rule: if the paper state is blocked, do not stabilize draft prose as if the paper were settled; follow the recommended paper action first."
             )
-
-        lines.extend(["", "Recent supporting runs:"])
-        recent_runs = snapshot.get("recent_runs") or []
-        supporting_runs = [
-            item
-            for item in recent_runs
-            if isinstance(item, dict) and str(item.get("run_id") or "").strip()
-        ]
-        if supporting_runs:
-            for item in supporting_runs[-3:]:
-                run_id = str(item.get("run_id") or "run").strip()
-                summary = str(item.get("summary") or "").strip() or "No summary provided."
-                lines.append(f"- {run_id}: {summary}")
-        else:
-            lines.append("- none")
-
-        lines.append("")
-        lines.append(
-            "- paper_state_rule: when drafting, reviewing, bundling, or finalizing, treat the selected outline, claim-evidence map, bundle manifest, proofing outputs, and downgrade watchlist as the active writing truth surface."
-        )
         return "\n".join(lines)
 
     def _priority_memory_block(
@@ -1346,46 +1395,53 @@ class PromptBuilder:
     ) -> str:
         stage = active_anchor if active_anchor in STAGE_MEMORY_PLAN else skill_id
         plan = STAGE_MEMORY_PLAN.get(stage, STAGE_MEMORY_PLAN["decision"])
+        quest_kinds = ", ".join(plan.get("quest", ())) or "none"
+        global_kinds = ", ".join(plan.get("global", ())) or "none"
+        lines = [
+            f"- stage_memory_rule: for `{stage}`, prefer quest memory kinds [{quest_kinds}] and global memory kinds [{global_kinds}] when memory lookup is needed.",
+            "- memory_lookup_tool: call memory.list_recent(...) to recover context after pause/restart and memory.search(...) before repeating prior work.",
+            "- memory_injection_rule: keep the injected memory compact, but do not drop all continuity on auto_continue turns; reuse a few recent durable cues directly when they materially anchor the next action.",
+        ]
         selected: list[dict] = []
         seen_paths: set[str] = set()
-
-        for scope in ("quest", "global"):
-            for kind in plan.get(scope, ()):
-                cards = self.memory_service.list_recent(
-                    scope=scope,
-                    quest_root=quest_root if scope == "quest" else None,
-                    kind=kind,
-                    limit=2,
-                )
-                if not cards:
-                    continue
+        for kind in plan.get("quest", ())[:2]:
+            for card in self.memory_service.list_recent(scope="quest", quest_root=quest_root, limit=2, kind=kind)[:1]:
                 self._append_priority_memory(
                     selected,
                     seen_paths,
-                    card=cards[-1],
-                    scope=scope,
+                    card=card,
+                    scope="quest",
                     quest_root=quest_root,
-                    reason=f"recent {stage} {kind} memory",
+                    reason=f"recent quest memory for stage `{stage}`",
                 )
-                if len(selected) >= 6:
-                    return self._format_priority_memory(selected)
-
-        for query in self._memory_queries(user_message):
-            matches = self.memory_service.search(query, scope="both", quest_root=quest_root, limit=6)
-            for card in matches:
-                scope = str(card.get("scope") or "quest")
+        for kind in plan.get("global", ())[:2]:
+            for card in self.memory_service.list_recent(scope="global", limit=2, kind=kind)[:1]:
                 self._append_priority_memory(
                     selected,
                     seen_paths,
                     card=card,
-                    scope=scope,
+                    scope="global",
                     quest_root=quest_root,
-                    reason=f"matches current user message: `{query}`",
+                    reason=f"recent global memory for stage `{stage}`",
                 )
-                if len(selected) >= 8:
-                    return self._format_priority_memory(selected)
-
-        return self._format_priority_memory(selected)
+        for query in self._memory_queries(user_message)[:2]:
+            for scope in ("quest", "global"):
+                for card in self.memory_service.search(
+                    query,
+                    scope=scope if scope == "global" else "quest",
+                    quest_root=quest_root if scope == "quest" else None,
+                    limit=1,
+                ):
+                    self._append_priority_memory(
+                        selected,
+                        seen_paths,
+                        card=card,
+                        scope=scope,
+                        quest_root=quest_root,
+                        reason=f"matched current-turn query `{query}`",
+                    )
+        lines.extend(["- selected_memory:", self._format_priority_memory(selected)])
+        return "\n".join(lines)
 
     def _append_priority_memory(
         self,
@@ -1447,20 +1503,12 @@ class PromptBuilder:
         return tokens
 
     def _conversation_block(self, quest_id: str, limit: int = 12) -> str:
-        records = self.quest_service.history(quest_id, limit=limit)
-        if not records:
-            return "- none"
-        lines = []
-        for item in records[-limit:]:
-            role = str(item.get("role") or "unknown")
-            source = str(item.get("source") or "unknown")
-            content = str(item.get("content") or "").strip().replace("\n", " ")
-            if len(content) > 400:
-                content = content[:397].rstrip() + "..."
-            reply_to = str(item.get("reply_to_interaction_id") or "").strip()
-            suffix = f" -> reply_to:{reply_to}" if reply_to else ""
-            lines.append(f"- [{role}|{source}]{suffix} {content}")
-        return "\n".join(lines)
+        return "\n".join(
+            [
+                "- conversation_context_rule: recent conversation is not pre-expanded here.",
+                f"- conversation_tool: call artifact.get_conversation_context(limit={limit}, include_attachments=False) when earlier turn continuity matters.",
+            ]
+        )
 
     def _markdown_body(self, path: Path) -> str:
         text = path.read_text(encoding="utf-8")