@researai/deepscientist 1.5.0 → 1.5.2

package/src/deepscientist/artifact/service.py

@@ -91,6 +91,41 @@ class ArtifactService:
         self.baselines = BaselineRegistry(home)
         self.quest_service = QuestService(home)
 
+    def _normalize_evaluation_summary(self, payload: dict[str, Any] | None) -> dict[str, str] | None:
+        if not isinstance(payload, dict):
+            return None
+        normalized: dict[str, str] = {}
+        for key in (
+            "takeaway",
+            "claim_update",
+            "baseline_relation",
+            "comparability",
+            "failure_mode",
+            "next_action",
+        ):
+            value = payload.get(key)
+            if value is None:
+                continue
+            text = str(value).strip()
+            if text:
+                normalized[key] = text
+        return normalized or None
+
+    def _evaluation_summary_markdown_lines(self, payload: dict[str, Any] | None) -> list[str]:
+        normalized = self._normalize_evaluation_summary(payload)
+        if not normalized:
+            return ["- Not recorded."]
+        labels = (
+            ("takeaway", "Takeaway"),
+            ("claim_update", "Claim Update"),
+            ("baseline_relation", "Baseline Relation"),
+            ("comparability", "Comparability"),
+            ("failure_mode", "Failure Mode"),
+            ("next_action", "Next Action"),
+        )
+        lines = [f"- {label}: {normalized[key]}" for key, label in labels if normalized.get(key)]
+        return lines or ["- Not recorded."]
+
     def _workspace_root_for(self, quest_root: Path, workspace_root: Path | None = None) -> Path:
         if workspace_root is not None:
             return workspace_root
@@ -387,6 +422,207 @@ class ArtifactService:
         write_json(path, normalized)
         return normalized
 
+    def _analysis_baseline_inventory_path(self, quest_root: Path) -> Path:
+        return ensure_dir(quest_root / "artifacts" / "baselines") / "analysis_inventory.json"
+
+    def _read_analysis_baseline_inventory(self, quest_root: Path) -> dict[str, Any]:
+        path = self._analysis_baseline_inventory_path(quest_root)
+        payload = read_json(path, {})
+        if not isinstance(payload, dict):
+            payload = {}
+        entries = payload.get("entries") if isinstance(payload.get("entries"), list) else []
+        return {
+            "schema_version": 1,
+            "entries": [dict(item) for item in entries if isinstance(item, dict)],
+            "updated_at": payload.get("updated_at"),
+        }
+
+    def _write_analysis_baseline_inventory(self, quest_root: Path, payload: dict[str, Any]) -> dict[str, Any]:
+        path = self._analysis_baseline_inventory_path(quest_root)
+        normalized_entries = payload.get("entries") if isinstance(payload.get("entries"), list) else []
+        normalized = {
+            "schema_version": 1,
+            "entries": [dict(item) for item in normalized_entries if isinstance(item, dict)],
+            "updated_at": utc_now(),
+        }
+        write_json(path, normalized)
+        return normalized
+
+    def _normalize_baseline_root_rel_path(
+        self,
+        quest_root: Path,
+        baseline_root_rel_path: str | None,
+        *,
+        baseline_id: str | None = None,
+    ) -> tuple[str | None, str | None]:
+        raw = str(baseline_root_rel_path or "").strip()
+        if not raw:
+            return None, None
+        candidate = Path(raw)
+        resolved = candidate.resolve() if candidate.is_absolute() else resolve_within(quest_root, raw)
+        if not resolved.exists():
+            raise FileNotFoundError(f"Baseline root does not exist: {resolved}")
+        try:
+            relative = resolved.relative_to(quest_root.resolve()).as_posix()
+        except ValueError as exc:
+            raise ValueError("`baseline_root_rel_path` must stay within quest_root.") from exc
+        parts = Path(relative).parts
+        if len(parts) < 3 or parts[0] != "baselines" or parts[1] not in {"local", "imported"}:
+            raise ValueError(
+                "`baseline_root_rel_path` must live under `baselines/local/<baseline_id>/...` or "
+                "`baselines/imported/<baseline_id>/...`."
+            )
+        normalized_baseline_id = str(baseline_id or parts[2]).strip() or None
+        if normalized_baseline_id and parts[2] != normalized_baseline_id:
+            raise ValueError(
+                f"`baseline_root_rel_path` points to baseline `{parts[2]}`, which does not match `{normalized_baseline_id}`."
+            )
+        return relative, parts[1]
+
+    @staticmethod
+    def _analysis_baseline_label(payload: dict[str, Any]) -> str:
+        baseline_id = str(payload.get("baseline_id") or "baseline").strip() or "baseline"
+        parts = [f"`{baseline_id}`"]
+        variant_id = str(payload.get("variant_id") or "").strip()
+        if variant_id:
+            parts.append(f"variant `{variant_id}`")
+        benchmark = str(payload.get("benchmark") or "").strip()
+        split = str(payload.get("split") or "").strip()
+        if benchmark and split:
+            parts.append(f"benchmark `{benchmark}` / split `{split}`")
+        elif benchmark:
+            parts.append(f"benchmark `{benchmark}`")
+        elif split:
+            parts.append(f"split `{split}`")
+        reason = str(payload.get("reason") or "").strip()
+        if reason:
+            parts.append(f"reason: {reason}")
+        return " · ".join(parts)
+
+    def _normalize_required_baselines(self, quest_root: Path, values: list[object] | None) -> list[dict[str, Any]]:
+        normalized: list[dict[str, Any]] = []
+        for raw in values or []:
+            if not isinstance(raw, dict):
+                continue
+            baseline_id = str(raw.get("baseline_id") or "").strip()
+            if not baseline_id:
+                continue
+            baseline_root_rel_path, storage_mode = self._normalize_baseline_root_rel_path(
+                quest_root,
+                raw.get("baseline_root_rel_path"),
+                baseline_id=baseline_id,
+            )
+            normalized.append(
+                {
+                    "baseline_id": baseline_id,
+                    "variant_id": str(raw.get("variant_id") or "").strip() or None,
+                    "reason": str(raw.get("reason") or "").strip() or None,
+                    "benchmark": str(raw.get("benchmark") or "").strip() or None,
+                    "split": str(raw.get("split") or "").strip() or None,
+                    "baseline_root_rel_path": baseline_root_rel_path,
+                    "storage_mode": storage_mode or (str(raw.get("storage_mode") or "").strip() or None),
+                    "usage_scope": "supplementary",
+                }
+            )
+        return normalized
+
+    def _normalize_comparison_baselines(self, quest_root: Path, values: list[object] | None) -> list[dict[str, Any]]:
+        normalized: list[dict[str, Any]] = []
+        for raw in values or []:
+            if not isinstance(raw, dict):
+                continue
+            baseline_id = str(raw.get("baseline_id") or "").strip()
+            if not baseline_id:
+                continue
+            baseline_root_rel_path, storage_mode = self._normalize_baseline_root_rel_path(
+                quest_root,
+                raw.get("baseline_root_rel_path"),
+                baseline_id=baseline_id,
+            )
+            metrics_summary = (
+                normalize_metrics_summary(raw.get("metrics_summary"))
+                if isinstance(raw.get("metrics_summary"), dict)
+                else {}
+            )
+            normalized.append(
+                {
+                    "baseline_id": baseline_id,
+                    "variant_id": str(raw.get("variant_id") or "").strip() or None,
+                    "benchmark": str(raw.get("benchmark") or "").strip() or None,
+                    "split": str(raw.get("split") or "").strip() or None,
+                    "reason": str(raw.get("reason") or "").strip() or None,
+                    "metrics_summary": metrics_summary,
+                    "evidence_paths": [
+                        str(item).strip() for item in (raw.get("evidence_paths") or []) if str(item).strip()
+                    ],
+                    "baseline_root_rel_path": baseline_root_rel_path,
+                    "storage_mode": storage_mode or (str(raw.get("storage_mode") or "").strip() or None),
+                    "usage_scope": "supplementary",
+                    "published": bool(raw.get("published", False)),
+                    "published_entry_id": str(raw.get("published_entry_id") or "").strip() or None,
+                    "status": str(raw.get("status") or "registered").strip() or "registered",
+                }
+            )
+        return normalized
+
+    @staticmethod
+    def _analysis_inventory_entry_key(payload: dict[str, Any]) -> tuple[str, str, str, str, str, str]:
+        origin = dict(payload.get("origin") or {}) if isinstance(payload.get("origin"), dict) else {}
+        return (
+            str(payload.get("baseline_id") or "").strip(),
+            str(payload.get("variant_id") or "").strip(),
+            str(origin.get("campaign_id") or "").strip(),
+            str(origin.get("slice_id") or "").strip(),
+            str(payload.get("benchmark") or "").strip(),
+            str(payload.get("split") or "").strip(),
+        )
+
+    @staticmethod
+    def _merge_analysis_inventory_entry(existing: dict[str, Any], incoming: dict[str, Any]) -> dict[str, Any]:
+        merged = dict(existing)
+        for key, value in incoming.items():
+            if value is None:
+                continue
+            if isinstance(value, str) and not value.strip():
+                continue
+            if isinstance(value, (list, dict)) and not value:
+                continue
+            merged[key] = value
+        merged["updated_at"] = utc_now()
+        merged.setdefault("created_at", existing.get("created_at") or incoming.get("created_at") or utc_now())
+        return merged
+
+    def _upsert_analysis_baseline_inventory(self, quest_root: Path, entries: list[dict[str, Any]]) -> dict[str, Any]:
+        inventory = self._read_analysis_baseline_inventory(quest_root)
+        existing_entries = [dict(item) for item in (inventory.get("entries") or []) if isinstance(item, dict)]
+        by_key = {
+            self._analysis_inventory_entry_key(item): dict(item)
+            for item in existing_entries
+            if str(item.get("baseline_id") or "").strip()
+        }
+        for raw in entries:
+            if not isinstance(raw, dict):
+                continue
+            entry = dict(raw)
+            if not str(entry.get("baseline_id") or "").strip():
+                continue
+            key = self._analysis_inventory_entry_key(entry)
+            current = by_key.get(key)
+            if current is None:
+                stamped = dict(entry)
+                stamped.setdefault("created_at", utc_now())
+                stamped["updated_at"] = utc_now()
+                by_key[key] = stamped
+                continue
+            by_key[key] = self._merge_analysis_inventory_entry(current, entry)
+        normalized = self._write_analysis_baseline_inventory(
+            quest_root,
+            {
+                "entries": list(by_key.values()),
+            },
+        )
+        return normalized
+
     def _paper_root(self, quest_root: Path) -> Path:
         return ensure_dir(quest_root / "paper")
 
@@ -405,6 +641,114 @@ class ArtifactService:
     def _paper_bundle_manifest_path(self, quest_root: Path) -> Path:
         return self._paper_root(quest_root) / "paper_bundle_manifest.json"
 
+    def _paper_baseline_inventory_path(self, quest_root: Path) -> Path:
+        return self._paper_root(quest_root) / "baseline_inventory.json"
+
+    def _open_source_root(self, quest_root: Path) -> Path:
+        return ensure_dir(quest_root / "release" / "open_source")
+
+    def _open_source_manifest_path(self, quest_root: Path) -> Path:
+        return self._open_source_root(quest_root) / "manifest.json"
+
+    def _open_source_cleanup_plan_path(self, quest_root: Path) -> Path:
+        return self._open_source_root(quest_root) / "cleanup_plan.md"
+
+    def _open_source_include_paths_path(self, quest_root: Path) -> Path:
+        return self._open_source_root(quest_root) / "include_paths.json"
+
+    def _open_source_exclude_paths_path(self, quest_root: Path) -> Path:
+        return self._open_source_root(quest_root) / "exclude_paths.json"
+
+    def _write_paper_baseline_inventory(self, quest_root: Path) -> dict[str, Any]:
+        quest_yaml = self.quest_service.read_quest_yaml(quest_root)
+        confirmed_baseline_ref = (
+            dict(quest_yaml.get("confirmed_baseline_ref") or {})
+            if isinstance(quest_yaml.get("confirmed_baseline_ref"), dict)
+            else None
+        )
+        analysis_inventory = self._read_analysis_baseline_inventory(quest_root)
+        payload = {
+            "schema_version": 1,
+            "canonical_baseline_ref": confirmed_baseline_ref,
+            "supplementary_baselines": [
+                dict(item) for item in (analysis_inventory.get("entries") or []) if isinstance(item, dict)
+            ],
+            "updated_at": utc_now(),
+        }
+        write_json(self._paper_baseline_inventory_path(quest_root), payload)
+        return payload
+
+    def _ensure_open_source_prep(
+        self,
+        quest_root: Path,
+        *,
+        source_branch: str | None,
+        source_bundle_manifest_path: str,
+        baseline_inventory_path: str,
+    ) -> dict[str, Any]:
+        root = self._open_source_root(quest_root)
+        cleanup_plan_path = self._open_source_cleanup_plan_path(quest_root)
+        include_paths_path = self._open_source_include_paths_path(quest_root)
+        exclude_paths_path = self._open_source_exclude_paths_path(quest_root)
+        manifest_path = self._open_source_manifest_path(quest_root)
+        if not cleanup_plan_path.exists():
+            write_text(
+                cleanup_plan_path,
+                "\n".join(
+                    [
+                        "# Open Source Cleanup Plan",
+                        "",
+                        "## Goal",
+                        "",
+                        "Prepare a clean public code branch from the finalized paper line.",
+                        "",
+                        "## Keep",
+                        "",
+                        "- Core training / evaluation code needed to reproduce the public results.",
+                        "",
+                        "## Remove Or Private",
+                        "",
+                        "- Temporary logs, scratch files, local secrets, and unrelated experimental debris.",
+                        "",
+                        "## Before Release",
+                        "",
+                        "- Confirm README, license, and benchmark instructions are complete.",
+                        "- Confirm only necessary files remain in scope.",
+                        "",
+                    ]
+                ).rstrip()
+                + "\n",
+            )
+        if not include_paths_path.exists():
+            write_json(include_paths_path, {"paths": []})
+        if not exclude_paths_path.exists():
+            write_json(exclude_paths_path, {"paths": []})
+        existing = read_json(manifest_path, {})
+        existing = existing if isinstance(existing, dict) else {}
+        manifest = {
+            **existing,
+            "schema_version": 1,
+            "status": str(existing.get("status") or "draft").strip() or "draft",
+            "source_branch": str(existing.get("source_branch") or source_branch or "").strip() or None,
+            "release_branch": str(existing.get("release_branch") or "").strip() or None,
+            "source_bundle_manifest_path": str(
+                existing.get("source_bundle_manifest_path") or source_bundle_manifest_path or ""
+            ).strip()
+            or source_bundle_manifest_path,
+            "baseline_inventory_path": str(existing.get("baseline_inventory_path") or baseline_inventory_path or "").strip()
+            or baseline_inventory_path,
+            "cleanup_plan_path": str(existing.get("cleanup_plan_path") or "release/open_source/cleanup_plan.md").strip()
+            or "release/open_source/cleanup_plan.md",
+            "include_paths_path": str(existing.get("include_paths_path") or "release/open_source/include_paths.json").strip()
+            or "release/open_source/include_paths.json",
+            "exclude_paths_path": str(existing.get("exclude_paths_path") or "release/open_source/exclude_paths.json").strip()
+            or "release/open_source/exclude_paths.json",
+            "created_at": existing.get("created_at") or utc_now(),
+            "updated_at": utc_now(),
+        }
+        write_json(manifest_path, manifest)
+        return manifest
+
     def _next_paper_outline_id(self, quest_root: Path) -> str:
         max_index = 0
         for root in (self._paper_outline_candidates_root(quest_root), self._paper_outline_revisions_root(quest_root)):
@@ -422,6 +766,45 @@ class ArtifactService:
     def _normalize_string_list(values: list[object] | None) -> list[str]:
         return [str(item).strip() for item in (values or []) if str(item).strip()]
 
+    def _normalize_campaign_origin(self, payload: dict[str, Any] | None) -> dict[str, Any] | None:
+        if not isinstance(payload, dict):
+            return None
+        origin_kind = str(payload.get("kind") or "analysis").strip().lower() or "analysis"
+        normalized = {
+            "kind": origin_kind,
+            "reason": str(payload.get("reason") or "").strip() or None,
+            "source_artifact_id": str(payload.get("source_artifact_id") or "").strip() or None,
+            "source_outline_ref": str(payload.get("source_outline_ref") or "").strip() or None,
+            "source_review_round": str(payload.get("source_review_round") or "").strip() or None,
+            "reviewer_item_ids": self._normalize_string_list(payload.get("reviewer_item_ids")),
+        }
+        if not any(value for key, value in normalized.items() if key != "kind"):
+            normalized["reason"] = None
+        return normalized
+
+    def _normalize_campaign_todo_items(self, todo_items: list[dict[str, Any]] | None) -> list[dict[str, Any]]:
+        normalized_items: list[dict[str, Any]] = []
+        for raw in todo_items or []:
+            if not isinstance(raw, dict):
+                continue
+            normalized_items.append(
+                {
+                    "todo_id": str(raw.get("todo_id") or raw.get("slice_id") or "").strip() or None,
+                    "slice_id": str(raw.get("slice_id") or "").strip() or None,
+                    "title": str(raw.get("title") or "").strip() or None,
+                    "status": str(raw.get("status") or "pending").strip() or "pending",
+                    "research_question": str(raw.get("research_question") or "").strip() or None,
+                    "experimental_design": str(raw.get("experimental_design") or "").strip() or None,
+                    "completion_condition": str(raw.get("completion_condition") or "").strip() or None,
+                    "why_now": str(raw.get("why_now") or "").strip() or None,
+                    "success_criteria": str(raw.get("success_criteria") or "").strip() or None,
+                    "abandonment_criteria": str(raw.get("abandonment_criteria") or "").strip() or None,
+                    "reviewer_item_ids": self._normalize_string_list(raw.get("reviewer_item_ids")),
+                    "manuscript_targets": self._normalize_string_list(raw.get("manuscript_targets")),
+                }
+            )
+        return normalized_items
+
     def _normalize_paper_outline_record(
         self,
         *,
@@ -1073,6 +1456,80 @@ class ArtifactService:
         ]
         return candidates[-1] if candidates else None
 
+    def _latest_branch_idea_id(self, quest_root: Path, branch_name: str) -> str | None:
+        normalized_branch = str(branch_name or "").strip()
+        if not normalized_branch:
+            return None
+        latest_idea = self._latest_idea_for_branch(quest_root, normalized_branch)
+        if isinstance(latest_idea, dict):
+            candidate = str(latest_idea.get("idea_id") or "").strip()
+            if candidate:
+                return candidate
+        latest_main_run = self._latest_main_run_for_branch(quest_root, normalized_branch)
+        if isinstance(latest_main_run, dict):
+            candidate = str(latest_main_run.get("idea_id") or "").strip()
+            if candidate:
+                return candidate
+        latest_match: tuple[str, int, str] | None = None
+        latest_candidate: str | None = None
+        for item in self.quest_service._collect_artifacts(quest_root):
+            payload = dict(item.get("payload") or {}) if isinstance(item.get("payload"), dict) else {}
+            if not payload:
+                continue
+            if str(payload.get("branch") or "").strip() != normalized_branch:
+                continue
+            candidate = str(payload.get("idea_id") or "").strip()
+            if not candidate:
+                continue
+            artifact_path = str(item.get("path") or "")
+            try:
+                artifact_mtime_ns = Path(artifact_path).stat().st_mtime_ns if artifact_path else 0
+            except OSError:
+                artifact_mtime_ns = 0
+            sort_key = (
+                str(payload.get("updated_at") or payload.get("created_at") or ""),
+                artifact_mtime_ns,
+                artifact_path,
+            )
+            if latest_match is None or sort_key > latest_match:
+                latest_match = sort_key
+                latest_candidate = candidate
+        if latest_match is not None and latest_candidate:
+            return latest_candidate
+        return None
+
+    def _resolve_analysis_parent_context(
+        self,
+        quest_root: Path,
+        *,
+        state: dict[str, Any],
+    ) -> tuple[str, Path, str | None]:
+        current_root_raw = str(state.get("current_workspace_root") or "").strip()
+        head_root_raw = str(state.get("research_head_worktree_root") or "").strip()
+        parent_worktree_root: Path | None = None
+        for raw in (current_root_raw, head_root_raw):
+            if not raw:
+                continue
+            candidate = Path(raw)
+            if candidate.exists():
+                parent_worktree_root = candidate
+                break
+        if parent_worktree_root is None:
+            parent_worktree_root = self._workspace_root_for(quest_root)
+
+        parent_branch = (
+            str(state.get("current_workspace_branch") or "").strip()
+            or str(state.get("research_head_branch") or "").strip()
+            or current_branch(parent_worktree_root)
+            or current_branch(self._workspace_root_for(quest_root))
+        )
+        parent_branch = str(parent_branch or "").strip()
+        if not parent_branch:
+            raise ValueError("Unable to resolve a parent branch for the analysis campaign.")
+
+        idea_id = self._latest_branch_idea_id(quest_root, parent_branch) or str(state.get("active_idea_id") or "").strip() or None
+        return parent_branch, parent_worktree_root, idea_id
+
     def _idea_parent_branch(self, record: dict[str, Any] | None) -> str | None:
         if not isinstance(record, dict) or not record:
             return None
@@ -1357,6 +1814,111 @@ class ArtifactService:
             "branches": branches,
         }
 
+    def resolve_runtime_refs(self, quest_root: Path) -> dict[str, Any]:
+        state = self.quest_service.read_research_state(quest_root)
+        snapshot = self.quest_service.snapshot(self._quest_id(quest_root))
+        active_campaign_id = str(state.get("active_analysis_campaign_id") or "").strip() or None
+        analysis_parent_branch = str(state.get("analysis_parent_branch") or "").strip() or None
+        current_workspace_branch = str(state.get("current_workspace_branch") or "").strip() or None
+        research_head_branch = str(state.get("research_head_branch") or "").strip() or None
+        canonical_branch = analysis_parent_branch or current_workspace_branch or research_head_branch
+        latest_main_run = self._latest_main_run_for_branch(quest_root, canonical_branch or "")
+        selected_outline = read_json(self._paper_selected_outline_path(quest_root), {})
+        selected_outline = selected_outline if isinstance(selected_outline, dict) else {}
+        active_campaign = (
+            self._read_analysis_manifest(quest_root, active_campaign_id)
+            if active_campaign_id
+            else {}
+        )
+        active_campaign = active_campaign if isinstance(active_campaign, dict) else {}
+        latest_paths = (
+            dict(latest_main_run.get("paths") or {})
+            if isinstance(latest_main_run, dict) and isinstance(latest_main_run.get("paths"), dict)
+            else {}
+        )
+        return {
+            "ok": True,
+            "active_idea_id": str(state.get("active_idea_id") or "").strip() or None,
+            "research_head_branch": research_head_branch,
+            "research_head_worktree_root": str(state.get("research_head_worktree_root") or "").strip() or None,
+            "current_workspace_branch": current_workspace_branch,
+            "current_workspace_root": str(state.get("current_workspace_root") or "").strip() or None,
+            "analysis_parent_branch": analysis_parent_branch,
+            "analysis_parent_worktree_root": str(state.get("analysis_parent_worktree_root") or "").strip() or None,
+            "current_canonical_branch": canonical_branch,
+            "active_analysis_campaign_id": active_campaign_id,
+            "active_campaign_title": str(active_campaign.get("title") or "").strip() or None,
+            "next_pending_slice_id": str(state.get("next_pending_slice_id") or "").strip() or None,
+            "latest_main_run_id": str((latest_main_run or {}).get("run_id") or "").strip() or None,
+            "latest_main_run_branch": str((latest_main_run or {}).get("branch") or "").strip() or None,
+            "latest_main_result_json": str(latest_paths.get("result_json") or "").strip() or None,
+            "selected_outline_ref": str(selected_outline.get("outline_id") or "").strip() or None,
+            "default_reply_interaction_id": str(snapshot.get("default_reply_interaction_id") or "").strip() or None,
+        }
+
+    def get_analysis_campaign(self, quest_root: Path, campaign_id: str | None = None) -> dict[str, Any]:
+        resolved_campaign_id = str(campaign_id or "").strip()
+        if not resolved_campaign_id or resolved_campaign_id == "active":
+            state = self.quest_service.read_research_state(quest_root)
+            resolved_campaign_id = str(state.get("active_analysis_campaign_id") or "").strip()
+        if not resolved_campaign_id:
+            raise ValueError("No active analysis campaign is available.")
+        manifest = self._read_analysis_manifest(quest_root, resolved_campaign_id)
+        slices = [dict(item) for item in (manifest.get("slices") or []) if isinstance(item, dict)]
+        pending_slices = [item for item in slices if str(item.get("status") or "pending").strip() == "pending"]
+        completed_slices = [item for item in slices if str(item.get("status") or "").strip() != "pending"]
+        next_pending_slice = pending_slices[0] if pending_slices else None
+        return {
+            "ok": True,
+            "campaign_id": resolved_campaign_id,
+            "title": str(manifest.get("title") or "").strip() or None,
+            "goal": str(manifest.get("goal") or "").strip() or None,
+            "active_idea_id": str(manifest.get("active_idea_id") or "").strip() or None,
+            "parent_run_id": str(manifest.get("parent_run_id") or "").strip() or None,
+            "parent_branch": str(manifest.get("parent_branch") or "").strip() or None,
+            "parent_worktree_root": str(manifest.get("parent_worktree_root") or "").strip() or None,
+            "selected_outline_ref": str(manifest.get("selected_outline_ref") or "").strip() or None,
+            "campaign_origin": dict(manifest.get("campaign_origin") or {}) if isinstance(manifest.get("campaign_origin"), dict) else None,
+            "todo_items": [dict(item) for item in (manifest.get("todo_items") or []) if isinstance(item, dict)],
+            "slices": slices,
+            "next_pending_slice_id": str((next_pending_slice or {}).get("slice_id") or "").strip() or None,
+            "pending_slice_count": len(pending_slices),
+            "completed_slice_count": len(completed_slices),
+            "manifest": manifest,
+        }
+
+    def list_paper_outlines(self, quest_root: Path) -> dict[str, Any]:
+        selected_outline = read_json(self._paper_selected_outline_path(quest_root), {})
+        selected_outline = selected_outline if isinstance(selected_outline, dict) else {}
+        outlines: list[dict[str, Any]] = []
+        for status, root in (
+            ("candidate", self._paper_outline_candidates_root(quest_root)),
+            ("revised", self._paper_outline_revisions_root(quest_root)),
+        ):
+            for path in sorted(root.glob("outline-*.json")):
+                record = read_json(path, {})
+                if not isinstance(record, dict) or not record:
+                    continue
+                outline_id = str(record.get("outline_id") or path.stem).strip() or path.stem
+                outlines.append(
+                    {
+                        "outline_id": outline_id,
+                        "title": str(record.get("title") or outline_id).strip() or outline_id,
+                        "status": str(record.get("status") or status).strip() or status,
+                        "review_result": str(record.get("review_result") or "").strip() or None,
+                        "path": str(path),
+                        "is_selected": outline_id == str(selected_outline.get("outline_id") or "").strip(),
+                    }
+                )
+        outlines.sort(key=lambda item: (str(item.get("outline_id") or ""), str(item.get("status") or "")))
+        return {
+            "ok": True,
+            "selected_outline_ref": str(selected_outline.get("outline_id") or "").strip() or None,
+            "selected_outline": selected_outline or None,
+            "count": len(outlines),
+            "outlines": outlines,
+        }
+
     def _previous_primary_best(
         self,
         quest_root: Path,
@@ -2149,6 +2711,7 @@ class ArtifactService:
         status: str = "completed",
         baseline_id: str | None = None,
         baseline_variant_id: str | None = None,
+        evaluation_summary: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         self._require_baseline_gate_open(quest_root, action="record_main_experiment")
         state = self.quest_service.read_research_state(quest_root)
@@ -2227,6 +2790,7 @@ class ArtifactService:
         resolved_config_paths = [str(item).strip() for item in (config_paths or []) if str(item).strip()]
         resolved_notes = [str(item).strip() for item in (notes or []) if str(item).strip()]
         normalized_dataset_scope = str(dataset_scope or "full").strip().lower() or "full"
+        normalized_evaluation_summary = self._normalize_evaluation_summary(evaluation_summary)
         primary = comparisons.get("primary") if isinstance(comparisons, dict) else {}
         primary_metric_id = str(progress_eval.get("primary_metric_id") or comparisons.get("primary_metric_id") or "").strip() or None
         primary_value = primary.get("run_value") if isinstance(primary, dict) else None
@@ -2336,6 +2900,8 @@ class ArtifactService:
         if resolved_notes:
             run_lines.extend(["", "## Notes", ""])
             run_lines.extend([f"- {item}" for item in resolved_notes])
+        run_lines.extend(["", "## Evaluation Summary", ""])
+        run_lines.extend(self._evaluation_summary_markdown_lines(normalized_evaluation_summary))
         run_lines.extend(
             [
                 "",
@@ -2384,6 +2950,7 @@ class ArtifactService:
                 key: value for key, value in comparisons.items() if key != "primary"
             },
             "progress_eval": progress_eval,
+            "evaluation_summary": normalized_evaluation_summary,
             "delivery_policy": delivery_policy,
             "startup_contract": delivery_policy.get("startup_contract") or None,
             "evidence_paths": resolved_evidence_paths,
@@ -2424,6 +2991,7 @@ class ArtifactService:
                     "recommended_next_route": delivery_policy.get("recommended_next_route"),
                     "changed_file_count": len(resolved_changed_files),
                     "evidence_count": len(resolved_evidence_paths),
+                    "evaluation_summary": normalized_evaluation_summary,
                 },
                 "delivery_policy": delivery_policy,
                 "startup_contract": delivery_policy.get("startup_contract") or None,
@@ -2439,6 +3007,7 @@ class ArtifactService:
                     key: value for key, value in comparisons.items() if key != "primary"
                 },
                 "progress_eval": progress_eval,
+                "evaluation_summary": normalized_evaluation_summary,
                 "files_changed": resolved_changed_files,
                 "evidence_paths": resolved_evidence_paths,
                 "verdict": verdict,
@@ -2475,6 +3044,7 @@ class ArtifactService:
                     "breakthrough_level": progress_eval.get("breakthrough_level"),
                     "need_research_paper": delivery_policy.get("need_research_paper"),
                     "recommended_next_route": delivery_policy.get("recommended_next_route"),
+                    "evaluation_summary": normalized_evaluation_summary,
                 }
             ],
         )
@@ -2497,6 +3067,7 @@ class ArtifactService:
                 key: value for key, value in comparisons.items() if key != "primary"
             },
             "progress_eval": progress_eval,
+            "evaluation_summary": normalized_evaluation_summary,
             "delivery_policy": delivery_policy,
         }
 
@@ -2508,6 +3079,7 @@ class ArtifactService:
         campaign_goal: str,
         parent_run_id: str | None = None,
         slices: list[dict[str, Any]],
+        campaign_origin: dict[str, Any] | None = None,
         selected_outline_ref: str | None = None,
         research_questions: list[str] | None = None,
         experimental_designs: list[str] | None = None,
@@ -2515,21 +3087,25 @@ class ArtifactService:
     ) -> dict[str, Any]:
         self._require_baseline_gate_open(quest_root, action="create_analysis_campaign")
         state = self.quest_service.read_research_state(quest_root)
-        active_idea_id = str(state.get("active_idea_id") or "").strip()
+        parent_branch, parent_worktree_root, resolved_idea_id = self._resolve_analysis_parent_context(
+            quest_root,
+            state=state,
+        )
+        active_idea_id = str(resolved_idea_id or "").strip()
         if not active_idea_id:
             raise ValueError("An active idea is required before starting an analysis campaign.")
         if not slices:
             raise ValueError("At least one analysis slice is required.")
-        parent_branch = str(state.get("research_head_branch") or current_branch(self._workspace_root_for(quest_root))).strip()
-        parent_worktree_root = Path(str(state.get("research_head_worktree_root") or self._workspace_root_for(quest_root)))
         campaign_id = generate_id("analysis")
         charter_dir = ensure_dir(parent_worktree_root / "experiments" / "analysis-results" / campaign_id)
         charter_path = charter_dir / "campaign.md"
+        normalized_campaign_origin = self._normalize_campaign_origin(campaign_origin)
         resolved_outline_ref = str(selected_outline_ref or "").strip() or None
         normalized_research_questions = self._normalize_string_list(research_questions)
         normalized_experimental_designs = self._normalize_string_list(experimental_designs)
-        normalized_todo_items = [dict(item) for item in (todo_items or []) if isinstance(item, dict)]
+        normalized_todo_items = self._normalize_campaign_todo_items(todo_items)
         slice_contexts: list[dict[str, Any]] = []
+        inventory_entries: list[dict[str, Any]] = []
         for index, raw in enumerate(slices, start=1):
             slice_id = str(raw.get("slice_id") or generate_id("slice")).strip()
             title = str(raw.get("title") or slice_id).strip() or slice_id
@@ -2550,6 +3126,21 @@ class ArtifactService:
                 worktree_root=worktree_root,
                 start_point=parent_branch,
             )
+            reviewer_item_ids = self._normalize_string_list(
+                raw.get("reviewer_item_ids") or matched_todo.get("reviewer_item_ids")
+            )
+            manuscript_targets = self._normalize_string_list(
+                raw.get("manuscript_targets") or matched_todo.get("manuscript_targets")
+            )
+            why_now = str(raw.get("why_now") or matched_todo.get("why_now") or "").strip()
+            success_criteria = str(raw.get("success_criteria") or matched_todo.get("success_criteria") or "").strip()
+            abandonment_criteria = str(
+                raw.get("abandonment_criteria") or matched_todo.get("abandonment_criteria") or ""
+            ).strip()
+            required_baselines = self._normalize_required_baselines(
+                quest_root,
+                raw.get("required_baselines") or matched_todo.get("required_baselines"),
+            )
             plan_dir = ensure_dir(worktree_root / "experiments" / "analysis" / campaign_id / slice_id)
             plan_path = plan_dir / "plan.md"
             requirement_lines = [
@@ -2567,6 +3158,10 @@ class ArtifactService:
                 "",
                 str(raw.get("experimental_design") or matched_todo.get("experimental_design") or "").strip() or "TBD",
                 "",
+                "## Why Now",
+                "",
+                why_now or "TBD",
+                "",
                 "## Hypothesis",
                 "",
                 str(raw.get("hypothesis") or "").strip() or "TBD",
@@ -2575,25 +3170,55 @@ class ArtifactService:
                 "",
                 str(raw.get("required_changes") or "").strip() or "TBD",
                 "",
-                "## Metric Contract",
-                "",
-                str(raw.get("metric_contract") or "").strip() or "TBD",
-                "",
-                "## Environment Notes",
-                "",
-                str(raw.get("environment_notes") or "").strip() or "TBD",
-                "",
-                "## Must Not Simplify",
-                "",
-                str(raw.get("must_not_simplify") or "").strip() or "Full dataset / full protocol only unless explicitly approved.",
-                "",
-                "## Completion Condition",
-                "",
-                str(raw.get("completion_condition") or matched_todo.get("completion_condition") or "").strip()
-                or str(raw.get("must_not_simplify") or matched_todo.get("must_not_simplify") or "").strip()
-                or "Complete the planned analysis slice and mirror the durable result back to the parent branch.",
+                "## Required Baselines",
                 "",
             ]
+            if required_baselines:
+                requirement_lines.extend([f"- {self._analysis_baseline_label(item)}" for item in required_baselines])
+            else:
+                requirement_lines.append("- None recorded.")
+            requirement_lines.extend(
+                [
+                    "",
+                    "## Metric Contract",
+                    "",
+                    str(raw.get("metric_contract") or "").strip() or "TBD",
+                    "",
+                    "## Environment Notes",
+                    "",
+                    str(raw.get("environment_notes") or "").strip() or "TBD",
+                    "",
+                    "## Must Not Simplify",
+                    "",
+                    str(raw.get("must_not_simplify") or "").strip() or "Full dataset / full protocol only unless explicitly approved.",
+                    "",
+                    "## Success Criteria",
+                    "",
+                    success_criteria or "TBD",
+                    "",
+                    "## Abandonment Criteria",
+                    "",
+                    abandonment_criteria or "TBD",
+                    "",
+                    "## Completion Condition",
+                    "",
+                    str(raw.get("completion_condition") or matched_todo.get("completion_condition") or "").strip()
+                    or str(raw.get("must_not_simplify") or matched_todo.get("must_not_simplify") or "").strip()
+                    or "Complete the planned analysis slice and mirror the durable result back to the parent branch.",
+                    "",
+                ]
+            )
+            requirement_lines.extend(["## Reviewer Item IDs", ""])
+            if reviewer_item_ids:
+                requirement_lines.extend([f"- `{item}`" for item in reviewer_item_ids])
+            else:
+                requirement_lines.append("- None recorded.")
+            requirement_lines.extend(["", "## Manuscript Targets", ""])
+            if manuscript_targets:
+                requirement_lines.extend([f"- {item}" for item in manuscript_targets])
+            else:
+                requirement_lines.append("- None recorded.")
+            requirement_lines.append("")
             write_text(plan_path, "\n".join(requirement_lines))
             slice_contexts.append(
                 {
@@ -2612,20 +3237,48 @@ class ArtifactService:
                     "experimental_design": str(
                         raw.get("experimental_design") or matched_todo.get("experimental_design") or ""
                     ).strip(),
+                    "why_now": why_now,
                     "hypothesis": str(raw.get("hypothesis") or "").strip(),
                     "required_changes": str(raw.get("required_changes") or "").strip(),
                     "metric_contract": str(raw.get("metric_contract") or "").strip(),
                     "environment_notes": str(raw.get("environment_notes") or "").strip(),
                     "must_not_simplify": str(raw.get("must_not_simplify") or "").strip(),
+                    "success_criteria": success_criteria,
+                    "abandonment_criteria": abandonment_criteria,
                     "completion_condition": str(
                         raw.get("completion_condition") or matched_todo.get("completion_condition") or ""
                     ).strip(),
+                    "required_baselines": required_baselines,
+                    "reviewer_item_ids": reviewer_item_ids,
+                    "manuscript_targets": manuscript_targets,
                 }
+                )
+            inventory_entries.extend(
+                [
+                    {
+                        "baseline_id": item.get("baseline_id"),
+                        "variant_id": item.get("variant_id"),
+                        "usage_scope": "supplementary",
+                        "status": "required",
+                        "reason": item.get("reason"),
+                        "benchmark": item.get("benchmark"),
+                        "split": item.get("split"),
+                        "baseline_root_rel_path": item.get("baseline_root_rel_path"),
+                        "storage_mode": item.get("storage_mode"),
+                        "origin": {
+                            "stage": "analysis_campaign",
+                            "campaign_id": campaign_id,
+                            "slice_id": slice_id,
+                        },
+                    }
+                    for item in required_baselines
+                ]
             )
 
         todo_manifest = {
             "schema_version": 1,
             "campaign_id": campaign_id,
+            "campaign_origin": normalized_campaign_origin,
             "selected_outline_ref": resolved_outline_ref,
             "research_questions": normalized_research_questions,
             "experimental_designs": normalized_experimental_designs,
@@ -2635,9 +3288,15 @@ class ArtifactService:
                     "slice_id": context["slice_id"],
                     "title": str(item.get("title") or context["title"]).strip() or context["title"],
                     "status": str(item.get("status") or "pending").strip() or "pending",
-                    "research_question": context.get("research_question") or item.get("research_question"),
-                    "experimental_design": context.get("experimental_design") or item.get("experimental_design"),
-                    "completion_condition": context.get("completion_condition") or item.get("completion_condition") or context.get("must_not_simplify"),
+                    "research_question": item.get("research_question") or context.get("research_question"),
+                    "experimental_design": item.get("experimental_design") or context.get("experimental_design"),
+                    "completion_condition": item.get("completion_condition") or context.get("completion_condition") or context.get("must_not_simplify"),
+                    "why_now": item.get("why_now") or context.get("why_now"),
+                    "success_criteria": item.get("success_criteria") or context.get("success_criteria"),
+                    "abandonment_criteria": item.get("abandonment_criteria") or context.get("abandonment_criteria"),
+                    "required_baselines": item.get("required_baselines") or context.get("required_baselines") or [],
+                    "reviewer_item_ids": item.get("reviewer_item_ids") or context.get("reviewer_item_ids") or [],
+                    "manuscript_targets": item.get("manuscript_targets") or context.get("manuscript_targets") or [],
                 }
                 for context, item in zip(slice_contexts, normalized_todo_items + [{}] * max(0, len(slice_contexts) - len(normalized_todo_items)))
             ],
@@ -2666,6 +3325,14 @@ class ArtifactService:
             "",
             f"`{resolved_outline_ref or 'none'}`",
             "",
+            "## Campaign Origin",
+            "",
+            f"- Kind: `{(normalized_campaign_origin or {}).get('kind') or 'analysis'}`",
+            f"- Reason: {str((normalized_campaign_origin or {}).get('reason') or 'Not recorded')}",
+            f"- Source Artifact: `{str((normalized_campaign_origin or {}).get('source_artifact_id') or 'none')}`",
+            f"- Source Outline: `{str((normalized_campaign_origin or {}).get('source_outline_ref') or 'none')}`",
+            f"- Source Review Round: `{str((normalized_campaign_origin or {}).get('source_review_round') or 'none')}`",
+            "",
             "## Slices",
             "",
         ]
@@ -2681,8 +3348,14 @@ class ArtifactService:
                     f"- Goal: {item['goal'] or 'TBD'}",
                     f"- Research question: {item['research_question'] or 'TBD'}",
                     f"- Experimental design: {item['experimental_design'] or 'TBD'}",
+                    f"- Why now: {item['why_now'] or 'TBD'}",
+                    f"- Required baselines: {', '.join(self._analysis_baseline_label(entry) for entry in item['required_baselines']) or 'none'}",
+                    f"- Success criteria: {item['success_criteria'] or 'TBD'}",
+                    f"- Abandonment criteria: {item['abandonment_criteria'] or 'TBD'}",
                     f"- Completion condition: {item['completion_condition'] or item['must_not_simplify'] or 'TBD'}",
                     f"- Requirement: {item['must_not_simplify'] or 'TBD'}",
+                    f"- Reviewer items: {', '.join(item['reviewer_item_ids']) or 'none'}",
+                    f"- Manuscript targets: {', '.join(item['manuscript_targets']) or 'none'}",
                     "",
                 ]
             )
@@ -2697,6 +3370,7 @@ class ArtifactService:
                 "active_idea_id": active_idea_id,
                 "parent_branch": parent_branch,
                 "parent_worktree_root": str(parent_worktree_root),
+                "campaign_origin": normalized_campaign_origin,
                 "selected_outline_ref": resolved_outline_ref,
                 "research_questions": normalized_research_questions,
                 "experimental_designs": normalized_experimental_designs,
@@ -2707,6 +3381,45 @@ class ArtifactService:
                 "created_at": utc_now(),
             },
         )
+        for item in slice_contexts:
+            self.record(
+                quest_root,
+                {
+                    "kind": "milestone",
+                    "status": "prepared",
+                    "summary": f"Analysis slice `{item['slice_id']}` prepared as a child branch.",
+                    "reason": "Expose the pending follow-up branch durably so Canvas and Git lineage stay visible before execution.",
+                    "idea_id": active_idea_id,
+                    "campaign_id": campaign_id,
+                    "slice_id": item["slice_id"],
+                    "branch": item["branch"],
+                    "parent_branch": parent_branch,
+                    "worktree_root": item["worktree_root"],
+                    "worktree_rel_path": self._workspace_relative(quest_root, Path(item["worktree_root"])),
+                    "flow_type": "analysis_slice",
+                    "protocol_step": "prepare",
+                    "paths": {
+                        "plan_md": item["plan_path"],
+                    },
+                    "details": {
+                        "title": item["title"],
+                        "goal": item["goal"],
+                        "run_kind": item["run_kind"],
+                        "research_question": item["research_question"],
+                        "experimental_design": item["experimental_design"],
+                        "why_now": item["why_now"],
+                        "completion_condition": item["completion_condition"] or item["must_not_simplify"],
+                        "must_not_simplify": item["must_not_simplify"],
+                        "required_baselines": item["required_baselines"],
+                        "success_criteria": item["success_criteria"],
+                        "abandonment_criteria": item["abandonment_criteria"],
+                        "reviewer_item_ids": item["reviewer_item_ids"],
+                        "manuscript_targets": item["manuscript_targets"],
+                    },
+                },
+                checkpoint=False,
+                workspace_root=Path(item["worktree_root"]),
+            )
         first_slice = slice_contexts[0]
         artifact = self.record(
             quest_root,
@@ -2729,6 +3442,7 @@ class ArtifactService:
                     "campaign_title": campaign_title,
                     "campaign_goal": campaign_goal,
                     "parent_run_id": parent_run_id,
+                    "campaign_origin": normalized_campaign_origin,
                     "selected_outline_ref": resolved_outline_ref,
                     "todo_manifest_path": str(todo_manifest_path),
                     "slice_count": len(slice_contexts),
@@ -2742,8 +3456,14 @@ class ArtifactService:
                             "goal": item["goal"],
                             "research_question": item["research_question"],
                             "experimental_design": item["experimental_design"],
+                            "why_now": item["why_now"],
                             "completion_condition": item["completion_condition"] or item["must_not_simplify"],
                             "must_not_simplify": item["must_not_simplify"],
+                            "required_baselines": item["required_baselines"],
+                            "success_criteria": item["success_criteria"],
+                            "abandonment_criteria": item["abandonment_criteria"],
+                            "reviewer_item_ids": item["reviewer_item_ids"],
+                            "manuscript_targets": item["manuscript_targets"],
                         }
                         for item in slice_contexts
                     ],
@@ -2754,6 +3474,7 @@ class ArtifactService:
         )
         research_state = self.quest_service.update_research_state(
             quest_root,
+            active_idea_id=active_idea_id,
             active_analysis_campaign_id=campaign_id,
             analysis_parent_branch=parent_branch,
             analysis_parent_worktree_root=str(parent_worktree_root),
@@ -2763,6 +3484,7 @@ class ArtifactService:
             workspace_mode="analysis",
             last_flow_type="analysis_campaign",
         )
+        baseline_inventory = self._upsert_analysis_baseline_inventory(quest_root, inventory_entries) if inventory_entries else None
         self.quest_service.update_settings(self._quest_id(quest_root), active_anchor="analysis-campaign")
         checkpoint_result = self._checkpoint_with_optional_push(
             parent_worktree_root,
@@ -2785,16 +3507,17 @@ class ArtifactService:
             attachments=[
                 {
                     "kind": "analysis_campaign",
-                "campaign_id": campaign_id,
-                "parent_branch": parent_branch,
-                "parent_worktree_root": str(parent_worktree_root),
-                "selected_outline_ref": resolved_outline_ref,
-                "todo_manifest_path": str(todo_manifest_path),
-                "next_slice": first_slice,
-                "todo_items": todo_manifest["todo_items"],
-                "slices": slice_contexts,
-            }
-        ],
+                    "campaign_id": campaign_id,
+                    "parent_branch": parent_branch,
+                    "parent_worktree_root": str(parent_worktree_root),
+                    "campaign_origin": normalized_campaign_origin,
+                    "selected_outline_ref": resolved_outline_ref,
+                    "todo_manifest_path": str(todo_manifest_path),
+                    "next_slice": first_slice,
+                    "todo_items": todo_manifest["todo_items"],
+                    "slices": slice_contexts,
+                }
+            ],
         )
         return {
             "ok": True,
@@ -2807,9 +3530,11 @@ class ArtifactService:
             "campaign_id": campaign_id,
             "parent_branch": parent_branch,
             "parent_worktree_root": str(parent_worktree_root),
+            "campaign_origin": normalized_campaign_origin,
             "charter_path": str(charter_path),
             "slices": slice_contexts,
             "manifest": manifest,
+            "analysis_baseline_inventory": baseline_inventory,
             "todo_manifest_path": str(todo_manifest_path),
             "artifact": artifact,
             "checkpoint": checkpoint_result,
@@ -2992,6 +3717,18 @@ class ArtifactService:
             raise ValueError("submit_paper_bundle requires a selected outline or explicit `outline_path`.")
 
         manifest_path = self._paper_bundle_manifest_path(quest_root)
+        baseline_inventory = self._write_paper_baseline_inventory(quest_root)
+        baseline_inventory_path = self._paper_baseline_inventory_path(quest_root)
+        source_branch = (
+            str(self.quest_service.read_research_state(quest_root).get("current_workspace_branch") or "").strip()
+            or current_branch(self._workspace_root_for(quest_root))
+        )
+        open_source_manifest = self._ensure_open_source_prep(
+            quest_root,
+            source_branch=source_branch,
+            source_bundle_manifest_path="paper/paper_bundle_manifest.json",
+            baseline_inventory_path="paper/baseline_inventory.json",
+        )
         manifest = {
             "schema_version": 1,
             "title": str(
@@ -3010,6 +3747,10 @@ class ArtifactService:
             "compile_report_path": str(compile_report_path or "paper/build/compile_report.json").strip() or None,
             "pdf_path": str(pdf_path or "").strip() or None,
             "latex_root_path": str(latex_root_path or "").strip() or None,
+            "baseline_inventory_path": "paper/baseline_inventory.json",
+            "open_source_manifest_path": "release/open_source/manifest.json",
+            "open_source_cleanup_plan_path": str(open_source_manifest.get("cleanup_plan_path") or "").strip()
+            or "release/open_source/cleanup_plan.md",
             "selected_outline_ref": str(selected_outline.get("outline_id") or "").strip() or None,
             "created_at": utc_now(),
             "updated_at": utc_now(),
@@ -3031,10 +3772,14 @@ class ArtifactService:
                     "outline_path": manifest.get("outline_path"),
                     "draft_path": manifest.get("draft_path"),
                     "pdf_path": manifest.get("pdf_path"),
+                    "baseline_inventory_path": str(baseline_inventory_path),
+                    "open_source_manifest_path": str(self._open_source_manifest_path(quest_root)),
                 },
                 "details": {
                     "title": manifest.get("title"),
                     "selected_outline_ref": manifest.get("selected_outline_ref"),
+                    "baseline_inventory_count": len(baseline_inventory.get("supplementary_baselines") or []),
+                    "open_source_status": open_source_manifest.get("status"),
                 },
             },
             checkpoint=False,
@@ -3044,6 +3789,8 @@ class ArtifactService:
             "ok": True,
             "manifest_path": str(manifest_path),
             "manifest": manifest,
+            "baseline_inventory_path": str(baseline_inventory_path),
+            "open_source_manifest_path": str(self._open_source_manifest_path(quest_root)),
             "artifact": artifact,
         }
 
@@ -3060,8 +3807,14 @@ class ArtifactService:
         evidence_paths: list[str] | None = None,
         metric_rows: list[dict[str, Any]] | None = None,
         deviations: list[str] | None = None,
+        claim_impact: str | None = None,
+        reviewer_resolution: str | None = None,
+        manuscript_update_hint: str | None = None,
+        next_recommendation: str | None = None,
         dataset_scope: str = "full",
         subset_approval_ref: str | None = None,
+        comparison_baselines: list[dict[str, Any]] | None = None,
+        evaluation_summary: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         state = self.quest_service.read_research_state(quest_root)
         manifest = self._read_analysis_manifest(quest_root, campaign_id)
@@ -3076,12 +3829,19 @@ class ArtifactService:
         evidence_paths = [str(item).strip() for item in (evidence_paths or []) if str(item).strip()]
         deviations = [str(item).strip() for item in (deviations or []) if str(item).strip()]
         metric_rows = [item for item in (metric_rows or []) if isinstance(item, dict)]
+        normalized_comparison_baselines = self._normalize_comparison_baselines(quest_root, comparison_baselines)
+        normalized_claim_impact = str(claim_impact or "").strip() or None
+        normalized_reviewer_resolution = str(reviewer_resolution or "").strip() or None
+        normalized_manuscript_update_hint = str(manuscript_update_hint or "").strip() or None
+        normalized_next_recommendation = str(next_recommendation or "").strip() or None
+        normalized_evaluation_summary = self._normalize_evaluation_summary(evaluation_summary)
         slice_worktree_root = Path(str(target.get("worktree_root") or ""))
         parent_worktree_root = Path(str(manifest.get("parent_worktree_root") or ""))
         parent_branch = str(manifest.get("parent_branch") or "")
 
         result_dir = ensure_dir(slice_worktree_root / "experiments" / "analysis" / campaign_id / slice_id)
         result_path = result_dir / "RESULT.md"
+        result_json_path = result_dir / "RESULT.json"
         result_lines = [
             f"# {target.get('title') or slice_id}",
             "",
@@ -3104,6 +3864,26 @@ class ArtifactService:
             "",
             results.strip() or "TBD",
             "",
+            "## Claim Impact",
+            "",
+            normalized_claim_impact or "Not recorded.",
+            "",
+            "## Reviewer Resolution",
+            "",
+            normalized_reviewer_resolution or "Not recorded.",
+            "",
+            "## Manuscript Update Hint",
+            "",
+            normalized_manuscript_update_hint or "Not recorded.",
+            "",
+            "## Next Recommendation",
+            "",
+            normalized_next_recommendation or "Not recorded.",
+            "",
+            "## Evaluation Summary",
+            "",
+            *self._evaluation_summary_markdown_lines(normalized_evaluation_summary),
+            "",
             "## Deviations",
             "",
         ]
@@ -3120,6 +3900,20 @@ class ArtifactService:
             result_lines.extend(["", "## Metric Rows", ""])
             for row in metric_rows:
                 result_lines.append(f"- `{row}`")
+        result_lines.extend(["", "## Comparison Baselines", ""])
+        if normalized_comparison_baselines:
+            for entry in normalized_comparison_baselines:
+                result_lines.append(f"- {self._analysis_baseline_label(entry)}")
+                if entry.get("baseline_root_rel_path"):
+                    result_lines.append(f"  - Root: `{entry['baseline_root_rel_path']}`")
+                if entry.get("metrics_summary"):
+                    result_lines.append(f"  - Metrics: `{entry['metrics_summary']}`")
+                if entry.get("published"):
+                    result_lines.append(
+                        f"  - Published: `{entry.get('published_entry_id') or entry.get('baseline_id')}`"
+                    )
+        else:
+            result_lines.append("- None recorded.")
         if subset_approval_ref:
             result_lines.extend(["", "## Subset Approval", "", f"`{subset_approval_ref}`"])
         write_text(result_path, "\n".join(result_lines).rstrip() + "\n")
@@ -3134,6 +3928,37 @@ class ArtifactService:
             if len(keys) == 1:
                 metrics_summary[keys[0]] = row.get(keys[0])
 
+        result_payload = {
+            "schema_version": 1,
+            "result_kind": "analysis_slice",
+            "campaign_id": campaign_id,
+            "slice_id": slice_id,
+            "status": status,
+            "title": target.get("title"),
+            "goal": target.get("goal"),
+            "run_kind": target.get("run_kind"),
+            "required_baselines": target.get("required_baselines") or [],
+            "comparison_baselines": normalized_comparison_baselines,
+            "metrics_summary": metrics_summary,
+            "metric_rows": metric_rows,
+            "dataset_scope": normalized_scope,
+            "subset_approval_ref": subset_approval_ref,
+            "setup": setup.strip() or None,
+            "execution": execution.strip() or None,
+            "results": results.strip() or None,
+            "claim_impact": normalized_claim_impact,
+            "reviewer_resolution": normalized_reviewer_resolution,
+            "manuscript_update_hint": normalized_manuscript_update_hint,
+            "next_recommendation": normalized_next_recommendation,
+            "evaluation_summary": normalized_evaluation_summary,
+            "deviations": deviations,
+            "evidence_paths": evidence_paths,
+            "source_branch": str(target.get("branch") or ""),
+            "source_worktree_root": str(slice_worktree_root),
+            "updated_at": utc_now(),
+        }
+        write_json(result_json_path, result_payload)
+
         mirror_dir = ensure_dir(parent_worktree_root / "experiments" / "analysis-results" / campaign_id)
         mirror_path = mirror_dir / f"{slice_id}.md"
         mirror_lines = [
@@ -3164,7 +3989,25 @@ class ArtifactService:
             "",
             results.strip() or "TBD",
             "",
+            "## Claim Impact",
+            "",
+            normalized_claim_impact or "Not recorded.",
+            "",
+            "## Manuscript Update Hint",
+            "",
+            normalized_manuscript_update_hint or "Not recorded.",
+            "",
+            "## Evaluation Summary",
+            "",
+            *self._evaluation_summary_markdown_lines(normalized_evaluation_summary),
+            "",
         ]
+        mirror_lines.extend(["## Comparison Baselines", ""])
+        if normalized_comparison_baselines:
+            mirror_lines.extend([f"- {self._analysis_baseline_label(entry)}" for entry in normalized_comparison_baselines])
+        else:
+            mirror_lines.append("- None recorded.")
+        mirror_lines.append("")
         write_text(mirror_path, "\n".join(mirror_lines).rstrip() + "\n")
 
         artifact = self.record(
@@ -3188,6 +4031,7 @@ class ArtifactService:
                 "protocol_step": "record",
                 "paths": {
                     "slice_result_md": str(result_path),
+                    "slice_result_json": str(result_json_path),
                     "parent_result_md": str(mirror_path),
                 },
                 "details": {
@@ -3197,9 +4041,17 @@ class ArtifactService:
                     "dataset_scope": normalized_scope,
                     "subset_approval_ref": subset_approval_ref,
                     "metric_rows": metric_rows,
+                    "claim_impact": normalized_claim_impact,
+                    "reviewer_resolution": normalized_reviewer_resolution,
+                    "manuscript_update_hint": normalized_manuscript_update_hint,
+                    "next_recommendation": normalized_next_recommendation,
                     "deviations": deviations,
                     "evidence_paths": evidence_paths,
+                    "required_baselines": target.get("required_baselines") or [],
+                    "comparison_baselines": normalized_comparison_baselines,
+                    "evaluation_summary": normalized_evaluation_summary,
                 },
+                "evaluation_summary": normalized_evaluation_summary,
             },
             checkpoint=False,
             workspace_root=slice_worktree_root,
@@ -3222,7 +4074,14 @@ class ArtifactService:
             updated["status"] = status
             updated["completed_at"] = utc_now()
             updated["result_path"] = str(result_path)
+            updated["result_json_path"] = str(result_json_path)
             updated["mirror_path"] = str(mirror_path)
+            updated["claim_impact"] = normalized_claim_impact
+            updated["reviewer_resolution"] = normalized_reviewer_resolution
+            updated["manuscript_update_hint"] = normalized_manuscript_update_hint
+            updated["next_recommendation"] = normalized_next_recommendation
+            updated["comparison_baselines"] = normalized_comparison_baselines
+            updated["evaluation_summary"] = normalized_evaluation_summary
             updated_slices.append(updated)
         next_slice = next((item for item in updated_slices if str(item.get("status") or "") == "pending"), None)
         manifest = self._write_analysis_manifest(
@@ -3233,6 +4092,36 @@ class ArtifactService:
                 "slices": updated_slices,
             },
         )
+        baseline_inventory = (
+            self._upsert_analysis_baseline_inventory(
+                quest_root,
+                [
+                    {
+                        "baseline_id": entry.get("baseline_id"),
+                        "variant_id": entry.get("variant_id"),
+                        "usage_scope": "supplementary",
+                        "status": "registered",
+                        "reason": entry.get("reason"),
+                        "benchmark": entry.get("benchmark"),
+                        "split": entry.get("split"),
+                        "baseline_root_rel_path": entry.get("baseline_root_rel_path"),
+                        "storage_mode": entry.get("storage_mode"),
+                        "metrics_summary": entry.get("metrics_summary"),
+                        "evidence_paths": entry.get("evidence_paths"),
+                        "published": entry.get("published"),
+                        "published_entry_id": entry.get("published_entry_id"),
+                        "origin": {
+                            "stage": "analysis_campaign",
+                            "campaign_id": campaign_id,
+                            "slice_id": slice_id,
+                        },
+                    }
+                    for entry in normalized_comparison_baselines
+                ],
+            )
+            if normalized_comparison_baselines
+            else self._read_analysis_baseline_inventory(quest_root)
+        )
 
         if next_slice is not None:
             research_state = self.quest_service.update_research_state(
@@ -3274,14 +4163,17 @@ class ArtifactService:
                 "slice_id": slice_id,
                 "status": status,
                 "result_path": str(result_path),
+                "result_json_path": str(result_json_path),
                 "mirror_path": str(mirror_path),
                 "artifact": artifact,
                 "slice_checkpoint": slice_checkpoint,
                 "parent_checkpoint": parent_checkpoint,
                 "next_slice": next_slice,
                 "manifest": manifest,
+                "analysis_baseline_inventory": baseline_inventory,
                 "interaction": interaction,
                 "research_state": research_state,
+                "evaluation_summary": normalized_evaluation_summary,
                 "completed": False,
             }
 
@@ -3336,12 +4228,14 @@ class ArtifactService:
             parent_worktree_root,
             message=f"analysis: summarize {campaign_id}",
         )
+        restored_idea_id = self._latest_branch_idea_id(quest_root, parent_branch) or str(manifest.get("active_idea_id") or "").strip() or None
         research_state = self.quest_service.update_research_state(
             quest_root,
+            active_idea_id=restored_idea_id,
             active_analysis_campaign_id=None,
             next_pending_slice_id=None,
-            current_workspace_branch=state.get("research_head_branch") or parent_branch,
-            current_workspace_root=state.get("research_head_worktree_root") or str(parent_worktree_root),
+            current_workspace_branch=parent_branch,
+            current_workspace_root=str(parent_worktree_root),
             workspace_mode="idea",
             last_flow_type="analysis_campaign_complete",
         )
@@ -3374,6 +4268,7 @@ class ArtifactService:
             "slice_id": slice_id,
             "status": status,
             "result_path": str(result_path),
+            "result_json_path": str(result_json_path),
             "mirror_path": str(mirror_path),
             "artifact": artifact,
             "slice_checkpoint": slice_checkpoint,
@@ -3382,8 +4277,10 @@ class ArtifactService:
             "summary_checkpoint": parent_summary_checkpoint,
             "summary_path": str(summary_path),
             "manifest": manifest,
+            "analysis_baseline_inventory": baseline_inventory,
             "interaction": interaction,
             "research_state": research_state,
+            "evaluation_summary": normalized_evaluation_summary,
             "completed": True,
             "returned_to_branch": parent_branch,
             "returned_to_worktree_root": str(parent_worktree_root),
@@ -3789,6 +4686,8 @@ class ArtifactService:
         expects_reply: bool | None = None,
         reply_mode: str | None = None,
         options: list[dict[str, Any]] | None = None,
+        surface_actions: list[dict[str, Any]] | None = None,
+        connector_hints: dict[str, Any] | None = None,
         allow_free_text: bool = True,
         reply_schema: dict[str, Any] | None = None,
         reply_to_interaction_id: str | None = None,
@@ -3801,6 +4700,9 @@ class ArtifactService:
             "approval_result": "approval",
         }.get(kind, "progress")
         options_resolved = options or []
+        surface_actions_resolved = [dict(item) for item in (surface_actions or []) if isinstance(item, dict)]
+        connector_hints_resolved = self._normalize_connector_hints(connector_hints)
+        attachments_resolved, attachment_issues = self._normalize_interaction_attachments(quest_root, attachments)
         reply_schema_resolved = reply_schema if isinstance(reply_schema, dict) else {}
         reply_mode_resolved = str(
             reply_mode
@@ -3860,10 +4762,14 @@ class ArtifactService:
                 "expects_reply": False,
                 "reply_mode": "none",
                 "delivered": False,
+                "delivery_results": [],
                 "response_phase": response_phase,
                 "delivery_targets": [],
                 "delivery_policy": self._delivery_policy(self._connectors_config()),
                 "preferred_connector": self._preferred_connector(self._connectors_config()),
+                "connector_hints": connector_hints_resolved,
+                "normalized_attachments": attachments_resolved,
+                "attachment_issues": attachment_issues,
                 "recent_inbound_messages": mailbox_payload.get("recent_inbound_messages") or [],
                 "delivery_batch": mailbox_payload.get("delivery_batch"),
                 "recent_interaction_records": mailbox_payload.get("recent_interaction_records") or [],
@@ -3889,11 +4795,13 @@ class ArtifactService:
             "summary": message,
             "interaction_phase": "request" if kind == "decision_request" else response_phase,
             "importance": importance,
-            "attachments": attachments or [],
+            "attachments": attachments_resolved,
             "interaction_id": resolved_interaction_id,
             "expects_reply": expects_reply_resolved,
             "reply_mode": reply_mode_resolved,
             "options": options_resolved,
+            "surface_actions": surface_actions_resolved,
+            "connector_hints": connector_hints_resolved,
             "allow_free_text": allow_free_text,
             "reply_schema": reply_schema_resolved,
             "reply_to_interaction_id": reply_to_interaction_id,
@@ -3929,6 +4837,7 @@ class ArtifactService:
         )
         delivery_targets: list[str] = []
         delivered = False
+        delivery_results: list[dict[str, Any]] = []
         if deliver_to_bound_conversations:
             connectors = self._connectors_config()
             targets = self._select_delivery_targets(
@@ -3950,12 +4859,17 @@ class ArtifactService:
                     "expects_reply": expects_reply_resolved,
                     "reply_mode": reply_mode_resolved,
                     "options": options_resolved,
+                    "surface_actions": surface_actions_resolved,
+                    "connector_hints": connector_hints_resolved,
                     "allow_free_text": allow_free_text,
                     "reply_schema": reply_schema_resolved,
                     "reply_to_interaction_id": reply_to_interaction_id,
-                    "attachments": attachments or [],
+                    "attachments": attachments_resolved,
                 }
-                if self._send_to_channel(channel_name, payload, connectors=connectors):
+                delivery_result = self._deliver_to_channel(channel_name, payload, connectors=connectors)
+                delivery_result["conversation_id"] = target
+                delivery_results.append(delivery_result)
+                if delivery_result.get("ok", False) or delivery_result.get("queued", False):
                     delivery_targets.append(target)
                     delivered = True
 
@@ -3985,6 +4899,8 @@ class ArtifactService:
             message=message,
             response_phase=response_phase,
             reply_mode=reply_mode_resolved,
+            surface_actions=surface_actions_resolved,
+            connector_hints=connector_hints_resolved,
             created_at=(artifact.get("record") or {}).get("updated_at"),
         )
 
@@ -3994,7 +4910,12 @@ class ArtifactService:
             "interaction_id": request_state.get("interaction_id"),
             "expects_reply": expects_reply_resolved,
             "reply_mode": reply_mode_resolved,
+            "surface_actions": surface_actions_resolved,
+            "connector_hints": connector_hints_resolved,
+            "normalized_attachments": attachments_resolved,
+            "attachment_issues": attachment_issues,
             "delivered": delivered,
+            "delivery_results": delivery_results,
             "response_phase": response_phase,
             "delivery_targets": delivery_targets,
             "delivery_policy": self._delivery_policy(self._connectors_config()),
@@ -4296,6 +5217,67 @@ class ArtifactService:
             return enabled[0]
         return None
 
+    @staticmethod
+    def _normalize_connector_hints(connector_hints: dict[str, Any] | None) -> dict[str, Any]:
+        if not isinstance(connector_hints, dict):
+            return {}
+        normalized: dict[str, Any] = {}
+        for key, value in connector_hints.items():
+            name = str(key or "").strip().lower()
+            if not name or not isinstance(value, dict):
+                continue
+            normalized[name] = dict(value)
+        return normalized
+
+    def _normalize_interaction_attachments(
+        self,
+        quest_root: Path,
+        attachments: list[dict[str, Any]] | None,
+    ) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+        normalized: list[dict[str, Any]] = []
+        issues: list[dict[str, Any]] = []
+        for index, raw_item in enumerate(attachments or [], start=1):
+            if not isinstance(raw_item, dict):
+                issues.append(
+                    {
+                        "attachment_index": index,
+                        "error": "attachment must be an object",
+                    }
+                )
+                continue
+            item = dict(raw_item)
+            path_value = str(item.get("path") or "").strip()
+            if path_value:
+                resolved_path = Path(path_value).expanduser()
+                if not resolved_path.is_absolute():
+                    resolved_path = (quest_root / resolved_path).resolve()
+                else:
+                    resolved_path = resolved_path.resolve()
+                item["path"] = str(resolved_path)
+                if not resolved_path.exists():
+                    item["path_error"] = "path_not_found"
+                    issues.append(
+                        {
+                            "attachment_index": index,
+                            "path": str(resolved_path),
+                            "error": "attachment path does not exist",
+                        }
+                    )
+            connector_delivery = item.get("connector_delivery")
+            if isinstance(connector_delivery, dict):
+                normalized_delivery: dict[str, Any] = {}
+                for key, value in connector_delivery.items():
+                    name = str(key or "").strip().lower()
+                    if not name or not isinstance(value, dict):
+                        continue
+                    normalized_delivery[name] = dict(value)
+                if normalized_delivery:
+                    item["connector_delivery"] = normalized_delivery
+                else:
+                    item.pop("connector_delivery", None)
+            normalized.append(item)
+        return normalized, issues
+
     def _select_delivery_targets(self, targets: list[str], *, connectors: dict[str, Any]) -> list[str]:
         if not targets:
             return ["local:default"]
@@ -4445,6 +5427,11 @@ class ArtifactService:
                 "transport": transport,
                 "response_phase": str(payload.get("response_phase") or "").strip() or None,
                 "importance": str(payload.get("importance") or "").strip() or None,
+                "artifact_id": str(payload.get("artifact_id") or "").strip() or None,
+                "interaction_id": str(payload.get("interaction_id") or "").strip() or None,
+                "surface_actions": payload.get("surface_actions") if isinstance(payload.get("surface_actions"), list) else [],
+                "connector_hints": payload.get("connector_hints") if isinstance(payload.get("connector_hints"), dict) else {},
+                "delivery_parts": delivery.get("parts") if isinstance(delivery.get("parts"), list) else [],
                 "error": str(result.get("error") or delivery.get("error") or "").strip() or None,
                 "created_at": utc_now(),
             },