@researai/deepscientist 1.5.13 → 1.5.15

package/src/deepscientist/prompts/builder.py

@@ -16,6 +16,7 @@ STANDARD_SKILLS = (
     "scout",
     "baseline",
     "idea",
+    "optimize",
     "experiment",
     "analysis-campaign",
     "write",
@@ -43,6 +44,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,6 +71,38 @@ STAGE_MEMORY_PLAN = {
 }
 
 
+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:
         self.repo_root = repo_root
@@ -83,6 +120,8 @@ 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)
@@ -151,7 +190,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 +217,18 @@ 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),
+                "",
                 "## Interaction Style",
                 self._interaction_style_block(default_locale=default_locale, user_message=user_message, snapshot=snapshot),
                 "",
@@ -206,7 +256,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 +285,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 +321,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 +338,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:
@@ -472,7 +524,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 +554,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":
@@ -634,6 +701,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)
@@ -693,6 +778,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")
@@ -732,6 +826,7 @@ class PromptBuilder:
     def _research_delivery_policy_block(self, snapshot: dict) -> str:
         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,15 +834,14 @@ 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'}",
             f"- manuscript_edit_mode: {manuscript_edit_mode if custom_profile in {'review_audit', 'revision_rebuttal'} else 'n/a'}",
             f"- delivery_mode: {'paper_required' if need_research_paper else 'algorithm_first'}",
+            "- requested_skill_rule: stage-specific execution detail lives in the requested skill; this block only adds runtime launch policy.",
             "- idea_stage_rule: every accepted idea submission should normally create a new branch/worktree and a new user-visible research node.",
-            "- idea_draft_rule: before `artifact.submit_idea(...)`, first finish a concise durable Markdown draft for the chosen route; keep `idea.md` compact and `draft.md` richer.",
-            "- idea_literature_floor_rule: before writing or submitting a final selected idea, durably survey at least 5 and usually 5 to 10 related and usable papers; prioritize direct task-modeling or mechanism-neighbor work and only backfill with the closest adjacent translatable papers when necessary.",
-            "- idea_reference_rule: the final selected-idea draft should use one consistent standard citation format and include a `References` or `Bibliography` section for the survey-stage papers that actually shaped the motivation, mechanism, or claim boundary.",
             "- lineage_rule: normal idea routing uses exactly two lineage intents: `continue_line` creates a child of the current active branch; `branch_alternative` creates a sibling-like branch from the current branch's parent foundation.",
             "- revise_rule: `artifact.submit_idea(mode='revise', ...)` is maintenance-only compatibility for the same branch and should not be the default research-route mechanism.",
             "- post_main_result_rule: after every `artifact.record_main_experiment(...)`, first interpret the measured result and only then choose the next route.",
@@ -835,17 +929,21 @@ 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(
                 [
                     "- delivery_goal: the quest should normally continue until at least one paper-like deliverable exists.",
-                    "- main_result_rule: a strong main experiment is evidence, not the endpoint; usually continue into the necessary analysis, writing, or further strengthening work.",
-                    "- main_run_branch_rule: every durable main experiment should live on its own dedicated `run/*` branch/worktree so the result becomes a stable Canvas node instead of mutating the idea branch in place.",
-                    "- main_run_branch_rule_2: if the current workspace is still an idea branch when `artifact.record_main_experiment(...)` runs, the runtime will materialize a child `run/*` branch before durable recording; still prefer planning and implementation with that dedicated run branch in mind from the start.",
-                    "- paper_branch_rule: after the required analysis for a strong main result is complete, writing should continue on a dedicated `paper/*` branch/worktree derived from that run branch rather than on the quest root or on the evidence branch itself.",
-                    "- paper_branch_rule_2: treat the paper branch as the writing surface and the parent run branch as the evidence source; do not record new main experiments from the paper branch.",
-                    "- paper_template_rule: once paper writing starts, choose a real venue template from the `write` skill's `templates/` folder, copy it into `paper/latex/`, and default to `templates/iclr2026/` for general ML unless the user or venue contract clearly points elsewhere.",
-                    "- writing_rule: when the evidence becomes strong enough, analysis and paper writing remain in scope by default.",
+                    "- main_result_rule: a strong main experiment is evidence, not the endpoint; usually continue into analysis, writing, or strengthening work.",
+                    "- paper_branch_rule: writing should normally continue on a dedicated `paper/*` branch/worktree derived from the evidence line rather than mutating the evidence branch itself.",
                     "- review_gate_rule: before declaring a substantial paper/draft task done, open `review` for an independent skeptical audit; if that audit finds serious gaps, route to `analysis-campaign`, `baseline`, `scout`, or `write` instead of stopping.",
                     "- stop_rule: do not stop with only an improved algorithm or isolated run logs unless the user explicitly narrows scope.",
                 ]
@@ -854,6 +952,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.",
@@ -862,6 +963,69 @@ 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))
@@ -869,6 +1033,7 @@ class PromptBuilder:
         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}",
@@ -876,74 +1041,39 @@ 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",
             "- 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",
-            "- progress_protocol: emit artifact.interact(kind='progress', reply_mode='threaded', ...) at real human-meaningful checkpoints; if no natural checkpoint appears during active user-relevant work, prefer a concise keepalive once work has crossed roughly 6 tool calls with a human-meaningful delta, and do not drift beyond roughly 12 tool calls or about 8 minutes without a user-visible update",
-            "- stage_kickoff_protocol: after entering any stage or companion skill, send one user-visible artifact.interact progress update within the first 3 tool calls of substantial work",
-            "- read_plan_keepalive_protocol: if work is still mostly reading, searching, comparison, or planning, do not wait too long for a 'big result'; send one concise user-visible checkpoint after about 5 consecutive tool calls if the user would otherwise see silence",
             "- 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",
             "- smoke_then_detach_protocol: for baseline reproduction, main experiments, and analysis experiments, first validate the command path with a bounded smoke test; once the smoke test passes, launch the real long run with bash_exec(mode='detach', ...) and usually leave timeout_seconds unset rather than guessing a fake deadline",
             "- progress_first_monitoring_protocol: when supervising a long-running bash_exec session, judge health by forward progress rather than by whether the final artifact has already appeared within a short window",
-            "- delta_monitoring_protocol: compare deltas such as new sample counters, new task counters, new saved files, new last_output_seq values, or changed last_progress payloads; if any of these move forward, treat the run as alive and keep observing",
-            "- long_run_reporting_protocol: for long-running bash_exec monitoring loops, inspect real logs or status after each completed sleep/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 or when the 30-minute visibility bound would otherwise be exceeded; those updates should report the current status, the latest concrete evidence of progress or failure, and the next checkpoint",
-            "- long_run_watchdog_protocol: for baseline reproduction, baseline-running stages, main experiments, and other important detached runs, do not let more than 30 minutes pass without a real progress inspection and, if the run is still active, a user-visible artifact.interact progress update",
+            "- 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",
-            "- slow_model_patience_protocol: if the user says the model, endpoint, or workload is expected to be slow, widen the observation window before intervention and avoid repeated no-change updates",
-            "- saved_log_read_protocol: bash_exec(mode='read', id=...) returns the full saved rendered log when it is 2000 lines or fewer; for longer logs it returns a preview with the first 500 lines plus the last 1500 lines and tells you to use start/tail for omitted middle windows",
-            "- log_window_protocol: when you need a specific omitted middle region from a long saved log, use bash_exec(mode='read', id=..., start=..., tail=...) to read a forward rendered-line window",
-            "- tail_monitoring_protocol: when monitoring a detached run, prefer bash_exec(mode='read', id=..., tail_limit=..., order='desc') so you inspect the newest seq-based evidence first instead of re-reading full logs every time",
-            "- managed_recovery_protocol: if a detached baseline, main-experiment, or analysis run is clearly invalid, wedged, or superseded, stop it with bash_exec(mode='kill', id=...), document the reason, fix the issue, and relaunch cleanly instead of letting a bad run linger",
-            "- 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, or set timeout_seconds intentionally",
+            "- 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",
             "- 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",
-            "- tool_call_keepalive_protocol: for active multi-step work outside long detached experiment waits, prefer sending one concise artifact.interact progress update after roughly 6 tool calls when there is already a human-meaningful delta, and do not exceed roughly 12 tool calls or about 8 minutes without a user-visible checkpoint",
+            "- 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",
-            "- milestone_graduation_protocol: keep ordinary subtask completions concise; upgrade to a richer milestone report only when a stage-significant deliverable or route-changing checkpoint becomes durably true",
-            "- eta_visibility_protocol: for baseline reproduction, main experiments, analysis experiments, and other important long-running phases, progress updates should also make the expected time to the next meaningful result, next milestone, or next user-visible update explicit; use roughly 10 to 30 minutes as the normal update window, and if the ETA is unreliable, say that and give a realistic next check-in window instead",
-            "- stage_plan_protocol: for `baseline`, `experiment`, and `analysis-campaign`, do not jump straight into substantial setup, code changes, or real runs; first create or update quest-visible `PLAN.md` and `CHECKLIST.md`, then keep them aligned with the actual route",
-            "- baseline_plan_protocol: in `baseline`, read the source paper and source repo first when they exist, then make `PLAN.md` cover the route, source package, code touchpoints, smoke path, real-run path, fallback options, monitoring rules, and verification targets before substantial work continues",
-            "- experiment_plan_protocol: in `experiment`, make `PLAN.md` start with the selected idea summarized in 1 to 2 sentences and then map the idea into code touchpoints, comparability rules, smoke / pilot path, full-run path, fallback options, monitoring rules, and revision notes",
-            "- analysis_plan_protocol: in `analysis-campaign`, treat `PLAN.md` as the campaign charter and make it cover the slice list, comparability boundary, asset and comparator plan, smoke / full-run policy, reporting plan, and revision log before real slices launch",
-            "- checklist_maintenance_protocol: for those same stages, treat `CHECKLIST.md` as the living execution surface and update it during reading, setup, coding, smoke tests, real runs, validation, aggregation, and route changes instead of letting progress live only in chat",
-            "- plan_revision_protocol: if the route, comparability contract, source package, execution strategy, slice ordering, or campaign interpretation changes materially, revise `PLAN.md` before continuing",
-            "- plan_execution_stability_protocol: once `baseline` or `experiment` has a concrete `PLAN.md` route, implement that plan cleanly instead of repeatedly reshaping code and commands mid-flight; the normal default is one bounded smoke or pilot validation and then one real run, and extra retries should happen only after concrete failure, invalidity, or genuinely new evidence justifies them",
-            "- stage_milestone_summary_protocol: for accepted baseline, selected idea, completed main experiment, and completed analysis-campaign milestones, usually open with 1 to 2 sentences that say what happened, what it means, and the exact next step before expanding into more detail",
-            "- idea_milestone_protocol: immediately after a successful accepted artifact.submit_idea(...), send a threaded milestone that explains the idea in plain language and explicitly states whether it currently looks valid, research-worthy, and insight-bearing, plus the main risk and exact next experiment",
-            "- idea_divergence_protocol: in the idea stage, separate divergence from convergence; unless strong durable evidence already narrows the route to one obvious serious option, do not collapse onto the first plausible route before generating a small but meaningfully diverse candidate slate",
-            "- idea_lens_protocol: when idea candidates cluster around one mechanism family, deliberately switch ideation lenses such as problem-first vs solution-first, tension hunting, analogy transfer, inversion, or adjacent-possible reasoning before final selection",
-            "- idea_frontier_protocol: a temporary raw ideation slate may be larger, but after convergence the serious frontier should usually shrink back to 2 to 3 candidates and at most 5",
-            "- idea_why_now_protocol: every serious idea candidate should answer why now or what changed, not just what the mechanism is",
-            "- idea_balance_protocol: when the search space is not tiny, carry at least one conservative route and one higher-upside route into the final comparison",
-            "- idea_pitch_protocol: before artifact.submit_idea(...), make the winner pass a two-sentence pitch, a strongest-objection check, and a concrete why-now statement",
-            "- idea_literature_floor_protocol: do not write or submit the final selected idea until the durable survey covers at least 5 and usually 5 to 10 related and usable papers; if fewer than 5 direct papers exist, document the shortage and use the closest adjacent translatable work instead of skipping the gate",
-            "- idea_reference_protocol: the final selected-idea draft should cite the survey-stage papers it actually uses and end with a standard-format `References` or `Bibliography` section",
-            "- experiment_milestone_protocol: immediately after artifact.record_main_experiment(...) writes the durable result, send a threaded milestone that explains what was run, the main result, whether primary performance improved / worsened / stayed mixed versus the active baseline or best prior anchor, whether the route still looks promising, and the exact next step",
-            "- analysis_milestone_protocol: immediately after a meaningful completed analysis-campaign synthesis or route-significant campaign checkpoint, send a threaded milestone that explains which campaign question or slice set just closed, whether the claim boundary became stronger / weaker / mixed, the main caveat, and the exact next route",
-            "- paper_milestone_protocol: immediately after a meaningful paper or draft milestone such as selected outline, evidence-complete draft, major revision package, or bundle-ready paper, send a threaded milestone that explains what document milestone is now complete, which claims are now supportable, what still needs strengthening, and the exact next revision or execution route",
-            "- asset_grounded_analysis_protocol: before artifact.create_analysis_campaign(...), reuse current quest and user-provided assets first and only plan slices that are executable with the current assets, runtime/tooling, and available credentials",
-            "- infeasible_slice_protocol: if an analysis slice cannot actually be executed after bounded recovery, do not fake completion; record the slice with a non-success status, report the blocker explicitly, and do not pretend the system can do it",
-            "- explicit_improvement_protocol: never make the user infer performance improvement only from raw metrics; say plainly whether performance improved, worsened, or stayed mixed",
-            "- verified_reference_breadth_protocol: for paper-like writing, run broad literature search and reading, aim for roughly 30 to 50 verified references unless scope clearly justifies fewer, use one consistent citation workflow SEARCH -> VERIFY -> RETRIEVE -> VALIDATE -> ADD, use Semantic Scholar by default or Google Scholar manual search/export for discovery, use DOI/Crossref or other real metadata backfills for BibTeX and verification, Every final citation must correspond to a real paper from an actual source, store actual bibliography entries in paper/references.bib as valid BibTeX, do one explicit reference audit before bundling, and never invent citations from memory or hand-write BibTeX from scratch",
-            "- narrative_focus_protocol: for paper-like writing, organize the paper around one cohesive contribution, make What / Why / So What clear early, assume many readers judge in the order title -> abstract -> introduction -> figures, front-load value in those surfaces, use a five-part abstract formula, keep the introduction concise with 2 to 4 specific contribution bullets, and if the first sentence could be pasted into many unrelated ML papers then rewrite it until it becomes specific",
-            "- writing_reasoning_externalization_protocol: for paper-like writing, externalize major reasoning into durable notes such as paper/outline_selection.md, paper/claim_evidence_map.json, paper/related_work_map.md, paper/figure_storyboard.md, and paper/reviewer_first_pass.md; those notes should summarize current judgment, alternatives considered, evidence used, risks, and next revision action rather than hidden chain-of-thought",
-            "- outline_intro_value_protocol: for outlines and introductions, make research value explicit early and use a standard introduction arc: problem and stakes -> concrete gap/bottleneck -> remedy/core idea -> evidence preview -> contributions",
+            "- 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",
-            "- tqdm_progress_protocol: when you control the experiment code for baseline reproduction, main experiments, or analysis experiments, instrument long loops with a throttled tqdm-style progress reporter when feasible and also prefer periodic __DS_PROGRESS__ JSON markers so monitoring stays both human-readable and machine-usable",
-            "- 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 and do not send a no-change update merely because a sleep finished unless the user-visible timing bound requires it",
+            "- 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",
         ]
@@ -958,7 +1088,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.",
                 ]
             )
@@ -970,6 +1100,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(
                 [
@@ -987,137 +1121,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"- 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(
                 [
@@ -1125,256 +1162,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(
@@ -1387,46 +1210,15 @@ 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"])
-        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
-                self._append_priority_memory(
-                    selected,
-                    seen_paths,
-                    card=cards[-1],
-                    scope=scope,
-                    quest_root=quest_root,
-                    reason=f"recent {stage} {kind} memory",
-                )
-                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")
-                self._append_priority_memory(
-                    selected,
-                    seen_paths,
-                    card=card,
-                    scope=scope,
-                    quest_root=quest_root,
-                    reason=f"matches current user message: `{query}`",
-                )
-                if len(selected) >= 8:
-                    return self._format_priority_memory(selected)
-
-        return self._format_priority_memory(selected)
+        quest_kinds = ", ".join(plan.get("quest", ())) or "none"
+        global_kinds = ", ".join(plan.get("global", ())) or "none"
+        return "\n".join(
+            [
+                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: memory is intentionally not pre-expanded here; pull only the cards that matter now.",
+            ]
+        )
 
     def _append_priority_memory(
         self,
@@ -1488,20 +1280,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")