@researai/deepscientist 1.5.8 → 1.5.11

package/src/deepscientist/quest/service.py

@@ -19,9 +19,10 @@ except ImportError:  # pragma: no cover
 
 from ..artifact.metrics import build_metrics_timeline, extract_latest_metric
 from ..config import ConfigManager
-from ..connector_runtime import conversation_identity_key, normalize_conversation_id
+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 ..home import repo_root
+from ..registries import BaselineRegistry
 from ..shared import append_jsonl, ensure_dir, generate_id, read_json, read_jsonl, read_text, read_yaml, resolve_within, run_command, sha256_text, slugify, utc_now, write_json, write_text, write_yaml
 from ..skills import SkillInstaller
 from ..web_search import extract_web_search_payload
@@ -48,6 +49,7 @@ class QuestService:
         self.home = home
         self.quests_root = home / "quests"
         self.skill_installer = skill_installer
+        self.baseline_registry = BaselineRegistry(home)
         self._file_cache_lock = threading.Lock()
         self._file_cache: dict[str, dict[str, Any]] = {}
         self._jsonl_cache_lock = threading.Lock()
@@ -62,6 +64,35 @@ class QuestService:
     def _quest_root(self, quest_id: str) -> Path:
         return self.quests_root / quest_id
 
+    def _normalized_binding_sources(self, sources: list[Any] | None) -> list[str]:
+        local_present = False
+        external_source: str | None = None
+        for raw in sources or []:
+            normalized = self._normalize_binding_source(raw)
+            if not normalized:
+                continue
+            if normalized == "local:default":
+                local_present = True
+                continue
+            parsed = parse_conversation_id(normalized)
+            connector = str((parsed or {}).get("connector") or "").strip().lower()
+            if connector == "local":
+                local_present = True
+                continue
+            external_source = normalized
+        if external_source:
+            return ["local:default", external_source]
+        if local_present:
+            return ["local:default"]
+        return ["local:default"]
+
+    def _binding_sources_payload(self, quest_root: Path) -> dict[str, list[str]]:
+        bindings_path = quest_root / ".ds" / "bindings.json"
+        payload = read_json(bindings_path, {"sources": ["local:default"]})
+        raw_sources = payload.get("sources") if isinstance(payload, dict) else ["local:default"]
+        sources = self._normalized_binding_sources(raw_sources if isinstance(raw_sources, list) else ["local:default"])
+        return {"sources": sources}
+
     def preferred_locale(self, quest_root: Path | None = None) -> str:
         if quest_root is not None:
             try:
@@ -116,6 +147,10 @@ class QuestService:
     def _research_state_path(quest_root: Path) -> Path:
         return quest_root / ".ds" / "research_state.json"
 
+    @staticmethod
+    def _lab_canvas_state_path(quest_root: Path) -> Path:
+        return quest_root / ".ds" / "lab_canvas_state.json"
+
     def _default_research_state(self, quest_root: Path) -> dict[str, Any]:
         return {
             "version": 1,
@@ -138,6 +173,18 @@ class QuestService:
             "updated_at": utc_now(),
         }
 
+    def _default_lab_canvas_state(self, quest_root: Path) -> dict[str, Any]:
+        return {
+            "version": 1,
+            "layout_json": {
+                "branch": {},
+                "event": {},
+                "stage": {},
+                "preferences": {},
+            },
+            "updated_at": utc_now(),
+        }
+
     def read_research_state(self, quest_root: Path) -> dict[str, Any]:
         self._initialize_runtime_files(quest_root)
         defaults = self._default_research_state(quest_root)
@@ -172,6 +219,39 @@ class QuestService:
             current[key] = str(value) if isinstance(value, Path) else value
         return self.write_research_state(quest_root, current)
 
+    def read_lab_canvas_state(self, quest_root: Path) -> dict[str, Any]:
+        self._initialize_runtime_files(quest_root)
+        defaults = self._default_lab_canvas_state(quest_root)
+        payload = self._read_cached_json(self._lab_canvas_state_path(quest_root), defaults)
+        if not isinstance(payload, dict):
+            payload = defaults
+        merged = {**defaults, **payload}
+        layout_json = dict(merged.get("layout_json") or {}) if isinstance(merged.get("layout_json"), dict) else {}
+        for key in ("branch", "event", "stage", "preferences"):
+            if not isinstance(layout_json.get(key), dict):
+                layout_json[key] = {}
+        merged["layout_json"] = layout_json
+        return merged
+
+    def update_lab_canvas_state(
+        self,
+        quest_root: Path,
+        *,
+        layout_json: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        current = self.read_lab_canvas_state(quest_root)
+        normalized_layout = dict(layout_json or {}) if isinstance(layout_json, dict) else {}
+        for key in ("branch", "event", "stage", "preferences"):
+            if not isinstance(normalized_layout.get(key), dict):
+                normalized_layout[key] = {}
+        payload = {
+            **current,
+            "layout_json": normalized_layout,
+            "updated_at": utc_now(),
+        }
+        write_json(self._lab_canvas_state_path(quest_root), payload)
+        return payload
+
     def workspace_roots(self, quest_root: Path) -> list[Path]:
         roots: list[Path] = [quest_root]
         state = self.read_research_state(quest_root)
@@ -305,6 +385,9 @@ class QuestService:
                     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:
@@ -684,7 +767,7 @@ class QuestService:
             "last_artifact_interact_at": runtime_state.get("last_artifact_interact_at"),
             "last_delivered_batch_id": runtime_state.get("last_delivered_batch_id"),
             "last_delivered_at": runtime_state.get("last_delivered_at"),
-            "bound_conversations": (self._read_cached_json(quest_root / ".ds" / "bindings.json", {}).get("sources") or ["local:default"]),
+            "bound_conversations": self._binding_sources_payload(quest_root).get("sources") or ["local:default"],
             "created_at": quest_yaml.get("created_at"),
             "updated_at": quest_yaml.get("updated_at"),
             "branch": research_state.get("current_workspace_branch") or research_state.get("research_head_branch"),
@@ -1039,7 +1122,7 @@ class QuestService:
             "last_artifact_interact_at": runtime_state.get("last_artifact_interact_at"),
             "last_delivered_batch_id": runtime_state.get("last_delivered_batch_id"),
             "last_delivered_at": runtime_state.get("last_delivered_at"),
-            "bound_conversations": (self._read_cached_json(quest_root / ".ds" / "bindings.json", {}).get("sources") or ["local:default"]),
+            "bound_conversations": self._binding_sources_payload(quest_root).get("sources") or ["local:default"],
             "created_at": quest_yaml.get("created_at"),
             "updated_at": quest_yaml.get("updated_at"),
             "branch": current_branch(workspace_root),
@@ -1308,61 +1391,30 @@ class QuestService:
     def bind_source(self, quest_id: str, source: str) -> dict:
         quest_root = self._quest_root(quest_id)
         bindings_path = quest_root / ".ds" / "bindings.json"
-        bindings = read_json(bindings_path, {"sources": []})
+        bindings = self._binding_sources_payload(quest_root)
         normalized_source = self._normalize_binding_source(source)
-        normalized_key = conversation_identity_key(normalized_source)
-        changed = False
-        replaced = False
-        sources: list[str] = []
-        for item in list(bindings.get("sources") or []):
-            existing = self._normalize_binding_source(str(item))
-            if conversation_identity_key(existing) == normalized_key:
-                if not replaced:
-                    sources.append(normalized_source)
-                    replaced = True
-                    if existing != normalized_source:
-                        changed = True
-                else:
-                    changed = True
-                continue
-            sources.append(existing)
-            if existing != item:
-                changed = True
-        if not replaced:
-            sources.append(normalized_source)
-            changed = True
+        next_sources = self._normalized_binding_sources([*(bindings.get("sources") or []), normalized_source])
+        changed = list(bindings.get("sources") or []) != next_sources
         if changed:
-            bindings["sources"] = sources
+            bindings["sources"] = next_sources
             write_json(bindings_path, bindings)
         return bindings
 
     def binding_sources(self, quest_id: str) -> list[str]:
         quest_root = self._quest_root(quest_id)
-        bindings_path = quest_root / ".ds" / "bindings.json"
-        bindings = read_json(bindings_path, {"sources": ["local:default"]})
-        sources = [self._normalize_binding_source(item) for item in (bindings.get("sources") or [])]
-        return [item for item in sources if item]
+        return list(self._binding_sources_payload(quest_root).get("sources") or ["local:default"])
 
     def set_binding_sources(self, quest_id: str, sources: list[str]) -> dict:
         quest_root = self._quest_root(quest_id)
         bindings_path = quest_root / ".ds" / "bindings.json"
-        normalized_sources = [self._normalize_binding_source(item) for item in sources]
-        ordered: list[str] = []
-        seen: set[str] = set()
-        for item in normalized_sources:
-            key = conversation_identity_key(item)
-            if not item or key in seen:
-                continue
-            seen.add(key)
-            ordered.append(item)
-        payload = {"sources": ordered}
+        payload = {"sources": self._normalized_binding_sources(sources)}
         write_json(bindings_path, payload)
         return payload
 
     def unbind_source(self, quest_id: str, source: str) -> dict:
         quest_root = self._quest_root(quest_id)
         bindings_path = quest_root / ".ds" / "bindings.json"
-        bindings = read_json(bindings_path, {"sources": []})
+        bindings = self._binding_sources_payload(quest_root)
         normalized_source = self._normalize_binding_source(source)
         normalized_key = conversation_identity_key(normalized_source)
         changed = False
@@ -1375,8 +1427,11 @@ class QuestService:
             sources.append(existing)
             if existing != item:
                 changed = True
+        normalized_sources = self._normalized_binding_sources(sources)
+        if normalized_sources != list(bindings.get("sources") or []):
+            changed = True
         if changed:
-            bindings["sources"] = sources
+            bindings["sources"] = normalized_sources
             write_json(bindings_path, bindings)
         return bindings
 
@@ -1770,6 +1825,12 @@ class QuestService:
         resolved_selection = dict(selection or {})
         selection_ref = str(resolved_selection.get("selection_ref") or "").strip()
         selection_type = str(resolved_selection.get("selection_type") or "stage_node").strip() or None
+        if (
+            selection_type == "branch_node"
+            and selection_ref
+            and not str(resolved_selection.get("branch_name") or "").strip()
+        ):
+            resolved_selection["branch_name"] = selection_ref
         trace = None
         if selection_ref:
             try:
@@ -2026,7 +2087,18 @@ class QuestService:
             if document_id.startswith(("questpath::", "memory::"))
             else workspace_root
         )
-        path, writable, scope, source_kind = self._resolve_document(resolution_root, document_id)
+        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
         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 ""
@@ -2417,6 +2489,9 @@ class QuestService:
         research_state_path = self._research_state_path(quest_root)
         if not research_state_path.exists():
             write_json(research_state_path, self._default_research_state(quest_root))
+        lab_canvas_state_path = self._lab_canvas_state_path(quest_root)
+        if not lab_canvas_state_path.exists():
+            write_json(lab_canvas_state_path, self._default_lab_canvas_state(quest_root))
         agent_status_path = self._agent_status_path(quest_root)
         if not agent_status_path.exists():
             write_json(agent_status_path, self._default_agent_status(quest_root))
@@ -3492,7 +3567,35 @@ def _tool_name(event: dict, item: dict) -> str:
     return "tool"
 
 
+def _structured_text(value: object) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value.strip()
+    try:
+        return json.dumps(value, ensure_ascii=False, indent=2)
+    except TypeError:
+        return str(value)
+
+
+def _is_bash_exec_item(event: dict, item: dict) -> bool:
+    server = str(item.get("server") or event.get("server") or "").strip()
+    tool = str(item.get("tool") or event.get("tool") or "").strip()
+    return server == "bash_exec" and tool == "bash_exec"
+
+
 def _tool_args(event: dict, item: dict) -> str:
+    if _is_bash_exec_item(event, item):
+        for value in (
+            item.get("arguments"),
+            event.get("arguments"),
+            item.get("input"),
+            event.get("input"),
+        ):
+            text = _structured_text(value)
+            if text:
+                return text
+        return ""
     for value in (
         item.get("command"),
         item.get("query"),
@@ -3512,6 +3615,21 @@ def _tool_args(event: dict, item: dict) -> str:
 
 
 def _tool_output(event: dict, item: dict) -> str:
+    if _is_bash_exec_item(event, item):
+        for value in (
+            item.get("result"),
+            item.get("output"),
+            item.get("content"),
+            event.get("result"),
+            event.get("output"),
+            event.get("content"),
+            item.get("aggregated_output"),
+            event.get("aggregated_output"),
+        ):
+            text = _structured_text(value)
+            if text:
+                return text
+        return ""
     for value in (
         item.get("aggregated_output"),
         item.get("changes"),
@@ -3554,17 +3672,25 @@ def _mcp_tool_metadata(*, quest_id: str, run_id: str, server: str, tool: str, it
         for key in ("command", "workdir", "mode", "timeout_seconds", "comment"):
             if key in arguments:
                 metadata[key] = arguments.get(key)
+        if server == "bash_exec" and tool == "bash_exec" and isinstance(arguments.get("id"), str):
+            metadata["bash_id"] = arguments.get("id")
     result_payload = _mcp_result_payload(item)
     if server == "bash_exec" and tool == "bash_exec":
         for key in (
             "bash_id",
             "status",
+            "command",
+            "workdir",
+            "cwd",
+            "kind",
+            "comment",
             "started_at",
             "finished_at",
             "exit_code",
             "stop_reason",
             "last_progress",
             "log_path",
+            "watchdog_after_seconds",
         ):
             if key in result_payload:
                 metadata[key] = result_payload.get(key)

package/src/deepscientist/quest/stage_views.py

@@ -153,8 +153,69 @@ class QuestStageViewBuilder:
                 return candidate
         return self.quest_root
 
+    def _infer_stage_from_branch_name(self) -> str | None:
+        normalized = str(self.branch_name or "").strip().lower()
+        if not normalized:
+            return None
+        if normalized.startswith("analysis/"):
+            return "analysis"
+        if normalized.startswith("run/"):
+            return "experiment"
+        if normalized.startswith("idea/"):
+            return "idea"
+        if normalized.startswith("paper/") or normalized.startswith("write/"):
+            return "paper"
+        if normalized.startswith("baseline/"):
+            return "baseline"
+        return None
+
+    def _has_paper_state(self) -> bool:
+        paper_root = self._paper_root()
+        return bool(
+            self._paper_candidates()
+            or (paper_root / "selected_outline.json").exists()
+            or (paper_root / "draft.md").exists()
+            or self._paper_bundle_manifest()
+        )
+
+    def _resolve_effective_stage_key(self) -> str:
+        normalized = normalize_stage_key(self.stage_key)
+        if normalized in {"baseline", "idea", "experiment", "analysis", "paper"}:
+            return normalized
+        if normalized != "general":
+            return normalized
+
+        inferred = self._infer_stage_from_branch_name()
+        if inferred:
+            return inferred
+        if self._analysis_stage_items(None):
+            return "analysis"
+        if self._experiment_stage_items():
+            return "experiment"
+        if self._idea_stage_items():
+            return "idea"
+        if self._has_paper_state():
+            return "paper"
+        if self._baseline_stage_items():
+            return "baseline"
+        return normalized
+
+    @staticmethod
+    def _artifact_detail(item: dict[str, Any] | None, payload: dict[str, Any]) -> dict[str, Any] | None:
+        if not isinstance(payload, dict) or not payload:
+            return None
+        record = dict(item or {})
+        return {
+            "artifact_id": payload.get("artifact_id") or payload.get("id"),
+            "artifact_kind": payload.get("kind"),
+            "artifact_path": record.get("path"),
+            "payload": payload,
+        }
+
     def build(self) -> dict[str, Any]:
-        if str(self.selection.get("selection_type") or "").strip() == "branch_node":
+        selection_type = str(self.selection.get("selection_type") or "").strip()
+        self.stage_key = self._resolve_effective_stage_key()
+        if selection_type == "branch_node" and self.stage_key not in {"experiment", "analysis", "paper"}:
             return self._build_branch()
         if self.stage_key == "baseline":
             return self._build_baseline()
@@ -332,6 +393,52 @@ class QuestStageViewBuilder:
         text = str(body or "").strip()
         return text or None
 
+    def _recent_trace_actions(self, *, limit: int = 6) -> list[dict[str, Any]]:
+        raw_actions = self.trace.get("actions") if isinstance(self.trace, dict) else []
+        if not isinstance(raw_actions, list) or not raw_actions:
+            return []
+        normalized: list[dict[str, Any]] = []
+        for item in raw_actions[-limit:]:
+            if not isinstance(item, dict):
+                continue
+            summary = _compact(item.get("summary") or item.get("output") or item.get("args"), limit=1000)
+            normalized.append(
+                {
+                    "action_id": item.get("action_id"),
+                    "title": item.get("title") or item.get("tool_name") or item.get("raw_event_type") or item.get("kind"),
+                    "summary": summary,
+                    "status": item.get("status"),
+                    "created_at": item.get("created_at"),
+                    "tool_name": item.get("tool_name"),
+                    "artifact_kind": item.get("artifact_kind"),
+                }
+            )
+        return normalized
+
+    def _trace_summary(self) -> str | None:
+        if not isinstance(self.trace, dict):
+            return None
+        return _compact(
+            self.trace.get("summary")
+            or self.selection.get("summary")
+            or self.trace.get("title"),
+            limit=600,
+        )
+
+    def _trace_markdown(self, *, limit: int = 5) -> str | None:
+        items = self._recent_trace_actions(limit=limit)
+        if not items:
+            return None
+        lines: list[str] = []
+        for item in items:
+            title = str(item.get("title") or "Trace").strip() or "Trace"
+            summary = str(item.get("summary") or "").strip()
+            if summary:
+                lines.append(f"- **{title}**: {summary}")
+            else:
+                lines.append(f"- **{title}**")
+        return "\n".join(lines) if lines else None
+
     def _file_entry(
         self,
         raw_path: object,
@@ -728,6 +835,8 @@ class QuestStageViewBuilder:
             or self.snapshot.get("active_idea_draft_path")
             or str(Path(worktree_root) / "memory" / "ideas" / idea_id / "draft.md")
         )
+        idea_markdown = self._markdown_body_for_path(idea_md_path)
+        idea_md_rel_path = self._relative_path_or_raw(idea_md_path)
         draft_md_rel_path = self._relative_path_or_raw(draft_md_path)
         draft_markdown = self._markdown_body_for_path(draft_md_path)
         lineage_intent = str(payload.get("lineage_intent") or details.get("lineage_intent") or "").strip() or None
@@ -800,10 +909,14 @@ class QuestStageViewBuilder:
                     "risks": details.get("risks") or [],
                     "evidence_paths": details.get("evidence_paths") or [],
                     "lineage_intent": lineage_intent,
+                    "idea_path": idea_md_rel_path,
+                    "idea_markdown": idea_markdown,
                     "draft_path": draft_md_rel_path,
                     "draft_markdown": draft_markdown,
                     "literature_files": literature_files,
-                }
+                    "decision_reason": payload.get("reason"),
+                },
+                "latest_artifact": self._artifact_detail(latest, payload),
             },
             lineage_intent=lineage_intent,
             idea_draft_path=draft_md_rel_path,
@@ -869,6 +982,7 @@ class QuestStageViewBuilder:
             if isinstance(latest_experiment_payload.get("paths"), dict)
             else {}
         )
+        latest_run_markdown = self._markdown_body_for_path(latest_experiment_paths.get("run_md"))
         latest_result_payload = (
             read_json(Path(str(latest_experiment_paths.get("result_json"))), {})
             if str(latest_experiment_paths.get("result_json") or "").strip()
@@ -904,6 +1018,7 @@ class QuestStageViewBuilder:
             if str(analysis_manifest.get("campaign_id") or "").strip()
             else None
         )
+        analysis_summary_markdown = self._markdown_body_for_path(analysis_summary_path)
 
         branch_items = [
             item
@@ -1008,6 +1123,11 @@ class QuestStageViewBuilder:
                     "next_target": next_target,
                     "idea_draft_path": idea_draft_rel_path,
                     "idea_draft_markdown": idea_draft_markdown,
+                    "idea_hypothesis": latest_idea_details.get("hypothesis"),
+                    "idea_mechanism": latest_idea_details.get("mechanism"),
+                    "idea_expected_gain": latest_idea_details.get("expected_gain"),
+                    "idea_risks": latest_idea_details.get("risks") or [],
+                    "decision_reason": latest_idea_payload.get("reason"),
                     "latest_main_experiment": {
                         "run_id": latest_run_id,
                         "summary": latest_experiment_payload.get("summary"),
@@ -1017,11 +1137,16 @@ class QuestStageViewBuilder:
                         "progress_eval": latest_progress_eval,
                         "evaluation_summary": latest_evaluation_summary,
                         "run_md_path": latest_experiment_paths.get("run_md"),
+                        "run_markdown": latest_run_markdown,
                         "result_json_path": latest_experiment_paths.get("result_json"),
+                        "result_payload": latest_result_payload,
                     }
                     if latest_run_id
                     else None,
-                }
+                    "analysis_summary_path": self._relative_path_or_raw(analysis_summary_path),
+                    "analysis_summary_markdown": analysis_summary_markdown,
+                },
+                "latest_artifact": self._artifact_detail(latest_experiment_item or latest_idea_item, latest_experiment_payload or latest_idea_payload),
             },
             lineage_intent=lineage_intent,
             idea_draft_path=idea_draft_rel_path,
@@ -1057,8 +1182,17 @@ class QuestStageViewBuilder:
         baseline_ref = payload.get("baseline_ref") or result_payload.get("baseline_ref") or {}
         evaluation_summary = _evaluation_summary(payload.get("evaluation_summary") or result_payload.get("evaluation_summary"))
         run_id = str(payload.get("run_id") or "pending").strip() or "pending"
+        run_markdown = self._markdown_body_for_path(paths.get("run_md"))
+        trace_summary = self._trace_summary()
+        trace_markdown = self._trace_markdown()
         note = (
-            str(payload.get("summary") or result_payload.get("conclusion") or (progress_eval or {}).get("reason") or "").strip()
+            str(
+                payload.get("summary")
+                or result_payload.get("conclusion")
+                or (progress_eval or {}).get("reason")
+                or trace_summary
+                or ""
+            ).strip()
             or "No durable main experiment result has been recorded yet."
         )
         title = f"Experiment · {run_id}"
@@ -1119,8 +1253,15 @@ class QuestStageViewBuilder:
                     "metrics_summary": metrics_summary,
                     "progress_eval": progress_eval,
                     "evaluation_summary": evaluation_summary,
+                    "run_path": self._relative_path_or_raw(paths.get("run_md")),
+                    "run_markdown": run_markdown,
+                    "result_json_path": self._relative_path_or_raw(paths.get("result_json")),
                     "result_payload": result_payload,
-                }
+                    "trace_summary": trace_summary,
+                    "trace_markdown": trace_markdown,
+                    "trace_actions": self._recent_trace_actions(),
+                },
+                "latest_artifact": self._artifact_detail(latest, payload),
             },
         )
 
@@ -1145,7 +1286,9 @@ class QuestStageViewBuilder:
             flow_type = str(payload.get("flow_type") or "").strip()
             if flow_type not in {"analysis_campaign", "analysis_slice"}:
                 continue
-            if campaign_id and str(payload.get("campaign_id") or "").strip() != campaign_id:
+            if campaign_id:
+                if str(payload.get("campaign_id") or "").strip() == campaign_id:
+                    items.append(item)
                 continue
             if self._branch_matches(payload, allow_parent=True, include_unscoped=False):
                 items.append(item)
@@ -1228,13 +1371,23 @@ class QuestStageViewBuilder:
                     "plan_path": item.get("plan_path"),
                     "result_path": item.get("result_path"),
                     "mirror_path": item.get("mirror_path"),
+                    "plan_markdown": self._markdown_body_for_path(item.get("plan_path")),
+                    "result_markdown": self._markdown_body_for_path(item.get("result_path")),
+                    "mirror_markdown": self._markdown_body_for_path(item.get("mirror_path")),
                 }
             )
         title = f"Analysis · {campaign_id}"
+        trace_summary = self._trace_summary()
         note = (
-            str(latest_payload.get("summary") or manifest.get("goal") or "").strip()
+            str(latest_payload.get("summary") or manifest.get("goal") or trace_summary or "").strip()
             or "No durable analysis campaign has been created yet."
         )
+        summary_path = (
+            self.quest_root / "experiments" / "analysis-results" / campaign_id / "SUMMARY.md"
+            if campaign_id != "pending"
+            else None
+        )
+        summary_markdown = self._markdown_body_for_path(summary_path) if summary_path else None
         key_files = self._dedupe_files(
             [
                 self._file_entry(manifest.get("_manifest_path"), label="Campaign Manifest", description="Structured analysis campaign manifest."),
@@ -1293,8 +1446,17 @@ class QuestStageViewBuilder:
                     "summary": latest_payload.get("summary"),
                     "manifest_path": manifest.get("_manifest_path"),
                     "charter_path": manifest.get("charter_path"),
+                    "charter_markdown": self._markdown_body_for_path(manifest.get("charter_path")),
                     "todo_manifest_path": manifest.get("todo_manifest_path"),
-                }
+                    "todo_manifest_markdown": self._markdown_body_for_path(manifest.get("todo_manifest_path")),
+                    "summary_path": self._relative_path_or_raw(summary_path) if summary_path else None,
+                    "summary_markdown": summary_markdown,
+                    "manifest_payload": manifest,
+                    "trace_summary": trace_summary,
+                    "trace_markdown": self._trace_markdown(),
+                    "trace_actions": self._recent_trace_actions(),
+                },
+                "latest_artifact": self._artifact_detail(latest, latest_payload),
             },
         )
 
@@ -1435,6 +1597,7 @@ class QuestStageViewBuilder:
                         "latex_root_path": latex_root_rel,
                         "main_tex_path": main_tex_rel,
                     },
-                }
+                },
+                "latest_artifact": self._artifact_detail(paper_items[-1] if paper_items else None, self._payload(paper_items[-1] if paper_items else {})),
             },
         )