@researai/deepscientist 1.5.14 → 1.5.16

package/src/deepscientist/quest/service.py

@@ -10,19 +10,21 @@ import json
 import mimetypes
 import re
 import threading
+import time
 from pathlib import Path, PurePosixPath
 from typing import Any
 from urllib.parse import quote
 
 try:
-    import fcntl
-except ImportError:  # pragma: no cover
+    import fcntl  # pragma: no cover - exercised on POSIX
+except ImportError:  # pragma: no cover - exercised on Windows
     fcntl = None
 
-from ..artifact.metrics import build_metrics_timeline, extract_latest_metric
+from ..artifact.metrics import build_baseline_compare_payload, build_metrics_timeline, extract_latest_metric
 from ..config import ConfigManager
 from ..connector_runtime import conversation_identity_key, normalize_conversation_id, parse_conversation_id
-from ..gitops import current_branch, export_git_graph, head_commit, init_repo
+from ..file_lock import advisory_file_lock
+from ..gitops import current_branch, export_git_graph, head_commit, init_repo, list_branch_canvas, list_commit_canvas
 from ..home import repo_root
 from ..registries import BaselineRegistry
 from ..shared import append_jsonl, ensure_dir, generate_id, iter_jsonl, read_json, read_jsonl, read_jsonl_tail, read_text, read_yaml, resolve_within, run_command, sha256_text, slugify, utc_now, write_json, write_text, write_yaml
@@ -50,9 +52,13 @@ _CODEX_HISTORY_TAIL_LIMIT = 400
 _JSONL_STREAM_CHUNK_BYTES = 64 * 1024
 _EVENTS_OVERSIZED_LINE_BYTES = 8 * 1024 * 1024
 _OVERSIZED_EVENT_PREFIX_BYTES = 4096
+_PROJECTION_SCHEMA_VERSION = 1
+_PROJECTION_BUILD_TOTAL_STEPS = 3
+_PROJECTION_REFRESH_THROTTLE_SECONDS = 1.0
 _EVENT_TYPE_BYTES_RE = re.compile(rb'"(?:type|event_type)"\s*:\s*"([^"]+)"')
 _EVENT_TOOL_NAME_BYTES_RE = re.compile(rb'"tool_name"\s*:\s*"([^"]+)"')
 _EVENT_RUN_ID_BYTES_RE = re.compile(rb'"run_id"\s*:\s*"([^"]+)"')
+CONTINUATION_POLICIES = {"auto", "when_external_progress", "wait_for_user_or_resume", "none"}
 
 
 def _oversized_event_placeholder(*, prefix: bytes, line_bytes: int) -> dict[str, Any]:
@@ -166,6 +172,127 @@ def _iter_jsonl_records_safely(
                     yield payload
 
 
+def _parse_jsonl_record_line_safely(
+    raw_line: bytes,
+    *,
+    oversized_line_bytes: int = _EVENTS_OVERSIZED_LINE_BYTES,
+) -> dict[str, Any] | None:
+    raw = bytes(raw_line).strip()
+    if not raw:
+        return None
+    line_bytes = len(raw)
+    if line_bytes > oversized_line_bytes:
+        return _oversized_event_placeholder(
+            prefix=raw[:_OVERSIZED_EVENT_PREFIX_BYTES],
+            line_bytes=line_bytes,
+        )
+    try:
+        payload = json.loads(raw)
+    except json.JSONDecodeError:
+        return None
+    return payload if isinstance(payload, dict) else None
+
+
+def _tail_jsonl_records_safely(
+    path: Path,
+    *,
+    limit: int,
+    oversized_line_bytes: int = _EVENTS_OVERSIZED_LINE_BYTES,
+) -> tuple[list[tuple[int, dict[str, Any]]], int]:
+    normalized_limit = max(int(limit or 0), 0)
+    if normalized_limit <= 0 or not path.exists():
+        return [], 0
+    total = _count_jsonl_lines_fast(path)
+    if total <= 0:
+        return [], 0
+
+    raw_tail = _read_jsonl_tail_lines_fast(path, normalized_limit)
+    if not raw_tail:
+        return [], total
+
+    cursor_start = max(total - len(raw_tail) + 1, 1)
+    parsed: list[tuple[int, dict[str, Any]]] = []
+    for cursor, raw_line in enumerate(raw_tail, start=cursor_start):
+        payload = _parse_jsonl_record_line_safely(
+            raw_line,
+            oversized_line_bytes=oversized_line_bytes,
+        )
+        if isinstance(payload, dict):
+            parsed.append((cursor, payload))
+    return parsed, total
+
+
+def _count_jsonl_lines_fast(path: Path, *, chunk_size: int = 1024 * 1024) -> int:
+    if not path.exists():
+        return 0
+    total = 0
+    last_byte = b""
+    with path.open("rb") as handle:
+        while True:
+            chunk = handle.read(chunk_size)
+            if not chunk:
+                break
+            total += chunk.count(b"\n")
+            last_byte = chunk[-1:]
+    if total == 0 and last_byte:
+        return 1
+    if last_byte not in {b"", b"\n"}:
+        total += 1
+    return total
+
+
+def _read_jsonl_tail_lines_fast(path: Path, limit: int, *, chunk_size: int = 1024 * 1024) -> list[bytes]:
+    normalized_limit = max(int(limit or 0), 0)
+    if normalized_limit <= 0 or not path.exists():
+        return []
+
+    size = path.stat().st_size
+    if size <= 0:
+        return []
+
+    lines: deque[bytes] = deque()
+    remainder = b""
+    with path.open("rb") as handle:
+        position = size
+        while position > 0 and len(lines) < normalized_limit:
+            read_size = min(chunk_size, position)
+            position -= read_size
+            handle.seek(position)
+            chunk = handle.read(read_size)
+            payload = chunk + remainder
+            parts = payload.split(b"\n")
+            remainder = parts[0]
+            for raw_line in reversed(parts[1:]):
+                stripped = raw_line.rstrip(b"\r")
+                if not stripped.strip():
+                    continue
+                lines.appendleft(stripped)
+                if len(lines) >= normalized_limit:
+                    break
+        if len(lines) < normalized_limit and remainder.strip():
+            lines.appendleft(remainder.rstrip(b"\r"))
+    return list(lines)[-normalized_limit:]
+
+
+def _iter_jsonl_records_from_offset_safely(
+    path: Path,
+    *,
+    start_offset: int,
+    oversized_line_bytes: int = _EVENTS_OVERSIZED_LINE_BYTES,
+):
+    if not path.exists():
+        return
+    with path.open("rb") as handle:
+        handle.seek(max(int(start_offset or 0), 0))
+        for raw_line in handle:
+            payload = _parse_jsonl_record_line_safely(
+                raw_line,
+                oversized_line_bytes=oversized_line_bytes,
+            )
+            if isinstance(payload, dict):
+                yield payload
+
+
 class QuestService:
     def __init__(self, home: Path, skill_installer: SkillInstaller | None = None) -> None:
         self.home = home
@@ -176,12 +303,21 @@ class QuestService:
         self._file_cache: dict[str, dict[str, Any]] = {}
         self._jsonl_cache_lock = threading.Lock()
         self._jsonl_cache: dict[str, dict[str, Any]] = {}
+        self._jsonl_tail_cache: dict[str, dict[str, Any]] = {}
         self._snapshot_cache_lock = threading.Lock()
         self._snapshot_cache: dict[str, dict[str, Any]] = {}
         self._codex_history_cache_lock = threading.Lock()
         self._codex_history_cache: dict[str, dict[str, Any]] = {}
         self._runtime_state_locks_lock = threading.Lock()
         self._runtime_state_locks: dict[str, threading.Lock] = {}
+        self._artifact_projection_locks_lock = threading.Lock()
+        self._artifact_projection_locks: dict[str, threading.Lock] = {}
+        self._quest_projection_locks_lock = threading.Lock()
+        self._quest_projection_locks: dict[str, threading.Lock] = {}
+        self._quest_projection_builds_lock = threading.Lock()
+        self._quest_projection_builds: dict[str, threading.Thread] = {}
+        self._quest_projection_refresh_lock = threading.Lock()
+        self._quest_projection_refresh_at: dict[str, float] = {}
 
     def _quest_root(self, quest_id: str) -> Path:
         return self.quests_root / quest_id
@@ -274,6 +410,13 @@ class QuestService:
         return quest_root / ".ds" / "lab_canvas_state.json"
 
     def _default_research_state(self, quest_root: Path) -> dict[str, Any]:
+        quest_yaml = self.read_quest_yaml(quest_root)
+        startup_contract = (
+            dict(quest_yaml.get("startup_contract") or {})
+            if isinstance(quest_yaml.get("startup_contract"), dict)
+            else {}
+        )
+        workspace_mode = str(startup_contract.get("workspace_mode") or "").strip().lower() or "quest"
         return {
             "version": 1,
             "active_idea_id": None,
@@ -290,7 +433,7 @@ class QuestService:
             "paper_parent_worktree_root": None,
             "paper_parent_run_id": None,
             "next_pending_slice_id": None,
-            "workspace_mode": "quest",
+            "workspace_mode": workspace_mode,
             "last_flow_type": None,
             "updated_at": utc_now(),
         }
@@ -339,7 +482,9 @@ class QuestService:
             if value is _UNSET:
                 continue
             current[key] = str(value) if isinstance(value, Path) else value
-        return self.write_research_state(quest_root, current)
+        payload = self.write_research_state(quest_root, current)
+        self.schedule_projection_refresh(quest_root, kinds=("details", "canvas", "git_canvas"))
+        return payload
 
     def read_lab_canvas_state(self, quest_root: Path) -> dict[str, Any]:
         self._initialize_runtime_files(quest_root)
@@ -443,7 +588,288 @@ class QuestService:
             str(path),
         )
 
-    def _collect_artifacts(self, quest_root: Path) -> list[dict[str, Any]]:
+    @staticmethod
+    def _artifact_projection_path(quest_root: Path) -> Path:
+        return quest_root / ".ds" / "cache" / "artifact_projection.v2.json"
+
+    @staticmethod
+    def _artifact_projection_lock_path(quest_root: Path) -> Path:
+        return quest_root / ".ds" / "artifact_projection.lock"
+
+    @staticmethod
+    def _metrics_timeline_cache_path(quest_root: Path) -> Path:
+        return quest_root / ".ds" / "cache" / "metrics_timeline.v1.json"
+
+    @staticmethod
+    def _metrics_timeline_cache_lock_path(quest_root: Path) -> Path:
+        return quest_root / ".ds" / "cache" / "metrics_timeline.lock"
+
+    @staticmethod
+    def _baseline_compare_cache_path(quest_root: Path) -> Path:
+        return quest_root / ".ds" / "cache" / "baseline_compare.v1.json"
+
+    @staticmethod
+    def _baseline_compare_cache_lock_path(quest_root: Path) -> Path:
+        return quest_root / ".ds" / "cache" / "baseline_compare.lock"
+
+    @staticmethod
+    def _json_compatible_state(value: Any) -> Any:
+        if isinstance(value, tuple):
+            return [QuestService._json_compatible_state(item) for item in value]
+        if isinstance(value, list):
+            return [QuestService._json_compatible_state(item) for item in value]
+        if isinstance(value, dict):
+            return {
+                str(key): QuestService._json_compatible_state(item)
+                for key, item in value.items()
+            }
+        return value
+
+    @contextmanager
+    def _artifact_projection_lock(self, quest_root: Path):
+        lock_key = str(quest_root.resolve())
+        with self._artifact_projection_locks_lock:
+            thread_lock = self._artifact_projection_locks.setdefault(lock_key, threading.Lock())
+        with thread_lock:
+            with advisory_file_lock(self._artifact_projection_lock_path(quest_root)):
+                yield
+
+    def _artifact_index_collection_state(self, quest_root: Path) -> list[list[Any]]:
+        states: list[list[Any]] = []
+        for root in self._artifact_roots(quest_root):
+            artifacts_root = root / "artifacts"
+            if not artifacts_root.exists():
+                continue
+            try:
+                label = str(root.relative_to(quest_root))
+            except ValueError:
+                label = str(root)
+            states.append(
+                [
+                    label,
+                    self._json_compatible_state(self._path_state(artifacts_root / "_index.jsonl")),
+                ]
+            )
+        return states
+
+    def _metrics_timeline_attachment_state(self, quest_root: Path, workspace_root: Path) -> list[list[Any]]:
+        states: list[list[Any]] = []
+        seen_paths: set[str] = set()
+        for root in (workspace_root, quest_root):
+            attachment_root = root / "baselines" / "imported"
+            if not attachment_root.exists():
+                continue
+            for path in sorted(attachment_root.glob("*/attachment.yaml")):
+                key = str(path.resolve())
+                if key in seen_paths:
+                    continue
+                seen_paths.add(key)
+                try:
+                    label = str(path.relative_to(quest_root))
+                except ValueError:
+                    label = str(path)
+                states.append([label, self._json_compatible_state(self._path_state(path))])
+        return states
+
+    def _metrics_timeline_state(self, quest_root: Path, workspace_root: Path) -> list[Any]:
+        return [
+            str(workspace_root.resolve()),
+            self._artifact_index_collection_state(quest_root),
+            self._metrics_timeline_attachment_state(quest_root, workspace_root),
+        ]
+
+    def _baseline_compare_state(self, quest_root: Path, workspace_root: Path) -> list[Any]:
+        return [
+            str(workspace_root.resolve()),
+            self._artifact_index_collection_state(quest_root),
+            self._metrics_timeline_attachment_state(quest_root, workspace_root),
+            self._json_compatible_state(self._path_state(self._quest_yaml_path(quest_root))),
+        ]
+
+    def _baseline_compare_entries(self, quest_root: Path, workspace_root: Path) -> list[dict[str, Any]]:
+        entries: list[dict[str, Any]] = []
+        for item in self._collect_artifacts_raw(quest_root):
+            if str(item.get("kind") or "").strip() != "baselines":
+                continue
+            payload = item.get("payload") or {}
+            if not isinstance(payload, dict):
+                continue
+            status = str(payload.get("status") or "").strip().lower()
+            if status not in {"confirmed", "published", "quest_confirmed"}:
+                continue
+            entries.append(dict(payload))
+        attachment = self._active_baseline_attachment(quest_root, workspace_root)
+        attachment_entry = dict(attachment.get("entry") or {}) if isinstance(attachment, dict) else None
+        if attachment_entry:
+            entries.append(attachment_entry)
+        return entries
+
+    def _artifact_projection_state(self, quest_root: Path) -> tuple[str, Any]:
+        index_state = self._artifact_index_collection_state(quest_root)
+        if index_state and all(item[1] is not None for item in index_state):
+            return "index", index_state
+        if not index_state:
+            return "index", []
+        return "raw", self._json_compatible_state(self._artifact_collection_state(quest_root))
+
+    def _projection_artifact_item(
+        self,
+        *,
+        record: dict[str, Any],
+        artifact_path: Path,
+        workspace_root: Path,
+    ) -> dict[str, Any]:
+        return {
+            "kind": artifact_path.parent.name,
+            "path": str(artifact_path),
+            "payload": copy.deepcopy(record),
+            "workspace_root": str(workspace_root),
+        }
+
+    def _write_artifact_projection_locked(
+        self,
+        quest_root: Path,
+        *,
+        state_kind: str,
+        state: Any,
+        artifacts: list[dict[str, Any]],
+    ) -> list[dict[str, Any]]:
+        projection_path = self._artifact_projection_path(quest_root)
+        ensure_dir(projection_path.parent)
+        payload = {
+            "schema_version": 2,
+            "generated_at": utc_now(),
+            "state_kind": state_kind,
+            "state": self._json_compatible_state(state),
+            "artifacts": copy.deepcopy(artifacts),
+        }
+        write_json(projection_path, payload)
+        return copy.deepcopy(artifacts)
+
+    def refresh_artifact_projection(
+        self,
+        quest_root: Path,
+        *,
+        state_kind: str | None = None,
+        state: Any | None = None,
+    ) -> list[dict[str, Any]]:
+        resolved_state_kind, resolved_state = (
+            (state_kind, state)
+            if state_kind is not None and state is not None
+            else self._artifact_projection_state(quest_root)
+        )
+        artifacts = self._collect_artifacts_raw(quest_root)
+        return self._write_artifact_projection_locked(
+            quest_root,
+            state_kind=resolved_state_kind,
+            state=resolved_state,
+            artifacts=artifacts,
+        )
+
+    def update_artifact_projection(
+        self,
+        quest_root: Path,
+        *,
+        record: dict[str, Any],
+        artifact_path: Path,
+        workspace_root: Path,
+        previous_state_kind: str | None = None,
+        previous_state: Any | None = None,
+        current_state_kind: str | None = None,
+        current_state: Any | None = None,
+    ) -> list[dict[str, Any]]:
+        resolved_previous_kind = previous_state_kind
+        resolved_previous_state = self._json_compatible_state(previous_state) if previous_state is not None else None
+        resolved_current_kind, resolved_current_state = (
+            (current_state_kind, self._json_compatible_state(current_state))
+            if current_state_kind is not None and current_state is not None
+            else self._artifact_projection_state(quest_root)
+        )
+        projection_path = self._artifact_projection_path(quest_root)
+        with self._artifact_projection_lock(quest_root):
+            payload = read_json(projection_path, {})
+            projected_artifacts = payload.get("artifacts") if isinstance(payload.get("artifacts"), list) else None
+            can_incrementally_update = (
+                isinstance(payload, dict)
+                and int(payload.get("schema_version") or 0) == 2
+                and isinstance(projected_artifacts, list)
+                and resolved_previous_kind is not None
+                and payload.get("state_kind") == resolved_previous_kind
+                and self._json_compatible_state(payload.get("state")) == resolved_previous_state
+            )
+            if not can_incrementally_update:
+                return self.refresh_artifact_projection(
+                    quest_root,
+                    state_kind=resolved_current_kind,
+                    state=resolved_current_state,
+                )
+
+            artifacts: list[dict[str, Any]] = [
+                dict(item)
+                for item in projected_artifacts
+                if isinstance(item, dict)
+            ]
+            next_item = self._projection_artifact_item(
+                record=record,
+                artifact_path=artifact_path,
+                workspace_root=workspace_root,
+            )
+            next_identity = self._artifact_item_identity(
+                artifact_path,
+                record,
+                kind=str(next_item.get("kind") or ""),
+            )
+            try:
+                next_mtime_ns = artifact_path.stat().st_mtime_ns
+            except OSError:
+                next_mtime_ns = 0
+            replaced = False
+            for index, existing in enumerate(artifacts):
+                existing_payload = existing.get("payload") if isinstance(existing.get("payload"), dict) else {}
+                existing_path = Path(str(existing.get("path") or artifact_path))
+                if (
+                    self._artifact_item_identity(
+                        existing_path,
+                        existing_payload,
+                        kind=str(existing.get("kind") or existing_path.parent.name or ""),
+                    )
+                    != next_identity
+                ):
+                    continue
+                try:
+                    existing_mtime_ns = existing_path.stat().st_mtime_ns
+                except OSError:
+                    existing_mtime_ns = 0
+                if self._artifact_item_rank(
+                    record,
+                    path=artifact_path,
+                    mtime_ns=next_mtime_ns,
+                ) >= self._artifact_item_rank(
+                    existing_payload,
+                    path=existing_path,
+                    mtime_ns=existing_mtime_ns,
+                ):
+                    artifacts[index] = next_item
+                replaced = True
+                break
+            if not replaced:
+                artifacts.append(next_item)
+            artifacts.sort(
+                key=lambda item: str(
+                    ((item.get("payload") or {}).get("updated_at"))
+                    or ((item.get("payload") or {}).get("created_at"))
+                    or item.get("path")
+                    or ""
+                )
+            )
+            return self._write_artifact_projection_locked(
+                quest_root,
+                state_kind=resolved_current_kind,
+                state=resolved_current_state,
+                artifacts=artifacts,
+            )
+
+    def _collect_artifacts_raw(self, quest_root: Path) -> list[dict[str, Any]]:
         artifacts_by_identity: dict[str, dict[str, Any]] = {}
         for root in self._artifact_roots(quest_root):
             artifacts_root = root / "artifacts"
@@ -494,33 +920,1689 @@ class QuestService:
         )
         return artifacts
 
-    def _active_baseline_attachment(self, quest_root: Path, workspace_root: Path) -> dict[str, Any] | None:
-        attachments: list[dict[str, Any]] = []
-        seen_paths: set[str] = set()
-        for root in (workspace_root, quest_root):
-            attachment_root = root / "baselines" / "imported"
-            if not attachment_root.exists():
+    def _collect_artifacts(self, quest_root: Path) -> list[dict[str, Any]]:
+        state_kind, state = self._artifact_projection_state(quest_root)
+        projection_path = self._artifact_projection_path(quest_root)
+        cached_projection = self._read_cached_json(projection_path, {})
+        if (
+            isinstance(cached_projection, dict)
+            and int(cached_projection.get("schema_version") or 0) == 2
+            and cached_projection.get("state_kind") == state_kind
+            and self._json_compatible_state(cached_projection.get("state")) == self._json_compatible_state(state)
+            and isinstance(cached_projection.get("artifacts"), list)
+        ):
+            return [
+                dict(item)
+                for item in cached_projection.get("artifacts") or []
+                if isinstance(item, dict)
+            ]
+
+        with self._artifact_projection_lock(quest_root):
+            cached_projection = self._read_cached_json(projection_path, {})
+            if (
+                isinstance(cached_projection, dict)
+                and int(cached_projection.get("schema_version") or 0) == 2
+                and cached_projection.get("state_kind") == state_kind
+                and self._json_compatible_state(cached_projection.get("state")) == self._json_compatible_state(state)
+                and isinstance(cached_projection.get("artifacts"), list)
+            ):
+                return [
+                    dict(item)
+                    for item in cached_projection.get("artifacts") or []
+                    if isinstance(item, dict)
+                ]
+            return self.refresh_artifact_projection(
+                quest_root,
+                state_kind=state_kind,
+                state=state,
+            )
+
+    def _collect_run_artifacts_raw(
+        self,
+        quest_root: Path,
+        *,
+        run_kind: str | None = None,
+    ) -> list[dict[str, Any]]:
+        artifacts_by_identity: dict[str, dict[str, Any]] = {}
+        normalized_run_kind = str(run_kind or "").strip()
+        for root in self._artifact_roots(quest_root):
+            runs_root = root / "artifacts" / "runs"
+            if not runs_root.exists():
+                continue
+            for path in sorted(runs_root.glob("*.json")):
+                item = self._read_cached_json(path, {})
+                payload = item if isinstance(item, dict) else {}
+                if normalized_run_kind and str(payload.get("run_kind") or "").strip() != normalized_run_kind:
+                    continue
+                try:
+                    mtime_ns = path.stat().st_mtime_ns
+                except OSError:
+                    mtime_ns = 0
+                artifact = {
+                    "kind": "run",
+                    "path": str(path),
+                    "payload": item,
+                    "workspace_root": str(root),
+                }
+                identity = self._artifact_item_identity(path, payload, kind="run")
+                existing = artifacts_by_identity.get(identity)
+                existing_payload = existing.get("payload") if isinstance((existing or {}).get("payload"), dict) else {}
+                existing_path = Path(str((existing or {}).get("path") or path))
+                try:
+                    existing_mtime_ns = existing_path.stat().st_mtime_ns if existing else 0
+                except OSError:
+                    existing_mtime_ns = 0
+                if existing is None or self._artifact_item_rank(
+                    payload,
+                    path=path,
+                    mtime_ns=mtime_ns,
+                ) >= self._artifact_item_rank(
+                    existing_payload,
+                    path=existing_path,
+                    mtime_ns=existing_mtime_ns,
+                ):
+                    artifacts_by_identity[identity] = artifact
+        artifacts = list(artifacts_by_identity.values())
+        artifacts.sort(
+            key=lambda item: str(
+                ((item.get("payload") or {}).get("updated_at"))
+                or ((item.get("payload") or {}).get("created_at"))
+                or item.get("path")
+                or ""
+            )
+        )
+        return artifacts
+
+    @staticmethod
+    def _projection_id(kind: str) -> str:
+        return f"{kind}.v1"
+
+    @staticmethod
+    def _projection_directory(quest_root: Path) -> Path:
+        return quest_root / ".ds" / "projections"
+
+    @classmethod
+    def _projection_manifest_path(cls, quest_root: Path) -> Path:
+        return cls._projection_directory(quest_root) / "manifest.json"
+
+    @classmethod
+    def _projection_payload_path(cls, quest_root: Path, kind: str) -> Path:
+        return cls._projection_directory(quest_root) / f"{cls._projection_id(kind)}.json"
+
+    @classmethod
+    def _projection_lock_path(cls, quest_root: Path, kind: str) -> Path:
+        return cls._projection_directory(quest_root) / f"{cls._projection_id(kind)}.lock"
+
+    def _projection_build_key(self, quest_root: Path, kind: str) -> str:
+        return f"{quest_root.resolve()}::{kind}"
+
+    def _codex_history_events_state(self, quest_root: Path) -> tuple[tuple[str, tuple[int, int, int] | None], ...]:
+        return self._glob_states(quest_root / ".ds" / "codex_history", "*/events.jsonl")
+
+    def _details_projection_state(self, quest_root: Path) -> tuple[Any, ...]:
+        workspace_root = self.active_workspace_root(quest_root)
+        core_paths = [
+            self._quest_yaml_path(quest_root),
+            quest_root / "status.md",
+            quest_root / ".ds" / "runtime_state.json",
+            quest_root / ".ds" / "research_state.json",
+            quest_root / ".ds" / "interaction_state.json",
+            quest_root / ".ds" / "bindings.json",
+            quest_root / ".ds" / "bash_exec" / "summary.json",
+            self._artifact_projection_path(quest_root),
+            workspace_root / "brief.md",
+            workspace_root / "plan.md",
+            workspace_root / "status.md",
+            workspace_root / "SUMMARY.md",
+        ]
+        return (
+            str(workspace_root.resolve()),
+            self._path_states(core_paths),
+            self._codex_meta_state(quest_root),
+            self._codex_history_events_state(quest_root),
+        )
+
+    def _git_branch_projection_state(self, quest_root: Path) -> dict[str, Any]:
+        result = run_command(
+            [
+                "git",
+                "for-each-ref",
+                "--sort=refname",
+                "--format=%(refname:short)%09%(objectname)%09%(committerdate:iso-strict)",
+                "refs/heads",
+            ],
+            cwd=quest_root,
+            check=False,
+        )
+        refs = [line.strip() for line in str(result.stdout or "").splitlines() if line.strip()]
+        if result.returncode != 0:
+            refs = [f"error:{result.returncode}:{str(result.stderr or '').strip()}"]
+        return {
+            "current_ref": current_branch(quest_root),
+            "head": head_commit(quest_root),
+            "refs": refs,
+        }
+
+    def _canvas_projection_state(self, quest_root: Path) -> tuple[Any, ...]:
+        return (
+            self._path_states(
+                [
+                    self._quest_yaml_path(quest_root),
+                    quest_root / ".ds" / "research_state.json",
+                    self._artifact_projection_path(quest_root),
+                ]
+            ),
+            self._git_branch_projection_state(quest_root),
+        )
+
+    def _projection_state_for_kind(self, quest_root: Path, kind: str) -> Any:
+        if kind == "details":
+            return self._details_projection_state(quest_root)
+        if kind == "canvas":
+            return self._canvas_projection_state(quest_root)
+        if kind == "git_canvas":
+            return self._canvas_projection_state(quest_root)
+        raise ValueError(f"Unsupported projection kind `{kind}`.")
+
+    def _projection_source_signature(self, quest_root: Path, kind: str) -> str:
+        state = {
+            "projection_id": self._projection_id(kind),
+            "state": self._json_compatible_state(self._projection_state_for_kind(quest_root, kind)),
+        }
+        return sha256_text(json.dumps(state, ensure_ascii=False, sort_keys=True))
+
+    def _default_projection_status(self, kind: str) -> dict[str, Any]:
+        return {
+            "projection_id": self._projection_id(kind),
+            "state": "missing",
+            "progress_current": 0,
+            "progress_total": 0,
+            "current_step": None,
+            "source_signature": None,
+            "generated_at": None,
+            "last_success_at": None,
+            "error": None,
+        }
+
+    def _normalize_projection_status(self, kind: str, raw: Any) -> dict[str, Any]:
+        normalized = self._default_projection_status(kind)
+        if isinstance(raw, dict):
+            normalized.update(
+                {
+                    "state": str(raw.get("state") or normalized["state"]).strip() or normalized["state"],
+                    "progress_current": max(0, int(raw.get("progress_current") or 0)),
+                    "progress_total": max(0, int(raw.get("progress_total") or 0)),
+                    "current_step": str(raw.get("current_step") or "").strip() or None,
+                    "source_signature": str(raw.get("source_signature") or "").strip() or None,
+                    "generated_at": str(raw.get("generated_at") or "").strip() or None,
+                    "last_success_at": str(raw.get("last_success_at") or "").strip() or None,
+                    "error": str(raw.get("error") or "").strip() or None,
+                }
+            )
+        return normalized
+
+    def _read_projection_manifest(self, quest_root: Path) -> dict[str, Any]:
+        manifest = self._read_cached_json(
+            self._projection_manifest_path(quest_root),
+            {
+                "schema_version": _PROJECTION_SCHEMA_VERSION,
+                "projections": {},
+            },
+        )
+        if not isinstance(manifest, dict):
+            return {
+                "schema_version": _PROJECTION_SCHEMA_VERSION,
+                "projections": {},
+            }
+        return manifest
+
+    def _read_projection_payload_file(self, quest_root: Path, kind: str) -> dict[str, Any] | None:
+        payload = self._read_cached_json(self._projection_payload_path(quest_root, kind), {})
+        if not isinstance(payload, dict):
+            return None
+        if str(payload.get("projection_id") or "").strip() != self._projection_id(kind):
+            return None
+        if not isinstance(payload.get("payload"), dict):
+            return None
+        return payload
+
+    def _write_projection_manifest_locked(
+        self,
+        quest_root: Path,
+        kind: str,
+        status: dict[str, Any],
+    ) -> dict[str, Any]:
+        path = self._projection_manifest_path(quest_root)
+        ensure_dir(path.parent)
+        manifest = read_json(path, {})
+        if not isinstance(manifest, dict):
+            manifest = {}
+        projections = manifest.get("projections") if isinstance(manifest.get("projections"), dict) else {}
+        next_status = self._normalize_projection_status(kind, status)
+        projections = {
+            **projections,
+            kind: next_status,
+        }
+        write_json(
+            path,
+            {
+                "schema_version": _PROJECTION_SCHEMA_VERSION,
+                "updated_at": utc_now(),
+                "projections": projections,
+            },
+        )
+        return next_status
+
+    def _write_projection_payload_locked(
+        self,
+        quest_root: Path,
+        kind: str,
+        *,
+        source_signature: str,
+        payload: dict[str, Any],
+        generated_at: str | None = None,
+    ) -> dict[str, Any]:
+        path = self._projection_payload_path(quest_root, kind)
+        ensure_dir(path.parent)
+        resolved_generated_at = generated_at or utc_now()
+        wrapper = {
+            "schema_version": _PROJECTION_SCHEMA_VERSION,
+            "projection_id": self._projection_id(kind),
+            "generated_at": resolved_generated_at,
+            "source_signature": source_signature,
+            "payload": copy.deepcopy(payload),
+        }
+        write_json(path, wrapper)
+        return copy.deepcopy(payload)
+
+    @contextmanager
+    def _projection_lock(self, quest_root: Path, kind: str):
+        lock_key = self._projection_build_key(quest_root, kind)
+        with self._quest_projection_locks_lock:
+            thread_lock = self._quest_projection_locks.setdefault(lock_key, threading.Lock())
+        with thread_lock:
+            with advisory_file_lock(self._projection_lock_path(quest_root, kind)):
+                yield
+
+    def _projection_build_active(self, quest_root: Path, kind: str) -> bool:
+        build_key = self._projection_build_key(quest_root, kind)
+        with self._quest_projection_builds_lock:
+            thread = self._quest_projection_builds.get(build_key)
+            if thread is not None and not thread.is_alive():
+                self._quest_projection_builds.pop(build_key, None)
+                thread = None
+            return thread is not None
+
+    def _present_projection_status(
+        self,
+        quest_root: Path,
+        kind: str,
+        *,
+        source_signature: str,
+        payload_wrapper: dict[str, Any] | None,
+    ) -> dict[str, Any]:
+        manifest = self._read_projection_manifest(quest_root)
+        projections = manifest.get("projections") if isinstance(manifest.get("projections"), dict) else {}
+        status = self._normalize_projection_status(kind, projections.get(kind))
+        payload_signature = (
+            str(payload_wrapper.get("source_signature") or "").strip()
+            if isinstance(payload_wrapper, dict)
+            else None
+        ) or None
+        payload_generated_at = (
+            str(payload_wrapper.get("generated_at") or "").strip()
+            if isinstance(payload_wrapper, dict)
+            else None
+        ) or None
+        payload_ready = (
+            isinstance(payload_wrapper, dict)
+            and isinstance(payload_wrapper.get("payload"), dict)
+            and payload_signature == source_signature
+        )
+        if payload_ready:
+            status.update(
+                {
+                    "state": "ready",
+                    "source_signature": source_signature,
+                    "generated_at": payload_generated_at,
+                    "last_success_at": payload_generated_at or status.get("last_success_at"),
+                    "progress_current": _PROJECTION_BUILD_TOTAL_STEPS,
+                    "progress_total": _PROJECTION_BUILD_TOTAL_STEPS,
+                    "current_step": None,
+                    "error": None,
+                }
+            )
+            return status
+        if self._projection_build_active(quest_root, kind):
+            status["state"] = "building" if status.get("state") != "queued" else "queued"
+            status["progress_total"] = max(int(status.get("progress_total") or 0), _PROJECTION_BUILD_TOTAL_STEPS)
+            status["current_step"] = status.get("current_step") or "Building projection"
+            return status
+        if isinstance(payload_wrapper, dict) and isinstance(payload_wrapper.get("payload"), dict):
+            status.update(
+                {
+                    "state": "stale",
+                    "generated_at": payload_generated_at,
+                    "last_success_at": payload_generated_at or status.get("last_success_at"),
+                    "progress_current": 0,
+                    "progress_total": _PROJECTION_BUILD_TOTAL_STEPS,
+                    "current_step": "Queued for refresh",
+                }
+            )
+            return status
+        if status.get("state") == "failed":
+            status["progress_total"] = max(int(status.get("progress_total") or 0), _PROJECTION_BUILD_TOTAL_STEPS)
+            return status
+        return self._default_projection_status(kind)
+
+    def _queue_projection_build(self, quest_root: Path, kind: str, *, source_signature: str) -> None:
+        if self._projection_build_active(quest_root, kind):
+            return
+
+        with self._projection_lock(quest_root, kind):
+            payload_wrapper = self._read_projection_payload_file(quest_root, kind)
+            if (
+                isinstance(payload_wrapper, dict)
+                and str(payload_wrapper.get("source_signature") or "").strip() == source_signature
+                and isinstance(payload_wrapper.get("payload"), dict)
+            ):
+                ready_status = self._default_projection_status(kind)
+                ready_status.update(
+                    {
+                        "state": "ready",
+                        "source_signature": source_signature,
+                        "generated_at": str(payload_wrapper.get("generated_at") or "").strip() or None,
+                        "last_success_at": str(payload_wrapper.get("generated_at") or "").strip() or None,
+                        "progress_current": _PROJECTION_BUILD_TOTAL_STEPS,
+                        "progress_total": _PROJECTION_BUILD_TOTAL_STEPS,
+                    }
+                )
+                self._write_projection_manifest_locked(quest_root, kind, ready_status)
+                return
+            queued_status = self._default_projection_status(kind)
+            queued_status.update(
+                {
+                    "state": "queued",
+                    "source_signature": source_signature,
+                    "progress_current": 0,
+                    "progress_total": _PROJECTION_BUILD_TOTAL_STEPS,
+                    "current_step": "Queued for background rebuild",
+                    "error": None,
+                }
+            )
+            self._write_projection_manifest_locked(quest_root, kind, queued_status)
+
+        build_key = self._projection_build_key(quest_root, kind)
+
+        def _update_progress(current: int, step: str | None) -> None:
+            with self._projection_lock(quest_root, kind):
+                manifest = self._read_projection_manifest(quest_root)
+                projections = manifest.get("projections") if isinstance(manifest.get("projections"), dict) else {}
+                status = self._normalize_projection_status(kind, projections.get(kind))
+                status.update(
+                    {
+                        "state": "building",
+                        "source_signature": source_signature,
+                        "progress_current": max(0, min(current, _PROJECTION_BUILD_TOTAL_STEPS)),
+                        "progress_total": _PROJECTION_BUILD_TOTAL_STEPS,
+                        "current_step": step,
+                        "error": None,
+                    }
+                )
+                self._write_projection_manifest_locked(quest_root, kind, status)
+
+        def _worker() -> None:
+            try:
+                _update_progress(0, "Preparing projection inputs")
+                payload = self._build_projection_payload(
+                    quest_root,
+                    kind,
+                    source_signature=source_signature,
+                    update_progress=_update_progress,
+                )
+                _update_progress(_PROJECTION_BUILD_TOTAL_STEPS, "Writing projection")
+                generated_at = utc_now()
+                with self._projection_lock(quest_root, kind):
+                    self._write_projection_payload_locked(
+                        quest_root,
+                        kind,
+                        source_signature=source_signature,
+                        payload=payload,
+                        generated_at=generated_at,
+                    )
+                    ready_status = self._default_projection_status(kind)
+                    ready_status.update(
+                        {
+                            "state": "ready",
+                            "source_signature": source_signature,
+                            "generated_at": generated_at,
+                            "last_success_at": generated_at,
+                            "progress_current": _PROJECTION_BUILD_TOTAL_STEPS,
+                            "progress_total": _PROJECTION_BUILD_TOTAL_STEPS,
+                            "current_step": None,
+                            "error": None,
+                        }
+                    )
+                    self._write_projection_manifest_locked(quest_root, kind, ready_status)
+            except Exception as exc:
+                with self._projection_lock(quest_root, kind):
+                    failed_status = self._default_projection_status(kind)
+                    failed_status.update(
+                        {
+                            "state": "failed",
+                            "source_signature": source_signature,
+                            "progress_current": 0,
+                            "progress_total": _PROJECTION_BUILD_TOTAL_STEPS,
+                            "current_step": None,
+                            "error": str(exc),
+                        }
+                    )
+                    self._write_projection_manifest_locked(quest_root, kind, failed_status)
+            finally:
+                with self._quest_projection_builds_lock:
+                    active = self._quest_projection_builds.get(build_key)
+                    if active is threading.current_thread():
+                        self._quest_projection_builds.pop(build_key, None)
+
+        worker = threading.Thread(
+            target=_worker,
+            daemon=True,
+            name=f"ds-projection-{quest_root.name}-{kind}",
+        )
+        with self._quest_projection_builds_lock:
+            self._quest_projection_builds[build_key] = worker
+        worker.start()
+
+    def _recent_codex_runs(self, quest_root: Path, *, limit: int = 5) -> list[dict[str, Any]]:
+        history_root = quest_root / ".ds" / "codex_history"
+        if not history_root.exists():
+            return []
+        runs: list[dict[str, Any]] = []
+        for meta_path in sorted(history_root.glob("*/meta.json")):
+            payload = self._read_cached_json(meta_path, {})
+            if not isinstance(payload, dict) or not payload:
+                continue
+            record = dict(payload)
+            record.setdefault("history_root", str(meta_path.parent))
+            runs.append(record)
+        runs.sort(
+            key=lambda item: str(
+                item.get("updated_at")
+                or item.get("completed_at")
+                or item.get("created_at")
+                or item.get("run_id")
+                or ""
+            )
+        )
+        return runs[-limit:]
+
+    def _build_workflow_payload(
+        self,
+        quest_id: str,
+        quest_root: Path,
+        workspace_root: Path,
+        *,
+        recent_runs: list[dict[str, Any]],
+        recent_artifacts: list[dict[str, Any]],
+    ) -> dict[str, Any]:
+        entries: list[dict[str, Any]] = []
+        changed_files: list[dict[str, Any]] = []
+        seen_files: set[str] = set()
+
+        def add_file(path: str | None, *, source: str, document_id: str | None = None, writable: bool | None = None) -> None:
+            if not path:
+                return
+            normalized = str(path)
+            if normalized in seen_files:
+                return
+            seen_files.add(normalized)
+            resolved_document_id = document_id or self._path_to_document_id(
+                normalized,
+                quest_root=quest_root,
+                workspace_root=workspace_root,
+            )
+            changed_files.append(
+                {
+                    "path": normalized,
+                    "source": source,
+                    "document_id": resolved_document_id,
+                    "writable": writable,
+                }
+            )
+
+        for relative in ("brief.md", "plan.md", "status.md", "SUMMARY.md"):
+            add_file(
+                str(workspace_root / relative),
+                source="document",
+                document_id=relative,
+                writable=True,
+            )
+
+        for run in recent_runs:
+            run_id = str(run.get("run_id") or "run")
+            entries.append(
+                {
+                    "id": f"run:{run_id}",
+                    "kind": "run",
+                    "run_id": run_id,
+                    "skill_id": run.get("skill_id"),
+                    "title": run_id,
+                    "summary": run.get("summary") or "Run completed.",
+                    "status": "completed" if run.get("exit_code", 0) == 0 else "failed",
+                    "created_at": run.get("completed_at") or run.get("created_at") or run.get("updated_at"),
+                    "paths": [item for item in [run.get("history_root"), run.get("run_root"), run.get("output_path")] if item],
+                }
+            )
+            for path in (run.get("history_root"), run.get("run_root"), run.get("output_path")):
+                add_file(path, source="run")
+            history_root = run.get("history_root")
+            if history_root:
+                entries.extend(
+                    self._parse_codex_history_cached(
+                        Path(str(history_root)),
+                        quest_id=quest_id,
+                        run_id=run_id,
+                        skill_id=run.get("skill_id"),
+                    )
+                )
+
+        for artifact in recent_artifacts:
+            payload = artifact.get("payload") if isinstance(artifact.get("payload"), dict) else {}
+            artifact_path = artifact.get("path")
+            entries.append(
+                {
+                    "id": f"artifact:{payload.get('artifact_id') or artifact_path}",
+                    "kind": "artifact",
+                    "title": str(payload.get("artifact_id") or artifact.get("kind") or "artifact"),
+                    "summary": payload.get("summary") or payload.get("message") or payload.get("reason") or "Artifact updated.",
+                    "status": payload.get("status"),
+                    "reason": payload.get("reason"),
+                    "created_at": payload.get("updated_at") or payload.get("created_at"),
+                    "paths": list((payload.get("paths") or {}).values()) + ([str(artifact_path)] if artifact_path else []),
+                }
+            )
+            add_file(str(artifact_path) if artifact_path else None, source="artifact")
+            for path in (payload.get("paths") or {}).values():
+                add_file(str(path), source="artifact_path")
+
+        entries.sort(key=lambda item: str(item.get("created_at") or item.get("id") or ""))
+        return {
+            "quest_id": quest_id,
+            "quest_root": str(quest_root.resolve()),
+            "entries": entries[-80:],
+            "changed_files": changed_files[-30:],
+        }
+
+    def _build_details_projection_payload(
+        self,
+        quest_root: Path,
+        *,
+        source_signature: str,
+        update_progress: Any,
+    ) -> dict[str, Any]:
+        quest_id = quest_root.name
+        workspace_root = self.active_workspace_root(quest_root)
+        update_progress(1, "Loading recent workflow sources")
+        recent_artifacts = self._collect_artifacts(quest_root)[-8:]
+        recent_runs = self._recent_codex_runs(quest_root, limit=5)
+        update_progress(2, "Materializing workflow timeline")
+        return self._build_workflow_payload(
+            quest_id,
+            quest_root,
+            workspace_root,
+            recent_runs=recent_runs,
+            recent_artifacts=recent_artifacts,
+        )
+
+    def _build_canvas_projection_payload(
+        self,
+        quest_root: Path,
+        *,
+        source_signature: str,
+        update_progress: Any,
+    ) -> dict[str, Any]:
+        update_progress(1, "Scanning branch references")
+        update_progress(2, "Computing branch canvas")
+        return list_branch_canvas(quest_root, quest_id=quest_root.name)
+
+    def _build_git_canvas_projection_payload(
+        self,
+        quest_root: Path,
+        *,
+        source_signature: str,
+        update_progress: Any,
+    ) -> dict[str, Any]:
+        update_progress(1, "Scanning commit history")
+        update_progress(2, "Computing commit canvas")
+        return list_commit_canvas(quest_root, quest_id=quest_root.name)
+
+    def _build_projection_payload(
+        self,
+        quest_root: Path,
+        kind: str,
+        *,
+        source_signature: str,
+        update_progress: Any,
+    ) -> dict[str, Any]:
+        if kind == "details":
+            return self._build_details_projection_payload(
+                quest_root,
+                source_signature=source_signature,
+                update_progress=update_progress,
+            )
+        if kind == "canvas":
+            return self._build_canvas_projection_payload(
+                quest_root,
+                source_signature=source_signature,
+                update_progress=update_progress,
+            )
+        if kind == "git_canvas":
+            return self._build_git_canvas_projection_payload(
+                quest_root,
+                source_signature=source_signature,
+                update_progress=update_progress,
+            )
+        raise ValueError(f"Unsupported projection kind `{kind}`.")
+
+    def _placeholder_workflow_payload(self, quest_id: str, quest_root: Path) -> dict[str, Any]:
+        workspace_root = self.active_workspace_root(quest_root)
+        return self._build_workflow_payload(
+            quest_id,
+            quest_root,
+            workspace_root,
+            recent_runs=[],
+            recent_artifacts=[],
+        )
+
+    def _placeholder_canvas_payload(self, quest_id: str, quest_root: Path) -> dict[str, Any]:
+        research_state = self.read_research_state(quest_root)
+        default_ref = (
+            str(research_state.get("research_head_branch") or "").strip()
+            or str(research_state.get("current_workspace_branch") or "").strip()
+            or current_branch(quest_root)
+        )
+        return {
+            "quest_id": quest_id,
+            "default_ref": default_ref,
+            "current_ref": default_ref,
+            "head": head_commit(quest_root),
+            "nodes": [],
+            "edges": [],
+            "views": {
+                "ideas": [],
+                "analysis": [],
+            },
+        }
+
+    def _placeholder_git_canvas_payload(self, quest_id: str, quest_root: Path) -> dict[str, Any]:
+        research_state = self.read_research_state(quest_root)
+        return {
+            "quest_id": quest_id,
+            "workspace_mode": str(research_state.get("workspace_mode") or "copilot").strip() or "copilot",
+            "head": head_commit(quest_root),
+            "current_ref": current_branch(quest_root),
+            "nodes": [],
+            "edges": [],
+        }
+
+    def _projected_payload(self, quest_id: str, kind: str) -> dict[str, Any]:
+        quest_root = self._quest_root(quest_id)
+        source_signature = self._projection_source_signature(quest_root, kind)
+        payload_wrapper = self._read_projection_payload_file(quest_root, kind)
+        payload_ready = (
+            isinstance(payload_wrapper, dict)
+            and str(payload_wrapper.get("source_signature") or "").strip() == source_signature
+            and isinstance(payload_wrapper.get("payload"), dict)
+        )
+        if not payload_ready:
+            self._queue_projection_build(quest_root, kind, source_signature=source_signature)
+            payload_wrapper = self._read_projection_payload_file(quest_root, kind)
+        status = self._present_projection_status(
+            quest_root,
+            kind,
+            source_signature=source_signature,
+            payload_wrapper=payload_wrapper,
+        )
+        payload = (
+            copy.deepcopy(payload_wrapper.get("payload"))
+            if isinstance(payload_wrapper, dict) and isinstance(payload_wrapper.get("payload"), dict)
+            else None
+        )
+        if payload is None:
+            if kind == "details":
+                payload = self._placeholder_workflow_payload(quest_id, quest_root)
+            elif kind == "git_canvas":
+                payload = self._placeholder_git_canvas_payload(quest_id, quest_root)
+            else:
+                payload = self._placeholder_canvas_payload(quest_id, quest_root)
+        payload["projection_status"] = status
+        return payload
+
+    def prime_projection(self, quest_id: str, kind: str) -> None:
+        quest_root = self._quest_root(quest_id)
+        self._queue_projection_build(
+            quest_root,
+            kind,
+            source_signature=self._projection_source_signature(quest_root, kind),
+        )
+
+    def schedule_projection_refresh(
+        self,
+        quest_root: Path,
+        *,
+        kinds: tuple[str, ...] | list[str] | None = None,
+        throttle_seconds: float = _PROJECTION_REFRESH_THROTTLE_SECONDS,
+    ) -> None:
+        resolved_kinds = [
+            str(kind).strip()
+            for kind in (kinds or ("details", "canvas", "git_canvas"))
+            if str(kind).strip() in {"details", "canvas", "git_canvas"}
+        ]
+        if not resolved_kinds:
+            return
+        min_interval = max(0.0, float(throttle_seconds))
+        now = time.monotonic()
+        for kind in resolved_kinds:
+            build_key = self._projection_build_key(quest_root, kind)
+            if self._projection_build_active(quest_root, kind):
+                continue
+            with self._quest_projection_refresh_lock:
+                previous = float(self._quest_projection_refresh_at.get(build_key) or 0.0)
+                if min_interval > 0 and now - previous < min_interval:
+                    continue
+                self._quest_projection_refresh_at[build_key] = now
+            try:
+                self._queue_projection_build(
+                    quest_root,
+                    kind,
+                    source_signature=self._projection_source_signature(quest_root, kind),
+                )
+            except Exception:
+                continue
+
+    def git_branch_canvas(self, quest_id: str) -> dict[str, Any]:
+        return self._projected_payload(quest_id, "canvas")
+
+    def git_commit_canvas(self, quest_id: str) -> dict[str, Any]:
+        return self._projected_payload(quest_id, "git_canvas")
+
+    def _active_baseline_attachment(self, quest_root: Path, workspace_root: Path) -> dict[str, Any] | None:
+        attachments: list[dict[str, Any]] = []
+        seen_paths: set[str] = set()
+        for root in (workspace_root, quest_root):
+            attachment_root = root / "baselines" / "imported"
+            if not attachment_root.exists():
+                continue
+            for path in sorted(attachment_root.glob("*/attachment.yaml")):
+                key = str(path.resolve())
+                if key in seen_paths:
+                    continue
+                seen_paths.add(key)
+                payload = self._read_cached_yaml(path, {})
+                baseline_id = str(payload.get("source_baseline_id") or "").strip() if isinstance(payload, dict) else ""
+                if baseline_id and self.baseline_registry.is_deleted(baseline_id):
+                    continue
+                if isinstance(payload, dict) and payload:
+                    attachments.append(payload)
+        if not attachments:
+            return None
+        return max(
+            attachments,
+            key=lambda item: (
+                str(item.get("attached_at") or ""),
+                str(item.get("source_baseline_id") or ""),
+            ),
+        )
+
+    @staticmethod
+    def _markdown_excerpt(path: Path, *, max_lines: int = 8) -> str | None:
+        if not path.exists() or not path.is_file():
+            return None
+        text = read_text(path, "")
+        if not text.strip():
+            return None
+        lines = [line.rstrip() for line in text.splitlines() if line.strip()]
+        if not lines:
+            return None
+        excerpt = "\n".join(lines[:max_lines]).strip()
+        return excerpt or None
+
+    def _snapshot_workspace_candidates(self, quest_root: Path, workspace_root: Path) -> list[Path]:
+        candidates: list[Path] = []
+        seen: set[str] = set()
+
+        def add(path: Path | None) -> None:
+            if path is None:
+                return
+            resolved = path.resolve()
+            key = str(resolved)
+            if key in seen or not resolved.exists():
+                return
+            seen.add(key)
+            candidates.append(resolved)
+
+        add(workspace_root)
+        add(quest_root)
+        worktrees_root = quest_root / ".ds" / "worktrees"
+        if worktrees_root.exists():
+            for item in sorted(worktrees_root.iterdir()):
+                if item.is_dir():
+                    add(item)
+        return candidates
+
+    @staticmethod
+    def _path_mtime(path: Path) -> float:
+        try:
+            return path.stat().st_mtime
+        except OSError:
+            return 0.0
+
+    def _best_paper_root(self, quest_root: Path, workspace_root: Path) -> Path | None:
+        best_root: Path | None = None
+        best_rank: tuple[int, float] = (-1, -1.0)
+        for candidate in self._snapshot_workspace_candidates(quest_root, workspace_root):
+            paper_root = candidate / "paper"
+            if not paper_root.exists() or not paper_root.is_dir():
+                continue
+            selected_outline = paper_root / "selected_outline.json"
+            bundle_manifest = paper_root / "paper_bundle_manifest.json"
+            draft = paper_root / "draft.md"
+            score = 0
+            if selected_outline.exists():
+                score += 4
+            if bundle_manifest.exists():
+                score += 5
+            if draft.exists():
+                score += 2
+            latest = max(
+                self._path_mtime(selected_outline),
+                self._path_mtime(bundle_manifest),
+                self._path_mtime(draft),
+                self._path_mtime(paper_root),
+            )
+            rank = (score, latest)
+            if rank > best_rank:
+                best_rank = rank
+                best_root = paper_root
+        return best_root
+
+    def _outline_record_from_paper_root(self, paper_root: Path) -> dict[str, Any]:
+        outline_root = paper_root / "outline"
+        manifest_path = outline_root / "manifest.json"
+        if manifest_path.exists():
+            manifest = read_json(manifest_path, {})
+            if isinstance(manifest, dict) and manifest:
+                manifest_sections = [
+                    dict(item) for item in (manifest.get("sections") or []) if isinstance(item, dict)
+                ]
+                by_id = {
+                    str(item.get("section_id") or "").strip(): dict(item)
+                    for item in manifest_sections
+                    if str(item.get("section_id") or "").strip()
+                }
+                section_order = [
+                    str(item).strip() for item in (manifest.get("section_order") or []) if str(item).strip()
+                ]
+                sections_root = outline_root / "sections"
+                if sections_root.exists():
+                    for section_dir in sorted(sections_root.iterdir()):
+                        if not section_dir.is_dir():
+                            continue
+                        section_id = section_dir.name
+                        section = dict(by_id.get(section_id) or {})
+                        section.setdefault("section_id", section_id)
+                        section.setdefault("title", section_id)
+                        result_table_payload = read_json(section_dir / "result_table.json", {})
+                        rows = result_table_payload.get("rows") if isinstance(result_table_payload, dict) else []
+                        section["result_table"] = rows if isinstance(rows, list) else []
+                        by_id[section_id] = section
+                ordered_sections: list[dict[str, Any]] = []
+                emitted: set[str] = set()
+                for section_id in section_order:
+                    section = by_id.get(section_id)
+                    if section is None:
+                        continue
+                    ordered_sections.append(section)
+                    emitted.add(section_id)
+                for section_id, section in by_id.items():
+                    if section_id in emitted:
+                        continue
+                    ordered_sections.append(section)
+                return {
+                    "schema_version": 1,
+                    "outline_id": manifest.get("outline_id"),
+                    "status": manifest.get("status"),
+                    "title": manifest.get("title"),
+                    "note": manifest.get("note"),
+                    "story": manifest.get("story"),
+                    "ten_questions": manifest.get("ten_questions") if isinstance(manifest.get("ten_questions"), list) else [],
+                    "detailed_outline": manifest.get("detailed_outline") if isinstance(manifest.get("detailed_outline"), dict) else {},
+                    "sections": ordered_sections,
+                    "evidence_contract": manifest.get("evidence_contract") if isinstance(manifest.get("evidence_contract"), dict) else None,
+                    "created_at": manifest.get("created_at"),
+                    "updated_at": manifest.get("updated_at"),
+                }
+        selected_outline_path = paper_root / "selected_outline.json"
+        payload = read_json(selected_outline_path, {})
+        return payload if isinstance(payload, dict) else {}
+
+    def _paper_evidence_payload(self, quest_root: Path, workspace_root: Path) -> dict[str, Any] | None:
+        best_payload: dict[str, Any] | None = None
+        best_rank: tuple[str, float] = ("", -1.0)
+        for candidate in self._snapshot_workspace_candidates(quest_root, workspace_root):
+            paper_root = candidate / "paper"
+            ledger_json_path = paper_root / "evidence_ledger.json"
+            if not ledger_json_path.exists():
+                continue
+            payload = read_json(ledger_json_path, {})
+            if not isinstance(payload, dict) or not payload:
+                continue
+            items = [dict(item) for item in (payload.get("items") or []) if isinstance(item, dict)]
+            latest = max(
+                self._path_mtime(ledger_json_path),
+                self._path_mtime(paper_root / "evidence_ledger.md"),
+                self._path_mtime(paper_root),
+            )
+            rank = (str(payload.get("updated_at") or payload.get("created_at") or ""), latest)
+            if rank < best_rank:
+                continue
+            best_rank = rank
+            best_payload = {
+                "paper_root": str(paper_root),
+                "workspace_root": str(paper_root.parent),
+                "selected_outline_ref": str(payload.get("selected_outline_ref") or "").strip() or None,
+                "item_count": len(items),
+                "main_text_ready_count": sum(
+                    1
+                    for item in items
+                    if str(item.get("paper_role") or "").strip() == "main_text"
+                    and str(item.get("status") or "").strip().lower() in {"ready", "completed", "analyzed", "written", "recorded", "supported"}
+                ),
+                "appendix_item_count": sum(
+                    1 for item in items if str(item.get("paper_role") or "").strip() == "appendix"
+                ),
+                "unmapped_item_count": sum(
+                    1
+                    for item in items
+                    if not str(item.get("section_id") or "").strip() or not str(item.get("paper_role") or "").strip()
+                ),
+                "items": items[:40],
+                "paths": {
+                    "ledger_json": str(ledger_json_path),
+                    "ledger_md": str(paper_root / "evidence_ledger.md") if (paper_root / "evidence_ledger.md").exists() else None,
+                },
+            }
+        return best_payload
+
+    def _paper_contract_payload(self, quest_root: Path, workspace_root: Path) -> dict[str, Any] | None:
+        paper_root = self._best_paper_root(quest_root, workspace_root)
+        if paper_root is None:
+            return None
+        selected_outline_path = paper_root / "selected_outline.json"
+        selected_outline = self._outline_record_from_paper_root(paper_root)
+        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)
+            else {}
+        )
+        outline_manifest_path = paper_root / "outline" / "manifest.json"
+        bundle_manifest_path = paper_root / "paper_bundle_manifest.json"
+        bundle_manifest = read_json(bundle_manifest_path, {})
+        bundle_manifest = bundle_manifest if isinstance(bundle_manifest, dict) else {}
+        experiment_matrix_path = paper_root / "paper_experiment_matrix.md"
+        experiment_matrix_json_path = paper_root / "paper_experiment_matrix.json"
+        claim_map_path = paper_root / "claim_evidence_map.json"
+        paper_line_state_path = paper_root / "paper_line_state.json"
+        evidence_ledger = self._paper_evidence_payload(quest_root, workspace_root)
+        checklist_path = paper_root / "review" / "submission_checklist.json"
+        draft_path = paper_root / "draft.md"
+        status_path = paper_root.parent / "status.md"
+        summary_path = paper_root.parent / "SUMMARY.md"
+
+        raw_sections = selected_outline.get("sections") if isinstance(selected_outline.get("sections"), list) else []
+        sections = []
+        if raw_sections:
+            for index, raw in enumerate(raw_sections, start=1):
+                if not isinstance(raw, dict):
+                    continue
+                title = str(raw.get("title") or raw.get("section_id") or "").strip()
+                if not title:
+                    title = f"Section {index}"
+                sections.append(
+                    {
+                        "section_id": str(raw.get("section_id") or slugify(title, f"section-{index}")).strip() or slugify(title, f"section-{index}"),
+                        "title": title,
+                        "paper_role": str(raw.get("paper_role") or "").strip() or None,
+                        "status": str(raw.get("status") or "").strip() or None,
+                        "claims": raw.get("claims") if isinstance(raw.get("claims"), list) else [],
+                        "required_items": raw.get("required_items") if isinstance(raw.get("required_items"), list) else [],
+                        "optional_items": raw.get("optional_items") if isinstance(raw.get("optional_items"), list) else [],
+                        "result_table": raw.get("result_table") if isinstance(raw.get("result_table"), list) else [],
+                    }
+                )
+        else:
+            for item in detailed_outline.get("experimental_designs") or []:
+                text = str(item or "").strip()
+                if not text:
+                    continue
+                sections.append(
+                    {
+                        "section_id": slugify(text, "section"),
+                        "title": text,
+                        "paper_role": "main_text",
+                        "status": "recorded",
+                        "claims": [],
+                        "required_items": [],
+                        "optional_items": [],
+                        "result_table": [],
+                    }
+                )
+
+        return {
+            "paper_root": str(paper_root),
+            "workspace_root": str(paper_root.parent),
+            "paper_branch": str(bundle_manifest.get("paper_branch") or "").strip() or current_branch(paper_root.parent),
+            "source_branch": str(bundle_manifest.get("source_branch") or "").strip() or None,
+            "selected_outline_ref": str(selected_outline.get("outline_id") or bundle_manifest.get("selected_outline_ref") or "").strip() or None,
+            "title": str(selected_outline.get("title") or bundle_manifest.get("title") or "").strip() or None,
+            "story": str(selected_outline.get("story") or "").strip() or None,
+            "research_questions": detailed_outline.get("research_questions") if isinstance(detailed_outline.get("research_questions"), list) else [],
+            "experimental_designs": detailed_outline.get("experimental_designs") if isinstance(detailed_outline.get("experimental_designs"), list) else [],
+            "contributions": detailed_outline.get("contributions") if isinstance(detailed_outline.get("contributions"), list) else [],
+            "evidence_contract": selected_outline.get("evidence_contract") if isinstance(selected_outline.get("evidence_contract"), dict) else None,
+            "sections": sections,
+            "evidence_summary": {
+                "item_count": int((evidence_ledger or {}).get("item_count") or 0),
+                "main_text_ready_count": int((evidence_ledger or {}).get("main_text_ready_count") or 0),
+                "appendix_item_count": int((evidence_ledger or {}).get("appendix_item_count") or 0),
+                "unmapped_item_count": int((evidence_ledger or {}).get("unmapped_item_count") or 0),
+            },
+            "summary": str(bundle_manifest.get("summary") or "").strip() or self._markdown_excerpt(summary_path),
+            "paths": {
+                "selected_outline": str(selected_outline_path) if selected_outline_path.exists() else None,
+                "outline_manifest": str(outline_manifest_path) if outline_manifest_path.exists() else None,
+                "experiment_matrix": str(experiment_matrix_path) if experiment_matrix_path.exists() else None,
+                "experiment_matrix_json": str(experiment_matrix_json_path) if experiment_matrix_json_path.exists() else None,
+                "bundle_manifest": str(bundle_manifest_path) if bundle_manifest_path.exists() else None,
+                "claim_evidence_map": str(claim_map_path) if claim_map_path.exists() else None,
+                "paper_line_state": str(paper_line_state_path) if paper_line_state_path.exists() else None,
+                "evidence_ledger_json": str(((evidence_ledger or {}).get("paths") or {}).get("ledger_json")) if ((evidence_ledger or {}).get("paths") or {}).get("ledger_json") else None,
+                "evidence_ledger_md": str(((evidence_ledger or {}).get("paths") or {}).get("ledger_md")) if ((evidence_ledger or {}).get("paths") or {}).get("ledger_md") else None,
+                "submission_checklist": str(checklist_path) if checklist_path.exists() else None,
+                "draft": str(draft_path) if draft_path.exists() else None,
+                "status": str(status_path) if status_path.exists() else None,
+                "summary": str(summary_path) if summary_path.exists() else None,
+            },
+            "bundle_manifest": bundle_manifest or None,
+            "outline_payload": selected_outline or None,
+        }
+
+    def _paper_lines_payload(self, quest_root: Path, workspace_root: Path) -> tuple[list[dict[str, Any]], str | None]:
+        lines_by_id: dict[str, dict[str, Any]] = {}
+        active_ref: str | None = None
+        for candidate in self._snapshot_workspace_candidates(quest_root, workspace_root):
+            paper_root = candidate / "paper"
+            if not paper_root.exists() or not paper_root.is_dir():
+                continue
+            state_path = paper_root / "paper_line_state.json"
+            payload = read_json(state_path, {}) if state_path.exists() else {}
+            if not isinstance(payload, dict) or not payload:
+                contract = self._paper_contract_payload(quest_root, candidate)
+                if not contract:
+                    continue
+                bundle_manifest = (
+                    dict(contract.get("bundle_manifest") or {})
+                    if isinstance(contract.get("bundle_manifest"), dict)
+                    else {}
+                )
+                payload = {
+                    "paper_line_id": slugify(
+                        "::".join(
+                            [
+                                str(contract.get("paper_branch") or "paper").strip() or "paper",
+                                str(contract.get("selected_outline_ref") or "outline").strip() or "outline",
+                                str(bundle_manifest.get("source_run_id") or "run").strip() or "run",
+                            ]
+                        ),
+                        "paper-line",
+                    ),
+                    "paper_branch": contract.get("paper_branch"),
+                    "paper_root": str(paper_root),
+                    "workspace_root": str(candidate),
+                    "source_branch": contract.get("source_branch"),
+                    "source_run_id": bundle_manifest.get("source_run_id"),
+                    "source_idea_id": bundle_manifest.get("source_idea_id"),
+                    "selected_outline_ref": contract.get("selected_outline_ref"),
+                    "title": contract.get("title"),
+                    "required_count": sum(len(item.get("required_items") or []) for item in (contract.get("sections") or [])),
+                    "ready_required_count": int((contract.get("evidence_summary") or {}).get("main_text_ready_count") or 0),
+                    "section_count": len(contract.get("sections") or []),
+                    "ready_section_count": 0,
+                    "unmapped_count": int((contract.get("evidence_summary") or {}).get("unmapped_item_count") or 0),
+                    "open_supplementary_count": 0,
+                    "draft_status": "present" if (paper_root / "draft.md").exists() else "missing",
+                    "bundle_status": "present" if (paper_root / "paper_bundle_manifest.json").exists() else "missing",
+                    "updated_at": "",
+                }
+            paper_line_id = str(payload.get("paper_line_id") or "").strip()
+            if not paper_line_id:
+                continue
+            payload["paths"] = {
+                "paper_line_state": str(state_path) if state_path.exists() else None,
+                "paper_root": str(paper_root),
+            }
+            current = lines_by_id.get(paper_line_id)
+            if current is None or str(payload.get("updated_at") or "") >= str(current.get("updated_at") or ""):
+                lines_by_id[paper_line_id] = payload
+            if str(candidate) == str(workspace_root):
+                active_ref = paper_line_id
+        lines = sorted(lines_by_id.values(), key=lambda item: str(item.get("updated_at") or ""), reverse=True)
+        if not active_ref and lines:
+            active_ref = str(lines[0].get("paper_line_id") or "").strip() or None
+        return lines, active_ref
+
+    def _analysis_inventory_payload(self, quest_root: Path, workspace_root: Path) -> dict[str, Any] | None:
+        manifest_by_id: dict[str, dict[str, Any]] = {}
+        campaigns_root = quest_root / ".ds" / "analysis_campaigns"
+        if campaigns_root.exists():
+            for path in sorted(campaigns_root.glob("*.json")):
+                payload = read_json(path, {})
+                if not isinstance(payload, dict) or not payload:
+                    continue
+                campaign_id = str(payload.get("campaign_id") or path.stem).strip() or path.stem
+                manifest_by_id[campaign_id] = payload
+        campaigns_by_id: dict[str, dict[str, Any]] = {}
+        for candidate in self._snapshot_workspace_candidates(quest_root, workspace_root):
+            analysis_root = candidate / "experiments" / "analysis-results"
+            if not analysis_root.exists() or not analysis_root.is_dir():
+                continue
+            for campaign_dir in sorted(analysis_root.iterdir()):
+                if not campaign_dir.is_dir():
+                    continue
+                campaign_id = campaign_dir.name
+                todo_manifest_path = campaign_dir / "todo_manifest.json"
+                campaign_md_path = campaign_dir / "campaign.md"
+                summary_md_path = campaign_dir / "SUMMARY.md"
+                todo_manifest = read_json(todo_manifest_path, {})
+                todo_manifest = todo_manifest if isinstance(todo_manifest, dict) else {}
+                campaign_manifest = dict(manifest_by_id.get(campaign_id) or {})
+                todo_items = todo_manifest.get("todo_items") if isinstance(todo_manifest.get("todo_items"), list) else []
+                manifest_slices = {
+                    str(item.get("slice_id") or "").strip(): dict(item)
+                    for item in (campaign_manifest.get("slices") or [])
+                    if isinstance(item, dict) and str(item.get("slice_id") or "").strip()
+                }
+                slice_files = []
+                for path in sorted(campaign_dir.glob("*.md")):
+                    if path.name in {"campaign.md", "SUMMARY.md"}:
+                        continue
+                    slice_files.append(path)
+                slices: list[dict[str, Any]] = []
+                for index, path in enumerate(slice_files):
+                    matched_todo = todo_items[index] if index < len(todo_items) and isinstance(todo_items[index], dict) else {}
+                    slice_id = str(matched_todo.get("slice_id") or path.stem).strip() or path.stem
+                    title = str(matched_todo.get("title") or path.stem).strip() or path.stem
+                    manifest_slice = dict(manifest_slices.get(slice_id) or {})
+                    slices.append(
+                        {
+                            "slice_id": slice_id,
+                            "title": title,
+                            "status": str(manifest_slice.get("status") or matched_todo.get("status") or "completed").strip() or "completed",
+                            "tier": str(matched_todo.get("tier") or "").strip() or None,
+                            "exp_id": str(matched_todo.get("exp_id") or "").strip() or None,
+                            "paper_role": str(matched_todo.get("paper_placement") or matched_todo.get("paper_role") or "").strip() or None,
+                            "section_id": str(matched_todo.get("section_id") or "").strip() or None,
+                            "item_id": str(matched_todo.get("item_id") or "").strip() or None,
+                            "claim_links": matched_todo.get("claim_links") if isinstance(matched_todo.get("claim_links"), list) else [],
+                            "research_question": str(matched_todo.get("research_question") or "").strip() or None,
+                            "experimental_design": str(matched_todo.get("experimental_design") or "").strip() or None,
+                            "branch": str(manifest_slice.get("branch") or "").strip() or None,
+                            "worktree_root": str(manifest_slice.get("worktree_root") or "").strip() or None,
+                            "mapped": bool(
+                                str(matched_todo.get("section_id") or "").strip()
+                                and str(matched_todo.get("item_id") or "").strip()
+                                and str(matched_todo.get("paper_placement") or matched_todo.get("paper_role") or "").strip()
+                            ),
+                            "result_path": str(path),
+                            "result_excerpt": self._markdown_excerpt(path, max_lines=6),
+                        }
+                    )
+                record = {
+                    "campaign_id": campaign_id,
+                    "title": str((todo_manifest.get("campaign_origin") or {}).get("reason") or campaign_id).strip() or campaign_id,
+                    "active_idea_id": str(campaign_manifest.get("active_idea_id") or "").strip() or None,
+                    "parent_run_id": str(campaign_manifest.get("parent_run_id") or "").strip() or None,
+                    "parent_branch": str(campaign_manifest.get("parent_branch") or "").strip() or None,
+                    "paper_line_id": str(campaign_manifest.get("paper_line_id") or "").strip() or None,
+                    "paper_line_branch": str(campaign_manifest.get("paper_line_branch") or "").strip() or None,
+                    "paper_line_root": str(campaign_manifest.get("paper_line_root") or "").strip() or None,
+                    "selected_outline_ref": str(campaign_manifest.get("selected_outline_ref") or todo_manifest.get("selected_outline_ref") or "").strip() or None,
+                    "todo_manifest_path": str(todo_manifest_path) if todo_manifest_path.exists() else None,
+                    "campaign_path": str(campaign_md_path) if campaign_md_path.exists() else None,
+                    "summary_path": str(summary_md_path) if summary_md_path.exists() else None,
+                    "summary_excerpt": self._markdown_excerpt(summary_md_path, max_lines=10),
+                    "updated_at": str(campaign_manifest.get("updated_at") or "").strip() or None,
+                    "slice_count": len(slices),
+                    "completed_slice_count": sum(1 for item in slices if str(item.get("status") or "") == "completed"),
+                    "mapped_slice_count": sum(1 for item in slices if bool(item.get("mapped"))),
+                    "pending_slice_count": sum(1 for item in slices if str(item.get("status") or "") != "completed"),
+                    "slices": slices,
+                    "_rank": (
+                        len(slices),
+                        max(
+                            self._path_mtime(summary_md_path),
+                            self._path_mtime(campaign_md_path),
+                            self._path_mtime(todo_manifest_path),
+                            self._path_mtime(campaigns_root / f"{campaign_id}.json"),
+                            self._path_mtime(campaign_dir),
+                        ),
+                    ),
+                }
+                current = campaigns_by_id.get(campaign_id)
+                if current is None or record["_rank"] >= current["_rank"]:
+                    campaigns_by_id[campaign_id] = record
+
+        if not campaigns_by_id:
+            return None
+        campaigns = []
+        total_slices = 0
+        total_completed = 0
+        total_mapped = 0
+        for item in sorted(
+            campaigns_by_id.values(),
+            key=lambda payload: (payload["_rank"][1], payload["campaign_id"]),
+            reverse=True,
+        ):
+            total_slices += int(item.get("slice_count") or 0)
+            total_completed += int(item.get("completed_slice_count") or 0)
+            total_mapped += int(item.get("mapped_slice_count") or 0)
+            campaigns.append({key: value for key, value in item.items() if key != "_rank"})
+        return {
+            "campaign_count": len(campaigns),
+            "slice_count": total_slices,
+            "completed_slice_count": total_completed,
+            "mapped_slice_count": total_mapped,
+            "campaigns": campaigns,
+        }
+
+    def _idea_lines_payload(
+        self,
+        quest_root: Path,
+        *,
+        paper_lines: list[dict[str, Any]],
+        analysis_inventory: dict[str, Any] | None,
+    ) -> tuple[list[dict[str, Any]], str | None]:
+        artifacts = self._collect_artifacts(quest_root)
+        research_state = self.read_research_state(quest_root)
+        active_idea_id = str(research_state.get("active_idea_id") or "").strip() or None
+        active_ref: str | None = None
+        lines_by_id: dict[str, dict[str, Any]] = {}
+
+        def ensure_line(idea_id: str) -> dict[str, Any]:
+            current = lines_by_id.get(idea_id)
+            if current is None:
+                current = {
+                    "idea_line_id": idea_id,
+                    "idea_id": idea_id,
+                    "idea_branch": None,
+                    "idea_title": None,
+                    "lineage_intent": None,
+                    "parent_branch": None,
+                    "latest_main_run_id": None,
+                    "latest_main_run_branch": None,
+                    "paper_line_id": None,
+                    "paper_branch": None,
+                    "selected_outline_ref": None,
+                    "analysis_campaign_count": 0,
+                    "analysis_slice_count": 0,
+                    "completed_analysis_slice_count": 0,
+                    "mapped_analysis_slice_count": 0,
+                    "required_count": 0,
+                    "ready_required_count": 0,
+                    "unmapped_count": 0,
+                    "open_supplementary_count": 0,
+                    "draft_status": None,
+                    "bundle_status": None,
+                    "updated_at": "",
+                    "paths": {
+                        "idea_md": None,
+                        "idea_draft": None,
+                        "paper_line_state": None,
+                    },
+                }
+                lines_by_id[idea_id] = current
+            return current
+
+        def updated_rank(value: object) -> str:
+            return str(value or "").strip()
+
+        for artifact in artifacts:
+            kind = str(artifact.get("kind") or "").strip()
+            payload = artifact.get("payload") if isinstance(artifact.get("payload"), dict) else {}
+            if not payload:
                 continue
-            for path in sorted(attachment_root.glob("*/attachment.yaml")):
-                key = str(path.resolve())
-                if key in seen_paths:
-                    continue
-                seen_paths.add(key)
-                payload = self._read_cached_yaml(path, {})
-                baseline_id = str(payload.get("source_baseline_id") or "").strip() if isinstance(payload, dict) else ""
-                if baseline_id and self.baseline_registry.is_deleted(baseline_id):
+            idea_id = str(payload.get("idea_id") or "").strip()
+            if not idea_id:
+                continue
+            entry = ensure_line(idea_id)
+            if kind == "ideas":
+                current_rank = updated_rank(entry.get("updated_at"))
+                candidate_rank = updated_rank(payload.get("updated_at") or payload.get("created_at"))
+                if candidate_rank >= current_rank:
+                    details = dict(payload.get("details") or {}) if isinstance(payload.get("details"), dict) else {}
+                    paths = dict(payload.get("paths") or {}) if isinstance(payload.get("paths"), dict) else {}
+                    entry["idea_branch"] = str(payload.get("branch") or "").strip() or entry.get("idea_branch")
+                    entry["idea_title"] = str(details.get("title") or payload.get("title") or "").strip() or entry.get("idea_title")
+                    entry["lineage_intent"] = str(payload.get("lineage_intent") or details.get("lineage_intent") or "").strip() or entry.get("lineage_intent")
+                    entry["parent_branch"] = str(payload.get("parent_branch") or details.get("parent_branch") or "").strip() or entry.get("parent_branch")
+                    entry["updated_at"] = candidate_rank or entry.get("updated_at")
+                    entry["paths"] = {
+                        **dict(entry.get("paths") or {}),
+                        "idea_md": str(paths.get("idea_md") or "").strip() or dict(entry.get("paths") or {}).get("idea_md"),
+                        "idea_draft": str(paths.get("idea_draft_md") or details.get("idea_draft_path") or "").strip()
+                        or dict(entry.get("paths") or {}).get("idea_draft"),
+                    }
+            elif kind == "runs":
+                branch = str(payload.get("branch") or "").strip()
+                run_id = str(payload.get("run_id") or "").strip()
+                run_kind = str(payload.get("run_kind") or "").strip().lower()
+                if not run_id or branch.startswith("analysis/") or branch.startswith("paper/") or run_kind.startswith("analysis"):
                     continue
-                if isinstance(payload, dict) and payload:
-                    attachments.append(payload)
-        if not attachments:
-            return None
-        return max(
-            attachments,
+                current_rank = updated_rank(entry.get("latest_main_run_updated_at"))
+                candidate_rank = updated_rank(payload.get("updated_at") or payload.get("created_at"))
+                if candidate_rank >= current_rank:
+                    entry["latest_main_run_id"] = run_id
+                    entry["latest_main_run_branch"] = branch or entry.get("latest_main_run_branch")
+                    entry["latest_main_run_updated_at"] = candidate_rank
+                    entry["updated_at"] = max(updated_rank(entry.get("updated_at")), candidate_rank)
+
+        for line in paper_lines:
+            idea_id = str(line.get("source_idea_id") or "").strip()
+            if not idea_id:
+                continue
+            entry = ensure_line(idea_id)
+            current_rank = updated_rank(entry.get("paper_line_updated_at"))
+            candidate_rank = updated_rank(line.get("updated_at"))
+            if candidate_rank >= current_rank:
+                entry["paper_line_id"] = str(line.get("paper_line_id") or "").strip() or entry.get("paper_line_id")
+                entry["paper_branch"] = str(line.get("paper_branch") or "").strip() or entry.get("paper_branch")
+                entry["selected_outline_ref"] = str(line.get("selected_outline_ref") or "").strip() or entry.get("selected_outline_ref")
+                entry["required_count"] = int(line.get("required_count") or 0)
+                entry["ready_required_count"] = int(line.get("ready_required_count") or 0)
+                entry["unmapped_count"] = int(line.get("unmapped_count") or 0)
+                entry["open_supplementary_count"] = int(line.get("open_supplementary_count") or 0)
+                entry["draft_status"] = str(line.get("draft_status") or "").strip() or None
+                entry["bundle_status"] = str(line.get("bundle_status") or "").strip() or None
+                entry["paper_line_updated_at"] = candidate_rank
+                entry["updated_at"] = max(updated_rank(entry.get("updated_at")), candidate_rank)
+                entry["paths"] = {
+                    **dict(entry.get("paths") or {}),
+                    "paper_line_state": str(((line.get("paths") or {}) if isinstance(line.get("paths"), dict) else {}).get("paper_line_state") or "").strip()
+                    or dict(entry.get("paths") or {}).get("paper_line_state"),
+                }
+
+        campaigns = list((analysis_inventory or {}).get("campaigns") or []) if isinstance(analysis_inventory, dict) else []
+        for campaign in campaigns:
+            if not isinstance(campaign, dict):
+                continue
+            matched_idea_id = str(campaign.get("active_idea_id") or "").strip()
+            if not matched_idea_id:
+                matched_run_id = str(campaign.get("parent_run_id") or "").strip()
+                matched_branch = str(campaign.get("parent_branch") or "").strip()
+                for candidate in lines_by_id.values():
+                    if matched_run_id and matched_run_id == str(candidate.get("latest_main_run_id") or "").strip():
+                        matched_idea_id = str(candidate.get("idea_id") or "").strip()
+                        break
+                    if matched_branch and matched_branch in {
+                        str(candidate.get("idea_branch") or "").strip(),
+                        str(candidate.get("latest_main_run_branch") or "").strip(),
+                    }:
+                        matched_idea_id = str(candidate.get("idea_id") or "").strip()
+                        break
+            if not matched_idea_id:
+                continue
+            entry = ensure_line(matched_idea_id)
+            entry["analysis_campaign_count"] = int(entry.get("analysis_campaign_count") or 0) + 1
+            entry["analysis_slice_count"] = int(entry.get("analysis_slice_count") or 0) + int(campaign.get("slice_count") or 0)
+            entry["completed_analysis_slice_count"] = int(entry.get("completed_analysis_slice_count") or 0) + int(
+                campaign.get("completed_slice_count") or 0
+            )
+            entry["mapped_analysis_slice_count"] = int(entry.get("mapped_analysis_slice_count") or 0) + int(
+                campaign.get("mapped_slice_count") or 0
+            )
+            if not entry.get("paper_line_id") and str(campaign.get("paper_line_id") or "").strip():
+                entry["paper_line_id"] = str(campaign.get("paper_line_id") or "").strip()
+                entry["paper_branch"] = str(campaign.get("paper_line_branch") or "").strip() or entry.get("paper_branch")
+                entry["selected_outline_ref"] = str(campaign.get("selected_outline_ref") or "").strip() or entry.get("selected_outline_ref")
+            entry["updated_at"] = max(
+                updated_rank(entry.get("updated_at")),
+                updated_rank(campaign.get("updated_at")),
+            )
+
+        lines = sorted(
+            lines_by_id.values(),
             key=lambda item: (
-                str(item.get("attached_at") or ""),
-                str(item.get("source_baseline_id") or ""),
+                0 if str(item.get("idea_id") or "").strip() == active_idea_id else 1,
+                str(item.get("updated_at") or ""),
+                str(item.get("idea_line_id") or ""),
+            ),
+        )
+        for item in lines:
+            if not item.get("open_supplementary_count"):
+                pending = max(
+                    0,
+                    int(item.get("analysis_slice_count") or 0) - int(item.get("completed_analysis_slice_count") or 0),
+                )
+                item["open_supplementary_count"] = pending
+            item.pop("latest_main_run_updated_at", None)
+            item.pop("paper_line_updated_at", None)
+        if active_idea_id and active_idea_id in lines_by_id:
+            active_ref = active_idea_id
+        elif lines:
+            active_ref = str(lines[0].get("idea_line_id") or "").strip() or None
+        return lines, active_ref
+
+    def _paper_contract_health_payload(
+        self,
+        *,
+        paper_contract: dict[str, Any] | None,
+        paper_evidence: dict[str, Any] | None,
+        analysis_inventory: dict[str, Any] | None,
+        paper_lines: list[dict[str, Any]],
+        active_paper_line_ref: str | None,
+    ) -> dict[str, Any] | None:
+        if not isinstance(paper_contract, dict) or not paper_contract:
+            return None
+        evidence_items = [
+            dict(item) for item in ((paper_evidence or {}).get("items") or []) if isinstance(item, dict)
+        ]
+        ledger_by_item = {
+            str(item.get("item_id") or "").strip(): item
+            for item in evidence_items
+            if str(item.get("item_id") or "").strip()
+        }
+        unresolved_required_items: list[dict[str, Any]] = []
+        ready_section_count = 0
+        for section in paper_contract.get("sections") or []:
+            if not isinstance(section, dict):
+                continue
+            required_items = [str(item).strip() for item in (section.get("required_items") or []) if str(item).strip()]
+            section_ready = True
+            for item_id in required_items:
+                ledger_item = ledger_by_item.get(item_id)
+                status = str((ledger_item or {}).get("status") or "").strip().lower()
+                if status not in {"ready", "completed", "analyzed", "written", "recorded", "supported"}:
+                    unresolved_required_items.append(
+                        {
+                            "section_id": str(section.get("section_id") or "").strip() or None,
+                            "section_title": str(section.get("title") or "").strip() or None,
+                            "item_id": item_id,
+                            "status": str((ledger_item or {}).get("status") or "").strip() or None,
+                        }
+                    )
+                    section_ready = False
+            if required_items and section_ready:
+                ready_section_count += 1
+
+        selected_outline_ref = str(paper_contract.get("selected_outline_ref") or "").strip() or None
+        active_line = next(
+            (
+                dict(item)
+                for item in paper_lines
+                if isinstance(item, dict)
+                and str(item.get("paper_line_id") or "").strip()
+                and str(item.get("paper_line_id") or "").strip() == str(active_paper_line_ref or "").strip()
             ),
+            dict(paper_lines[0]) if paper_lines else {},
+        )
+        active_line_id = str(active_line.get("paper_line_id") or "").strip() or None
+        active_line_branch = str(active_line.get("paper_branch") or "").strip() or None
+
+        campaigns = [dict(item) for item in ((analysis_inventory or {}).get("campaigns") or []) if isinstance(item, dict)]
+        relevant_campaigns: list[dict[str, Any]] = []
+        for campaign in campaigns:
+            campaign_outline = str(campaign.get("selected_outline_ref") or "").strip() or None
+            campaign_line_id = str(campaign.get("paper_line_id") or "").strip() or None
+            campaign_line_branch = str(campaign.get("paper_line_branch") or "").strip() or None
+            if active_line_id and campaign_line_id == active_line_id:
+                relevant_campaigns.append(campaign)
+                continue
+            if active_line_branch and campaign_line_branch == active_line_branch:
+                relevant_campaigns.append(campaign)
+                continue
+            if selected_outline_ref and campaign_outline == selected_outline_ref:
+                relevant_campaigns.append(campaign)
+
+        unmapped_completed_items: list[dict[str, Any]] = []
+        blocking_pending_slices: list[dict[str, Any]] = []
+        for campaign in relevant_campaigns:
+            for slice_item in campaign.get("slices") or []:
+                if not isinstance(slice_item, dict):
+                    continue
+                status = str(slice_item.get("status") or "").strip().lower()
+                if status == "completed" and not bool(slice_item.get("mapped")):
+                    unmapped_completed_items.append(
+                        {
+                            "campaign_id": str(campaign.get("campaign_id") or "").strip() or None,
+                            "slice_id": str(slice_item.get("slice_id") or "").strip() or None,
+                            "item_id": str(slice_item.get("item_id") or "").strip() or None,
+                            "section_id": str(slice_item.get("section_id") or "").strip() or None,
+                            "title": str(slice_item.get("title") or "").strip() or None,
+                        }
+                    )
+                if status in {"", "pending"}:
+                    paper_role = str(slice_item.get("paper_role") or "").strip().lower()
+                    tier = str(slice_item.get("tier") or "").strip().lower()
+                    if paper_role == "main_text" or tier == "main_required":
+                        blocking_pending_slices.append(
+                            {
+                                "campaign_id": str(campaign.get("campaign_id") or "").strip() or None,
+                                "slice_id": str(slice_item.get("slice_id") or "").strip() or None,
+                                "item_id": str(slice_item.get("item_id") or "").strip() or None,
+                                "section_id": str(slice_item.get("section_id") or "").strip() or None,
+                                "title": str(slice_item.get("title") or "").strip() or None,
+                            }
+                        )
+
+        contract_ok = not unresolved_required_items and not unmapped_completed_items
+        writing_ready = contract_ok and not blocking_pending_slices
+        draft_path = str((paper_contract.get("paths") or {}).get("draft") or "").strip()
+        draft_status = str(active_line.get("draft_status") or "").strip() or ("present" if draft_path else "missing")
+        bundle_status = str(active_line.get("bundle_status") or "").strip() or (
+            "present" if str((paper_contract.get("paths") or {}).get("bundle_manifest") or "").strip() else "missing"
         )
+        bundle_manifest = (
+            dict(paper_contract.get("bundle_manifest") or {})
+            if isinstance(paper_contract.get("bundle_manifest"), dict)
+            else {}
+        )
+        submission_checklist_path = str(((paper_contract.get("paths") or {}).get("submission_checklist") or "")).strip()
+        submission_checklist = read_json(Path(submission_checklist_path), {}) if submission_checklist_path else {}
+        submission_checklist = submission_checklist if isinstance(submission_checklist, dict) else {}
+        overall_status = str(submission_checklist.get("overall_status") or bundle_manifest.get("status") or "").strip().lower()
+        delivered_at = str(
+            bundle_manifest.get("paper_delivered_to_user_at")
+            or bundle_manifest.get("delivered_at")
+            or submission_checklist.get("paper_delivered_to_user_at")
+            or ""
+        ).strip() or None
+        closure_state = "bundle_not_ready"
+        delivery_state = "not_ready"
+        keep_bundle_fixed_by_default = False
+        if bundle_status == "present":
+            closure_state = "delivery_ready"
+            delivery_state = "bundle_ready"
+        if delivered_at or "delivered" in overall_status:
+            delivery_state = "delivered"
+            closure_state = "delivered_continue_research" if "continue" in overall_status else "delivered_parked"
+            keep_bundle_fixed_by_default = True
+
+        if unmapped_completed_items:
+            recommended_next_stage = "write"
+            recommended_action = "sync_paper_contract"
+        elif unresolved_required_items or blocking_pending_slices:
+            recommended_next_stage = "analysis-campaign"
+            recommended_action = "complete_required_supplementary"
+        elif draft_status != "present":
+            recommended_next_stage = "write"
+            recommended_action = "draft_paper"
+        elif bundle_status != "present":
+            recommended_next_stage = "write"
+            recommended_action = "prepare_bundle"
+        else:
+            recommended_next_stage = "finalize"
+            recommended_action = "finalize_paper_line"
+
+        blocking_reasons: list[str] = []
+        if unmapped_completed_items:
+            blocking_reasons.append("completed analysis remains unmapped into the paper contract")
+        if unresolved_required_items:
+            blocking_reasons.append("required outline items are still unresolved")
+        if blocking_pending_slices:
+            blocking_reasons.append("main-text supplementary slices are still pending")
+
+        return {
+            "paper_line_id": active_line_id,
+            "paper_branch": active_line_branch,
+            "selected_outline_ref": selected_outline_ref,
+            "contract_ok": contract_ok,
+            "writing_ready": writing_ready,
+            "finalize_ready": writing_ready and bundle_status == "present",
+            "closure_state": closure_state,
+            "delivery_state": delivery_state,
+            "delivered_at": delivered_at,
+            "keep_bundle_fixed_by_default": keep_bundle_fixed_by_default,
+            "required_count": sum(
+                len(section.get("required_items") or [])
+                for section in (paper_contract.get("sections") or [])
+                if isinstance(section, dict)
+            ),
+            "ready_required_count": max(
+                0,
+                sum(
+                    len(section.get("required_items") or [])
+                    for section in (paper_contract.get("sections") or [])
+                    if isinstance(section, dict)
+                )
+                - len(unresolved_required_items),
+            ),
+            "section_count": len([section for section in (paper_contract.get("sections") or []) if isinstance(section, dict)]),
+            "ready_section_count": ready_section_count,
+            "ledger_item_count": len(evidence_items),
+            "unresolved_required_count": len(unresolved_required_items),
+            "unmapped_completed_count": len(unmapped_completed_items),
+            "open_supplementary_count": int(active_line.get("open_supplementary_count") or 0),
+            "blocking_open_supplementary_count": len(blocking_pending_slices),
+            "draft_status": draft_status,
+            "bundle_status": bundle_status,
+            "blocking_reasons": blocking_reasons,
+            "recommended_next_stage": recommended_next_stage,
+            "recommended_action": recommended_action,
+            "unresolved_required_items": unresolved_required_items[:12],
+            "unmapped_completed_items": unmapped_completed_items[:12],
+            "blocking_pending_slices": blocking_pending_slices[:12],
+        }
 
     @staticmethod
     def _latest_metric_from_payload(payload: dict[str, Any]) -> dict[str, Any] | None:
@@ -551,14 +2633,8 @@ class QuestService:
     def _quest_id_state_lock(self):
         lock_path = self._quest_id_lock_path()
         ensure_dir(lock_path.parent)
-        with lock_path.open("a+", encoding="utf-8") as handle:
-            if fcntl is not None:
-                fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
-            try:
-                yield
-            finally:
-                if fcntl is not None:
-                    fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+        with advisory_file_lock(lock_path):
+            yield
 
     @contextmanager
     def _runtime_state_lock(self, quest_root: Path):
@@ -568,14 +2644,8 @@ class QuestService:
         with thread_lock:
             lock_path = self._runtime_state_lock_path(quest_root)
             ensure_dir(lock_path.parent)
-            with lock_path.open("a+", encoding="utf-8") as handle:
-                if fcntl is not None:
-                    fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
-                try:
-                    yield
-                finally:
-                    if fcntl is not None:
-                        fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+            with advisory_file_lock(lock_path):
+                yield
 
     def _scan_next_numeric_quest_id(self) -> int:
         max_numeric_id = 0
@@ -695,7 +2765,7 @@ class QuestService:
         )
         write_text(quest_root / "brief.md", initial_brief(goal))
         write_text(quest_root / "plan.md", initial_plan())
-        write_text(quest_root / "status.md", initial_status())
+        write_text(quest_root / "status.md", initial_status(startup_contract))
         write_text(quest_root / "SUMMARY.md", initial_summary())
         write_text(quest_root / ".gitignore", gitignore())
         self._write_active_user_requirements(
@@ -878,9 +2948,27 @@ class QuestService:
             "requested_baseline_ref": quest_yaml.get("requested_baseline_ref"),
             "startup_contract": quest_yaml.get("startup_contract"),
             "runner": quest_yaml.get("default_runner", "codex"),
+            "active_workspace_root": str(workspace_root),
+            "research_head_branch": research_state.get("research_head_branch"),
+            "research_head_worktree_root": research_state.get("research_head_worktree_root"),
+            "current_workspace_branch": research_state.get("current_workspace_branch"),
+            "current_workspace_root": research_state.get("current_workspace_root"),
+            "workspace_mode": research_state.get("workspace_mode") or "quest",
+            "active_idea_id": research_state.get("active_idea_id"),
             "active_baseline_id": active_baseline_id,
             "active_baseline_variant_id": active_baseline_variant_id,
             "active_run_id": runtime_state.get("active_run_id"),
+            "continuation_policy": runtime_state.get("continuation_policy") or "auto",
+            "continuation_anchor": runtime_state.get("continuation_anchor"),
+            "continuation_reason": runtime_state.get("continuation_reason"),
+            "continuation_updated_at": runtime_state.get("continuation_updated_at"),
+            "last_resume_source": runtime_state.get("last_resume_source"),
+            "last_resume_at": runtime_state.get("last_resume_at"),
+            "last_recovery_abandoned_run_id": runtime_state.get("last_recovery_abandoned_run_id"),
+            "last_recovery_summary": runtime_state.get("last_recovery_summary"),
+            "last_stage_fingerprint": runtime_state.get("last_stage_fingerprint"),
+            "last_stage_fingerprint_at": runtime_state.get("last_stage_fingerprint_at"),
+            "same_fingerprint_auto_turn_count": int(runtime_state.get("same_fingerprint_auto_turn_count") or 0),
             "pending_decisions": pending_decisions,
             "waiting_interaction_id": waiting_interaction_id,
             "default_reply_interaction_id": default_reply_interaction_id,
@@ -952,8 +3040,8 @@ class QuestService:
             }
         return items
 
-    @staticmethod
     def _read_jsonl_cursor_slice(
+        self,
         path: Path,
         *,
         after: int = 0,
@@ -962,7 +3050,10 @@ class QuestService:
         tail: bool = False,
     ) -> tuple[list[tuple[int, dict[str, Any]]], int, bool]:
         normalized_limit = max(int(limit or 0), 0)
+        cache_key = self._cache_key_for_path(path)
         if not path.exists():
+            with self._jsonl_cache_lock:
+                self._jsonl_tail_cache.pop(cache_key, None)
             return [], 0, False
         if normalized_limit <= 0:
             total = sum(1 for _ in _iter_jsonl_records_safely(path))
@@ -981,11 +3072,71 @@ class QuestService:
             return list(window), total, has_more
 
         if tail:
-            window = deque(maxlen=normalized_limit)
-            total = 0
-            for payload in _iter_jsonl_records_safely(path):
-                total += 1
-                window.append((total, payload))
+            state = self._path_state(path)
+            cached_tail: dict[str, Any] | None = None
+            with self._jsonl_cache_lock:
+                candidate = self._jsonl_tail_cache.get(cache_key)
+                if isinstance(candidate, dict):
+                    cached_tail = dict(candidate)
+
+            if cached_tail and cached_tail.get("state") == state:
+                cached_limit = int(cached_tail.get("limit") or 0)
+                cached_records = list(cached_tail.get("records") or [])
+                cached_total = int(cached_tail.get("total") or 0)
+                if cached_limit >= normalized_limit and cached_records:
+                    window = cached_records[-normalized_limit:]
+                    has_more = cached_total > len(window)
+                    return window, cached_total, has_more
+
+            if (
+                cached_tail
+                and state is not None
+                and cached_tail.get("state")
+                and tuple(cached_tail.get("state"))[0] == state[0]
+                and state[2] >= tuple(cached_tail.get("state"))[2]
+            ):
+                cached_state = tuple(cached_tail.get("state"))
+                cached_limit = int(cached_tail.get("limit") or 0)
+                cached_total = int(cached_tail.get("total") or 0)
+                max_limit = max(normalized_limit, cached_limit)
+                window = deque(
+                    list(cached_tail.get("records") or []),
+                    maxlen=max_limit,
+                )
+                appended_records = list(
+                    _iter_jsonl_records_from_offset_safely(
+                        path,
+                        start_offset=int(cached_state[2]),
+                    )
+                )
+                if appended_records:
+                    next_cursor = cached_total + 1
+                    for payload in appended_records:
+                        window.append((next_cursor, payload))
+                        next_cursor += 1
+                    total = cached_total + len(appended_records)
+                else:
+                    total = cached_total
+                stored_records = list(window)
+                with self._jsonl_cache_lock:
+                    self._jsonl_tail_cache[cache_key] = {
+                        "state": state,
+                        "limit": max_limit,
+                        "total": total,
+                        "records": stored_records,
+                    }
+                selected = stored_records[-normalized_limit:]
+                has_more = total > len(selected)
+                return selected, total, has_more
+
+            window, total = _tail_jsonl_records_safely(path, limit=normalized_limit)
+            with self._jsonl_cache_lock:
+                self._jsonl_tail_cache[cache_key] = {
+                    "state": state,
+                    "limit": normalized_limit,
+                    "total": total,
+                    "records": list(window),
+                }
             has_more = total > len(window)
             return list(window), total, has_more
 
@@ -1021,6 +3172,14 @@ class QuestService:
         except FileNotFoundError:
             return str(path.absolute())
 
+    def jsonl_tail_cache_entry(self, path: Path) -> dict[str, Any] | None:
+        cache_key = self._cache_key_for_path(path)
+        with self._jsonl_cache_lock:
+            candidate = self._jsonl_tail_cache.get(cache_key)
+            if isinstance(candidate, dict):
+                return dict(candidate)
+        return None
+
     def _read_cached_path(
         self,
         path: Path,
@@ -1089,7 +3248,7 @@ class QuestService:
         return entries
 
     def snapshot_fast(self, quest_id: str) -> dict:
-        return self._snapshot(quest_id)
+        return self.summary_compact(quest_id)
 
     def snapshot(self, quest_id: str) -> dict:
         return self._snapshot(quest_id)
@@ -1206,6 +3365,22 @@ class QuestService:
         bash_service = BashExecService(self.home)
         bash_summary = bash_service.summary(quest_root)
         latest_bash_session = bash_summary.get("latest_session")
+        paper_contract = self._paper_contract_payload(quest_root, workspace_root)
+        paper_evidence = self._paper_evidence_payload(quest_root, workspace_root)
+        analysis_inventory = self._analysis_inventory_payload(quest_root, workspace_root)
+        paper_lines, active_paper_line_ref = self._paper_lines_payload(quest_root, workspace_root)
+        idea_lines, active_idea_line_ref = self._idea_lines_payload(
+            quest_root,
+            paper_lines=paper_lines,
+            analysis_inventory=analysis_inventory,
+        )
+        paper_contract_health = self._paper_contract_health_payload(
+            paper_contract=paper_contract,
+            paper_evidence=paper_evidence,
+            analysis_inventory=analysis_inventory,
+            paper_lines=paper_lines,
+            active_paper_line_ref=active_paper_line_ref,
+        )
         paths = {
             "brief": str(workspace_root / "brief.md"),
             "plan": str(workspace_root / "plan.md"),
@@ -1277,11 +3452,27 @@ class QuestService:
             "paper_parent_branch": research_state.get("paper_parent_branch"),
             "paper_parent_worktree_root": research_state.get("paper_parent_worktree_root"),
             "paper_parent_run_id": research_state.get("paper_parent_run_id"),
+            "idea_lines": idea_lines,
+            "active_idea_line_ref": active_idea_line_ref,
+            "paper_lines": paper_lines,
+            "active_paper_line_ref": active_paper_line_ref,
+            "paper_contract_health": paper_contract_health,
             "next_pending_slice_id": research_state.get("next_pending_slice_id"),
             "workspace_mode": research_state.get("workspace_mode") or "quest",
             "active_baseline_id": active_baseline_id,
             "active_baseline_variant_id": active_baseline_variant_id,
             "active_run_id": runtime_state.get("active_run_id"),
+            "continuation_policy": runtime_state.get("continuation_policy") or "auto",
+            "continuation_anchor": runtime_state.get("continuation_anchor"),
+            "continuation_reason": runtime_state.get("continuation_reason"),
+            "continuation_updated_at": runtime_state.get("continuation_updated_at"),
+            "last_resume_source": runtime_state.get("last_resume_source"),
+            "last_resume_at": runtime_state.get("last_resume_at"),
+            "last_recovery_abandoned_run_id": runtime_state.get("last_recovery_abandoned_run_id"),
+            "last_recovery_summary": runtime_state.get("last_recovery_summary"),
+            "last_stage_fingerprint": runtime_state.get("last_stage_fingerprint"),
+            "last_stage_fingerprint_at": runtime_state.get("last_stage_fingerprint_at"),
+            "same_fingerprint_auto_turn_count": int(runtime_state.get("same_fingerprint_auto_turn_count") or 0),
             "pending_decisions": pending_decisions,
             "active_interactions": active_interactions,
             "recent_reply_threads": recent_reply_threads,
@@ -1320,6 +3511,9 @@ class QuestService:
             "artifact_count": len(artifacts),
             "recent_artifacts": artifacts[-5:],
             "recent_runs": recent_runs[-5:],
+            "paper_contract": paper_contract,
+            "paper_evidence": paper_evidence,
+            "analysis_inventory": analysis_inventory,
             "guidance": guidance,
         }
         with self._snapshot_cache_lock:
@@ -1651,10 +3845,11 @@ class QuestService:
             normalized_anchor = str(active_anchor).strip()
             if not normalized_anchor:
                 raise ValueError("`active_anchor` cannot be empty.")
-            from ..prompts.builder import STANDARD_SKILLS
+            from ..prompts.builder import current_standard_skills
 
-            if normalized_anchor not in STANDARD_SKILLS:
-                allowed = ", ".join(STANDARD_SKILLS)
+            available_stage_skills = current_standard_skills(repo_root())
+            if normalized_anchor not in available_stage_skills:
+                allowed = ", ".join(available_stage_skills)
                 raise ValueError(f"Unsupported active anchor `{normalized_anchor}`. Allowed values: {allowed}.")
             if quest_data.get("active_anchor") != normalized_anchor:
                 quest_data["active_anchor"] = normalized_anchor
@@ -1711,10 +3906,11 @@ class QuestService:
             normalized_anchor = str(active_anchor or "").strip()
             if not normalized_anchor:
                 raise ValueError("`active_anchor` cannot be empty.")
-            from ..prompts.builder import STANDARD_SKILLS
+            from ..prompts.builder import current_standard_skills
 
-            if normalized_anchor not in STANDARD_SKILLS:
-                allowed = ", ".join(STANDARD_SKILLS)
+            available_stage_skills = current_standard_skills(repo_root())
+            if normalized_anchor not in available_stage_skills:
+                allowed = ", ".join(available_stage_skills)
                 raise ValueError(f"Unsupported active anchor `{normalized_anchor}`. Allowed values: {allowed}.")
             if quest_data.get("active_anchor") != normalized_anchor:
                 quest_data["active_anchor"] = normalized_anchor
@@ -1860,97 +4056,7 @@ class QuestService:
         return self._read_cached_jsonl(self._quest_root(quest_id) / ".ds" / "conversations" / "main.jsonl")[-limit:]
 
     def workflow(self, quest_id: str) -> dict:
-        quest_root = self._quest_root(quest_id)
-        workspace_root = self.active_workspace_root(quest_root)
-        snapshot = self.snapshot(quest_id)
-        entries: list[dict] = []
-        changed_files: list[dict] = []
-        seen_files: set[str] = set()
-
-        def add_file(path: str | None, *, source: str, document_id: str | None = None, writable: bool | None = None) -> None:
-            if not path:
-                return
-            normalized = str(path)
-            if normalized in seen_files:
-                return
-            seen_files.add(normalized)
-            resolved_document_id = document_id or self._path_to_document_id(
-                normalized,
-                quest_root=quest_root,
-                workspace_root=workspace_root,
-            )
-            changed_files.append(
-                {
-                    "path": normalized,
-                    "source": source,
-                    "document_id": resolved_document_id,
-                    "writable": writable,
-                }
-            )
-
-        for relative in ("brief.md", "plan.md", "status.md", "SUMMARY.md"):
-            add_file(
-                str(workspace_root / relative),
-                source="document",
-                document_id=relative,
-                writable=True,
-            )
-
-        recent_runs = snapshot.get("recent_runs") or []
-        for run in recent_runs:
-            run_id = str(run.get("run_id") or "run")
-            entries.append(
-                {
-                    "id": f"run:{run_id}",
-                    "kind": "run",
-                    "run_id": run_id,
-                    "skill_id": run.get("skill_id"),
-                    "title": run_id,
-                    "summary": run.get("summary") or "Run completed.",
-                    "status": "completed" if run.get("exit_code", 0) == 0 else "failed",
-                    "created_at": run.get("completed_at") or run.get("created_at") or run.get("updated_at"),
-                    "paths": [item for item in [run.get("history_root"), run.get("run_root"), run.get("output_path")] if item],
-                }
-            )
-            for path in (run.get("history_root"), run.get("run_root"), run.get("output_path")):
-                add_file(path, source="run")
-            history_root = run.get("history_root")
-            if history_root:
-                entries.extend(
-                    self._parse_codex_history_cached(
-                        Path(str(history_root)),
-                        quest_id=quest_id,
-                        run_id=run_id,
-                        skill_id=run.get("skill_id"),
-                    )
-                )
-
-        for artifact in snapshot.get("recent_artifacts") or []:
-            payload = artifact.get("payload") or {}
-            artifact_path = artifact.get("path")
-            entries.append(
-                {
-                    "id": f"artifact:{payload.get('artifact_id') or artifact_path}",
-                    "kind": "artifact",
-                    "title": str(payload.get("artifact_id") or artifact.get("kind") or "artifact"),
-                    "summary": payload.get("summary") or payload.get("message") or payload.get("reason") or "Artifact updated.",
-                    "status": payload.get("status"),
-                    "reason": payload.get("reason"),
-                    "created_at": payload.get("updated_at"),
-                    "paths": list((payload.get("paths") or {}).values()) + ([str(artifact_path)] if artifact_path else []),
-                }
-            )
-            add_file(str(artifact_path) if artifact_path else None, source="artifact")
-            for path in (payload.get("paths") or {}).values():
-                add_file(str(path), source="artifact_path")
-
-        entries.sort(key=lambda item: str(item.get("created_at") or item.get("id") or ""))
-        return {
-            "quest_id": quest_id,
-            "quest_root": snapshot.get("quest_root"),
-            "entries": entries[-80:],
-            "changed_files": changed_files[-30:],
-        }
+        return self._projected_payload(quest_id, "details")
 
     def events(
         self,
@@ -2077,23 +4183,129 @@ class QuestService:
     def metrics_timeline(self, quest_id: str) -> dict:
         quest_root = self._quest_root(quest_id)
         workspace_root = self.active_workspace_root(quest_root)
-        attachment = self._active_baseline_attachment(quest_root, workspace_root)
-        baseline_entry = dict(attachment.get("entry") or {}) if isinstance(attachment, dict) else None
-        selected_variant_id = (
-            str(attachment.get("source_variant_id") or "").strip() or None if isinstance(attachment, dict) else None
-        )
-        run_records = [
-            item.get("payload") or {}
-            for item in self._collect_artifacts(quest_root)
-            if str((item.get("payload") or {}).get("kind") or "") == "run"
-            and str((item.get("payload") or {}).get("run_kind") or "") == "main_experiment"
-        ]
-        return build_metrics_timeline(
-            quest_id=quest_id,
-            run_records=[item for item in run_records if isinstance(item, dict)],
-            baseline_entry=baseline_entry,
-            selected_variant_id=selected_variant_id,
-        )
+        state = self._json_compatible_state(self._metrics_timeline_state(quest_root, workspace_root))
+        cache_path = self._metrics_timeline_cache_path(quest_root)
+        cache_schema_version = 2
+        cached = self._read_cached_json(cache_path, {})
+        if (
+            isinstance(cached, dict)
+            and int(cached.get("schema_version") or 0) == cache_schema_version
+            and self._json_compatible_state(cached.get("state")) == state
+            and isinstance(cached.get("payload"), dict)
+        ):
+            return dict(cached.get("payload") or {})
+
+        with advisory_file_lock(self._metrics_timeline_cache_lock_path(quest_root)):
+            cached = read_json(cache_path, {})
+            if (
+                isinstance(cached, dict)
+                and int(cached.get("schema_version") or 0) == cache_schema_version
+                and self._json_compatible_state(cached.get("state")) == state
+                and isinstance(cached.get("payload"), dict)
+            ):
+                return dict(cached.get("payload") or {})
+
+            attachment = self._active_baseline_attachment(quest_root, workspace_root)
+            baseline_entry = dict(attachment.get("entry") or {}) if isinstance(attachment, dict) else None
+            selected_variant_id = (
+                str(attachment.get("source_variant_id") or "").strip() or None if isinstance(attachment, dict) else None
+            )
+            if not baseline_entry:
+                latest_baseline_payload = None
+                for item in reversed(self._collect_artifacts_raw(quest_root)):
+                    if str(item.get("kind") or "").strip() != "baselines":
+                        continue
+                    payload = item.get("payload") or {}
+                    if not isinstance(payload, dict):
+                        continue
+                    if str(payload.get("status") or "").strip().lower() != "confirmed":
+                        continue
+                    latest_baseline_payload = payload
+                    break
+                if isinstance(latest_baseline_payload, dict) and latest_baseline_payload:
+                    baseline_entry = dict(latest_baseline_payload)
+                    selected_variant_id = (
+                        str(latest_baseline_payload.get("baseline_variant_id") or "").strip() or None
+                    )
+            run_records = [
+                item.get("payload") or {}
+                for item in self._collect_run_artifacts_raw(quest_root, run_kind="main_experiment")
+                if isinstance(item.get("payload"), dict)
+            ]
+            payload = build_metrics_timeline(
+                quest_id=quest_id,
+                run_records=run_records,
+                baseline_entry=baseline_entry,
+                selected_variant_id=selected_variant_id,
+            )
+            write_json(
+                cache_path,
+                {
+                    "schema_version": cache_schema_version,
+                    "generated_at": utc_now(),
+                    "state": state,
+                    "payload": payload,
+                },
+            )
+            return payload
+
+    def baseline_compare(self, quest_id: str) -> dict:
+        quest_root = self._quest_root(quest_id)
+        workspace_root = self.active_workspace_root(quest_root)
+        state = self._json_compatible_state(self._baseline_compare_state(quest_root, workspace_root))
+        cache_path = self._baseline_compare_cache_path(quest_root)
+        cache_schema_version = 1
+        cached = self._read_cached_json(cache_path, {})
+        if (
+            isinstance(cached, dict)
+            and int(cached.get("schema_version") or 0) == cache_schema_version
+            and self._json_compatible_state(cached.get("state")) == state
+            and isinstance(cached.get("payload"), dict)
+        ):
+            return dict(cached.get("payload") or {})
+
+        with advisory_file_lock(self._baseline_compare_cache_lock_path(quest_root)):
+            cached = read_json(cache_path, {})
+            if (
+                isinstance(cached, dict)
+                and int(cached.get("schema_version") or 0) == cache_schema_version
+                and self._json_compatible_state(cached.get("state")) == state
+                and isinstance(cached.get("payload"), dict)
+            ):
+                return dict(cached.get("payload") or {})
+
+            quest_data = self.read_quest_yaml(quest_root)
+            confirmed_ref = (
+                dict(quest_data.get("confirmed_baseline_ref") or {})
+                if isinstance(quest_data.get("confirmed_baseline_ref"), dict)
+                else {}
+            )
+            attachment = self._active_baseline_attachment(quest_root, workspace_root)
+            active_baseline_id = (
+                str(confirmed_ref.get("baseline_id") or "").strip()
+                or (str(attachment.get("source_baseline_id") or "").strip() if isinstance(attachment, dict) else "")
+                or None
+            )
+            active_variant_id = (
+                str(confirmed_ref.get("variant_id") or "").strip()
+                or (str(attachment.get("source_variant_id") or "").strip() if isinstance(attachment, dict) else "")
+                or None
+            )
+            payload = build_baseline_compare_payload(
+                quest_id=quest_id,
+                baseline_entries=self._baseline_compare_entries(quest_root, workspace_root),
+                active_baseline_id=active_baseline_id,
+                active_variant_id=active_variant_id,
+            )
+            write_json(
+                cache_path,
+                {
+                    "schema_version": cache_schema_version,
+                    "state": state,
+                    "payload": payload,
+                },
+            )
+            return payload
 
     def list_documents(self, quest_id: str) -> list[dict]:
         quest_root = self._quest_root(quest_id)
@@ -2310,23 +4522,7 @@ class QuestService:
                 },
             }
 
-        resolution_root = (
-            quest_root
-            if document_id.startswith(("questpath::", "memory::"))
-            else workspace_root
-        )
-        try:
-            path, writable, scope, source_kind = self._resolve_document(resolution_root, document_id)
-        except FileNotFoundError:
-            legacy_relative = None
-            if document_id.startswith("path::"):
-                legacy_relative = document_id.split("::", 1)[1].lstrip("/")
-            if legacy_relative and legacy_relative.startswith("literature/arxiv/"):
-                path, writable, scope, source_kind = self._resolve_document(
-                    quest_root, f"questpath::{legacy_relative}"
-                )
-            else:
-                raise
+        path, writable, scope, source_kind = self.resolve_document(quest_id, document_id)
         renderer_hint, mime_type = self._renderer_hint_for(path)
         is_text = self._is_text_document(path, mime_type, renderer_hint)
         content = read_text(path) if is_text else ""
@@ -2354,6 +4550,24 @@ class QuestService:
             },
         }
 
+    def resolve_document(self, quest_id: str, document_id: str) -> tuple[Path, bool, str, str]:
+        quest_root = self._quest_root(quest_id)
+        workspace_root = self.active_workspace_root(quest_root)
+        resolution_root = self._document_resolution_root(
+            quest_root=quest_root,
+            workspace_root=workspace_root,
+            document_id=document_id,
+        )
+        try:
+            return self._resolve_document(resolution_root, document_id)
+        except FileNotFoundError:
+            legacy_relative = None
+            if document_id.startswith("path::"):
+                legacy_relative = document_id.split("::", 1)[1].lstrip("/")
+            if legacy_relative and legacy_relative.startswith("literature/arxiv/"):
+                return self._resolve_document(quest_root, f"questpath::{legacy_relative}")
+            raise
+
     def save_document(self, quest_id: str, document_id: str, content: str, previous_revision: str | None = None) -> dict:
         current = self.open_document(quest_id, document_id)
         if not current.get("writable", False):
@@ -2689,6 +4903,17 @@ class QuestService:
             "last_tool_activity_at": None,
             "last_tool_activity_name": None,
             "tool_calls_since_last_artifact_interact": 0,
+            "continuation_policy": "auto",
+            "continuation_anchor": None,
+            "continuation_reason": None,
+            "continuation_updated_at": None,
+            "last_resume_source": None,
+            "last_resume_at": None,
+            "last_recovery_abandoned_run_id": None,
+            "last_recovery_summary": None,
+            "last_stage_fingerprint": None,
+            "last_stage_fingerprint_at": None,
+            "same_fingerprint_auto_turn_count": 0,
             "pending_user_message_count": pending_count,
             "last_delivered_batch_id": None,
             "last_delivered_at": None,
@@ -2754,6 +4979,20 @@ class QuestService:
         merged = {**defaults, **payload}
         merged["pending_user_message_count"] = int(merged.get("pending_user_message_count") or 0)
         merged["tool_calls_since_last_artifact_interact"] = int(merged.get("tool_calls_since_last_artifact_interact") or 0)
+        merged["continuation_policy"] = self._normalize_continuation_policy(
+            merged.get("continuation_policy"),
+            default=str(defaults.get("continuation_policy") or "auto"),
+        )
+        merged["continuation_anchor"] = str(merged.get("continuation_anchor") or "").strip() or None
+        merged["continuation_reason"] = str(merged.get("continuation_reason") or "").strip() or None
+        merged["continuation_updated_at"] = str(merged.get("continuation_updated_at") or "").strip() or None
+        merged["last_resume_source"] = str(merged.get("last_resume_source") or "").strip() or None
+        merged["last_resume_at"] = str(merged.get("last_resume_at") or "").strip() or None
+        merged["last_recovery_abandoned_run_id"] = str(merged.get("last_recovery_abandoned_run_id") or "").strip() or None
+        merged["last_recovery_summary"] = str(merged.get("last_recovery_summary") or "").strip() or None
+        merged["last_stage_fingerprint"] = str(merged.get("last_stage_fingerprint") or "").strip() or None
+        merged["last_stage_fingerprint_at"] = str(merged.get("last_stage_fingerprint_at") or "").strip() or None
+        merged["same_fingerprint_auto_turn_count"] = int(merged.get("same_fingerprint_auto_turn_count") or 0)
         merged["retry_state"] = dict(merged.get("retry_state") or {}) if isinstance(merged.get("retry_state"), dict) else None
         return merged
 
@@ -2773,6 +5012,17 @@ class QuestService:
         last_tool_activity_at: str | None | object = _UNSET,
         last_tool_activity_name: str | None | object = _UNSET,
         tool_calls_since_last_artifact_interact: int | object = _UNSET,
+        continuation_policy: str | object = _UNSET,
+        continuation_anchor: str | None | object = _UNSET,
+        continuation_reason: str | None | object = _UNSET,
+        continuation_updated_at: str | None | object = _UNSET,
+        last_resume_source: str | None | object = _UNSET,
+        last_resume_at: str | None | object = _UNSET,
+        last_recovery_abandoned_run_id: str | None | object = _UNSET,
+        last_recovery_summary: str | None | object = _UNSET,
+        last_stage_fingerprint: str | None | object = _UNSET,
+        last_stage_fingerprint_at: str | None | object = _UNSET,
+        same_fingerprint_auto_turn_count: int | object = _UNSET,
         pending_user_message_count: int | object = _UNSET,
         last_delivered_batch_id: str | None | object = _UNSET,
         last_delivered_at: str | None | object = _UNSET,
@@ -2810,6 +5060,44 @@ class QuestService:
                 state["last_tool_activity_name"] = str(last_tool_activity_name).strip() if last_tool_activity_name else None
             if tool_calls_since_last_artifact_interact is not _UNSET:
                 state["tool_calls_since_last_artifact_interact"] = max(0, int(tool_calls_since_last_artifact_interact))
+            continuation_changed = False
+            if continuation_policy is not _UNSET:
+                state["continuation_policy"] = self._normalize_continuation_policy(continuation_policy)
+                continuation_changed = True
+            if continuation_anchor is not _UNSET:
+                normalized_anchor = str(continuation_anchor or "").strip() or None
+                if normalized_anchor is not None:
+                    from ..prompts.builder import current_standard_skills
+
+                    available_stage_skills = current_standard_skills(repo_root())
+                    if normalized_anchor not in available_stage_skills:
+                        allowed = ", ".join(available_stage_skills)
+                        raise ValueError(
+                            f"Unsupported continuation anchor `{normalized_anchor}`. Allowed values: {allowed}."
+                        )
+                state["continuation_anchor"] = normalized_anchor
+                continuation_changed = True
+            if continuation_reason is not _UNSET:
+                state["continuation_reason"] = str(continuation_reason or "").strip() or None
+                continuation_changed = True
+            if continuation_updated_at is not _UNSET:
+                state["continuation_updated_at"] = str(continuation_updated_at or "").strip() or None
+            elif continuation_changed:
+                state["continuation_updated_at"] = now
+            if last_resume_source is not _UNSET:
+                state["last_resume_source"] = str(last_resume_source or "").strip() or None
+            if last_resume_at is not _UNSET:
+                state["last_resume_at"] = str(last_resume_at or "").strip() or None
+            if last_recovery_abandoned_run_id is not _UNSET:
+                state["last_recovery_abandoned_run_id"] = str(last_recovery_abandoned_run_id or "").strip() or None
+            if last_recovery_summary is not _UNSET:
+                state["last_recovery_summary"] = str(last_recovery_summary or "").strip() or None
+            if last_stage_fingerprint is not _UNSET:
+                state["last_stage_fingerprint"] = str(last_stage_fingerprint or "").strip() or None
+            if last_stage_fingerprint_at is not _UNSET:
+                state["last_stage_fingerprint_at"] = str(last_stage_fingerprint_at or "").strip() or None
+            if same_fingerprint_auto_turn_count is not _UNSET:
+                state["same_fingerprint_auto_turn_count"] = max(0, int(same_fingerprint_auto_turn_count or 0))
             if pending_user_message_count is not _UNSET:
                 state["pending_user_message_count"] = max(0, int(pending_user_message_count))
             if last_delivered_batch_id is not _UNSET:
@@ -2836,8 +5124,29 @@ class QuestService:
                         quest_data.pop("active_run_id", None)
                 quest_data["updated_at"] = now
                 write_yaml(quest_root / "quest.yaml", quest_data)
+            self.schedule_projection_refresh(quest_root, kinds=("details",))
             return state
 
+    @staticmethod
+    def _normalize_continuation_policy(value: object, *, default: str = "auto") -> str:
+        normalized = str(value or "").strip().lower() or default
+        return normalized if normalized in CONTINUATION_POLICIES else default
+
+    def set_continuation_state(
+        self,
+        quest_root: Path,
+        *,
+        policy: str,
+        anchor: str | None = None,
+        reason: str | None = None,
+    ) -> dict[str, Any]:
+        return self.update_runtime_state(
+            quest_root=quest_root,
+            continuation_policy=policy,
+            continuation_anchor=anchor,
+            continuation_reason=reason,
+        )
+
     def _enqueue_user_message(self, quest_root: Path, record: dict[str, Any]) -> dict[str, Any]:
         queue_payload = self._read_message_queue(quest_root)
         source = str(record.get("source") or "local")
@@ -3055,11 +5364,15 @@ class QuestService:
         artifact_id: str | None,
         kind: str,
         message: str,
+        summary_preview: str | None = None,
+        dedupe_key: str | None = None,
         response_phase: str | None = None,
         reply_mode: str | None = None,
         surface_actions: list[dict[str, Any]] | None = None,
         connector_hints: dict[str, Any] | None = None,
         created_at: str | None = None,
+        counts_as_visible: bool = True,
+        deliver_to_bound_conversations: bool | None = None,
     ) -> dict[str, Any]:
         timestamp = created_at or utc_now()
         payload = {
@@ -3070,22 +5383,31 @@ class QuestService:
             "artifact_id": artifact_id,
             "kind": kind,
             "message": message,
+            "summary_preview": str(summary_preview or "").strip() or None,
+            "dedupe_key": str(dedupe_key or "").strip() or None,
             "response_phase": response_phase,
             "reply_mode": reply_mode,
             "surface_actions": [dict(item) for item in (surface_actions or []) if isinstance(item, dict)],
             "connector_hints": dict(connector_hints) if isinstance(connector_hints, dict) else {},
+            "deliver_to_bound_conversations": (
+                bool(deliver_to_bound_conversations)
+                if deliver_to_bound_conversations is not None
+                else None
+            ),
             "created_at": timestamp,
         }
         append_jsonl(self._interaction_journal_path(quest_root), payload)
-        self.update_runtime_state(
-            quest_root=quest_root,
-            active_interaction_id=interaction_id or artifact_id,
-            last_artifact_interact_at=timestamp,
-            last_tool_activity_at=timestamp,
-            last_tool_activity_name="artifact.interact",
-            tool_calls_since_last_artifact_interact=0,
-            pending_user_message_count=len((self._read_message_queue(quest_root).get("pending") or [])),
-        )
+        runtime_updates: dict[str, Any] = {
+            "quest_root": quest_root,
+            "active_interaction_id": interaction_id or artifact_id,
+            "last_tool_activity_at": timestamp,
+            "last_tool_activity_name": "artifact.interact",
+            "tool_calls_since_last_artifact_interact": 0,
+            "pending_user_message_count": len((self._read_message_queue(quest_root).get("pending") or [])),
+        }
+        if counts_as_visible:
+            runtime_updates["last_artifact_interact_at"] = timestamp
+        self.update_runtime_state(**runtime_updates)
         return payload
 
     def record_tool_activity(
@@ -3133,13 +5455,25 @@ class QuestService:
         runtime_state = self._read_runtime_state(quest_root)
         last_artifact_interact_at = str(runtime_state.get("last_artifact_interact_at") or "").strip() or None
         last_tool_activity_at = str(runtime_state.get("last_tool_activity_at") or "").strip() or None
+        tool_count = int(runtime_state.get("tool_calls_since_last_artifact_interact") or 0)
+        silence_seconds = self._seconds_since_iso_timestamp(last_artifact_interact_at)
+        inspection_due = bool(
+            tool_count >= 25
+            or (
+                tool_count > 0
+                and silence_seconds is not None
+                and silence_seconds >= 30 * 60
+            )
+        )
         return {
             "last_artifact_interact_at": last_artifact_interact_at,
-            "seconds_since_last_artifact_interact": self._seconds_since_iso_timestamp(last_artifact_interact_at),
-            "tool_calls_since_last_artifact_interact": int(runtime_state.get("tool_calls_since_last_artifact_interact") or 0),
+            "seconds_since_last_artifact_interact": silence_seconds,
+            "tool_calls_since_last_artifact_interact": tool_count,
             "last_tool_activity_at": last_tool_activity_at,
             "seconds_since_last_tool_activity": self._seconds_since_iso_timestamp(last_tool_activity_at),
             "last_tool_activity_name": str(runtime_state.get("last_tool_activity_name") or "").strip() or None,
+            "inspection_due": inspection_due,
+            "user_update_due": False,
         }
 
     def latest_artifact_interaction_records(self, quest_root: Path, limit: int = 10) -> list[dict[str, Any]]:
@@ -3309,6 +5643,12 @@ class QuestService:
             "queued_message_count_after_delivery": len(queue_payload.get("pending") or []),
         }
 
+    @staticmethod
+    def _document_resolution_root(quest_root: Path, workspace_root: Path, document_id: str) -> Path:
+        if document_id.startswith(("questpath::", "memory::")):
+            return quest_root
+        return workspace_root
+
     @staticmethod
     def _resolve_document(quest_root: Path, document_id: str) -> tuple[Path, bool, str, str]:
         if document_id.startswith("memory::"):
@@ -3935,9 +6275,11 @@ def _tool_output(event: dict, item: dict) -> str:
             item.get("result"),
             item.get("output"),
             item.get("content"),
+            item.get("error"),
             event.get("result"),
             event.get("output"),
             event.get("content"),
+            event.get("error"),
             item.get("aggregated_output"),
             event.get("aggregated_output"),
         ):
@@ -3951,11 +6293,13 @@ def _tool_output(event: dict, item: dict) -> str:
         item.get("output"),
         item.get("result"),
         item.get("content"),
+        item.get("error"),
         event.get("aggregated_output"),
         event.get("changes"),
         event.get("output"),
         event.get("result"),
         event.get("content"),
+        event.get("error"),
     ):
         text = _compact_text(value, limit=1200)
         if text: