@researai/deepscientist 1.5.7 → 1.5.9

package/src/deepscientist/artifact/service.py

@@ -10,6 +10,7 @@ from ..channels import get_channel_factory, register_builtin_channels
 from ..config import ConfigManager
 from ..connector_runtime import conversation_identity_key, infer_connector_transport, normalize_conversation_id
 from ..gitops import (
+    branch_exists,
     canonical_worktree_root,
     checkpoint_repo,
     create_worktree,
@@ -42,13 +43,18 @@ from .guidance import build_guidance_for_record, guidance_summary
 from .metrics import (
     baseline_metric_lines,
     build_metrics_timeline,
+    canonicalize_baseline_submission,
     compare_with_baseline,
     compute_progress_eval,
+    MetricContractValidationError,
     normalize_metric_contract,
+    normalize_metric_direction,
     normalize_metric_rows,
     normalize_metrics_summary,
     selected_baseline_metrics,
     to_number,
+    validate_baseline_metric_contract_submission,
+    validate_main_experiment_against_baseline_contract,
 )
 from .schemas import ARTIFACT_DIRS, guidance_for_kind, validate_artifact_payload
 
@@ -91,6 +97,16 @@ class ArtifactService:
         self.baselines = BaselineRegistry(home)
         self.quest_service = QuestService(home)
 
+    @staticmethod
+    def _notification_text(value: object, *, limit: int = 220) -> str | None:
+        text = str(value or "").strip()
+        if not text:
+            return None
+        text = re.sub(r"\s+", " ", text)
+        if len(text) <= limit:
+            return text
+        return text[: limit - 1].rstrip() + "…"
+
     def _normalize_evaluation_summary(self, payload: dict[str, Any] | None) -> dict[str, str] | None:
         if not isinstance(payload, dict):
             return None
@@ -126,6 +142,418 @@ class ArtifactService:
         lines = [f"- {label}: {normalized[key]}" for key, label in labels if normalized.get(key)]
         return lines or ["- Not recorded."]
 
+    @staticmethod
+    def _format_route_label(value: object) -> str | None:
+        normalized = str(value or "").strip().replace("_", " ").replace("-", " ")
+        if not normalized:
+            return None
+        return " ".join(part.capitalize() for part in normalized.split())
+
+    def _format_foundation_label(self, foundation_ref: dict[str, Any] | None, *, fallback: str | None = None) -> str:
+        payload = dict(foundation_ref or {})
+        label = self._notification_text(payload.get("label"))
+        if label:
+            return label
+        kind = self._notification_text(payload.get("kind"))
+        ref = self._notification_text(payload.get("ref"))
+        branch = self._notification_text(payload.get("branch"))
+        if kind and ref:
+            return f"{kind} {ref}"
+        if branch:
+            return branch
+        return fallback or "current head"
+
+    def _build_idea_interaction_message(
+        self,
+        *,
+        action: str,
+        idea_id: str,
+        title: str | None,
+        problem: str | None,
+        hypothesis: str | None,
+        mechanism: str | None,
+        foundation_label: str | None,
+        branch_name: str,
+        next_target: str | None,
+        idea_md_rel_path: str | None,
+        draft_md_rel_path: str | None,
+    ) -> str:
+        lead = "is now active" if action == "create" else "was revised"
+        lines = [f"Idea `{idea_id}` {lead} on branch `{branch_name}`."]
+        if self._notification_text(title):
+            lines.append(f"Title: {self._notification_text(title)}")
+        if self._notification_text(problem):
+            lines.append(f"Problem: {self._notification_text(problem)}")
+        if self._notification_text(hypothesis):
+            lines.append(f"Hypothesis: {self._notification_text(hypothesis)}")
+        if self._notification_text(mechanism):
+            lines.append(f"Mechanism: {self._notification_text(mechanism)}")
+        if foundation_label:
+            lines.append(f"Foundation: {foundation_label}")
+        if next_target:
+            lines.append(f"Next route: {self._format_route_label(next_target) or next_target}")
+        if idea_md_rel_path:
+            lines.append(f"Idea doc: `{idea_md_rel_path}`")
+        if draft_md_rel_path:
+            lines.append(f"Draft: `{draft_md_rel_path}`")
+        return "\n".join(lines)
+
+    def _build_main_experiment_interaction_message(
+        self,
+        *,
+        run_id: str,
+        branch_name: str,
+        verdict: str,
+        primary_metric_id: str | None,
+        primary_value: object,
+        primary_baseline: object,
+        primary_delta: object,
+        decimals: int | None,
+        conclusion: str | None,
+        evaluation_summary: dict[str, str] | None,
+        breakthrough_level: str | None,
+        recommended_next_route: str | None,
+        run_md_rel_path: str | None,
+        result_json_rel_path: str | None,
+    ) -> str:
+        lines = [f"Main experiment `{run_id}` finished on branch `{branch_name}`."]
+        if primary_metric_id and primary_value is not None:
+            metric_text = f"{primary_metric_id}={self._format_metric_value(primary_value, decimals)}"
+            if primary_baseline is not None and primary_delta is not None:
+                metric_text += (
+                    f", baseline={self._format_metric_value(primary_baseline, decimals)}, "
+                    f"delta={self._format_metric_value(primary_delta, decimals)}"
+                )
+            lines.append(f"Metric: {metric_text}")
+        lines.append(f"Verdict: {self._format_route_label(verdict) or verdict}")
+        takeaway = (
+            self._notification_text((evaluation_summary or {}).get("takeaway"))
+            or self._notification_text(conclusion)
+        )
+        if takeaway:
+            lines.append(f"Takeaway: {takeaway}")
+        claim_update = self._notification_text((evaluation_summary or {}).get("claim_update"))
+        if claim_update:
+            lines.append(f"Claim update: {claim_update}")
+        if self._notification_text(breakthrough_level):
+            lines.append(f"Breakthrough level: {self._notification_text(breakthrough_level)}")
+        if recommended_next_route:
+            lines.append(
+                f"Recommended next route: {self._format_route_label(recommended_next_route) or recommended_next_route}"
+            )
+        if run_md_rel_path:
+            lines.append(f"Run log: `{run_md_rel_path}`")
+        if result_json_rel_path:
+            lines.append(f"Result: `{result_json_rel_path}`")
+        return "\n".join(lines)
+
+    def _build_outline_interaction_message(
+        self,
+        *,
+        action: str,
+        outline_id: str,
+        title: str | None,
+        selected_reason: str | None,
+        story: str | None,
+        research_questions: object,
+        experimental_designs: object,
+        selected_outline_rel_path: str | None,
+        outline_selection_rel_path: str | None,
+        revised_outline_rel_path: str | None = None,
+    ) -> str:
+        verb = "selected" if action == "select" else "revised"
+        lines = [f"Paper outline `{outline_id}` was {verb} and promoted into the writing stage."]
+        if self._notification_text(title):
+            lines.append(f"Title: {self._notification_text(title)}")
+        if self._notification_text(selected_reason):
+            lines.append(f"Reason: {self._notification_text(selected_reason)}")
+        if self._notification_text(story):
+            lines.append(f"Story: {self._notification_text(story)}")
+        if research_questions:
+            lines.append(f"Research questions: {self._notification_text(research_questions)}")
+        if experimental_designs:
+            lines.append(f"Experimental designs: {self._notification_text(experimental_designs)}")
+        lines.append("Next route: Continue writing on the paper branch, or launch outline-bound analysis if evidence is still missing.")
+        if selected_outline_rel_path:
+            lines.append(f"Selected outline: `{selected_outline_rel_path}`")
+        if outline_selection_rel_path:
+            lines.append(f"Selection note: `{outline_selection_rel_path}`")
+        if revised_outline_rel_path:
+            lines.append(f"Revision record: `{revised_outline_rel_path}`")
+        return "\n".join(lines)
+
+    def _build_analysis_campaign_interaction_message(
+        self,
+        *,
+        campaign_id: str,
+        goal: str | None,
+        parent_branch: str,
+        selected_outline_ref: str | None,
+        first_slice: dict[str, Any],
+        todo_manifest_rel_path: str | None,
+    ) -> str:
+        lines = [f"Analysis campaign `{campaign_id}` is ready from parent branch `{parent_branch}`."]
+        if self._notification_text(goal):
+            lines.append(f"Goal: {self._notification_text(goal)}")
+        if selected_outline_ref:
+            lines.append(f"Selected outline: `{selected_outline_ref}`")
+        lines.append(
+            f"Next slice: `{first_slice.get('slice_id')}` on branch `{first_slice.get('branch')}`"
+        )
+        if self._notification_text(first_slice.get("title")):
+            lines.append(f"Slice focus: {self._notification_text(first_slice.get('title'))}")
+        requirement = self._notification_text(first_slice.get("must_not_simplify") or first_slice.get("goal"))
+        if requirement:
+            lines.append(f"Core requirement: {requirement}")
+        if todo_manifest_rel_path:
+            lines.append(f"Todo manifest: `{todo_manifest_rel_path}`")
+        return "\n".join(lines)
+
+    def _build_analysis_slice_interaction_message(
+        self,
+        *,
+        campaign_id: str,
+        slice_id: str,
+        evaluation_summary: dict[str, str] | None,
+        claim_impact: str | None,
+        next_slice: dict[str, Any],
+        mirror_rel_path: str | None,
+    ) -> str:
+        lines = [f"Analysis slice `{slice_id}` from campaign `{campaign_id}` is complete."]
+        takeaway = self._notification_text((evaluation_summary or {}).get("takeaway"))
+        if takeaway:
+            lines.append(f"Takeaway: {takeaway}")
+        if self._notification_text(claim_impact):
+            lines.append(f"Claim impact: {self._notification_text(claim_impact)}")
+        lines.append(
+            f"Next slice: `{next_slice.get('slice_id')}` on branch `{next_slice.get('branch')}`"
+        )
+        requirement = self._notification_text(next_slice.get("must_not_simplify") or next_slice.get("goal"))
+        if requirement:
+            lines.append(f"Core requirement: {requirement}")
+        if mirror_rel_path:
+            lines.append(f"Parent mirror: `{mirror_rel_path}`")
+        return "\n".join(lines)
+
+    def _build_analysis_complete_interaction_message(
+        self,
+        *,
+        campaign_id: str,
+        completed_slices: list[dict[str, Any]],
+        summary_rel_path: str | None,
+        writing_branch: str | None,
+        writing_worktree_rel_path: str | None,
+    ) -> str:
+        lines = [f"Analysis campaign `{campaign_id}` is complete."]
+        lines.append(f"Completed slices: {len(completed_slices)}")
+        strongest_takeaway = next(
+            (
+                self._notification_text(
+                    ((item.get("evaluation_summary") or {}) if isinstance(item.get("evaluation_summary"), dict) else {}).get(
+                        "takeaway"
+                    )
+                )
+                for item in completed_slices
+                if self._notification_text(
+                    ((item.get("evaluation_summary") or {}) if isinstance(item.get("evaluation_summary"), dict) else {}).get(
+                        "takeaway"
+                    )
+                )
+            ),
+            None,
+        )
+        if strongest_takeaway:
+            lines.append(f"Main takeaway: {strongest_takeaway}")
+        if summary_rel_path:
+            lines.append(f"Summary: `{summary_rel_path}`")
+        if writing_branch:
+            lines.append(f"Next route: writing is active on branch `{writing_branch}`")
+            if writing_worktree_rel_path:
+                lines.append(f"Writing workspace: `{writing_worktree_rel_path}`")
+        else:
+            lines.append("Next route: make the next durable decision from the merged analysis evidence.")
+        return "\n".join(lines)
+
+    def _load_metric_contract_payload(self, quest_root: Path, metric_contract_json_rel_path: str | None) -> dict[str, Any] | None:
+        rel_path = str(metric_contract_json_rel_path or "").strip()
+        if not rel_path:
+            return None
+        try:
+            resolved_path = resolve_within(quest_root, rel_path)
+        except ValueError:
+            return None
+        if not resolved_path.exists():
+            return None
+        payload = read_json(resolved_path, {})
+        return payload if isinstance(payload, dict) and payload else None
+
+    def _normalize_metric_directions(self, metric_directions: object) -> dict[str, str]:
+        if not isinstance(metric_directions, dict):
+            return {}
+        normalized: dict[str, str] = {}
+        for raw_metric_id, raw_direction in metric_directions.items():
+            metric_id = str(raw_metric_id or "").strip()
+            if not metric_id:
+                continue
+            normalized[metric_id] = normalize_metric_direction(raw_direction, metric_id=metric_id)
+        return normalized
+
+    def _apply_metric_directions_to_contract(
+        self,
+        *,
+        metric_contract: object,
+        metric_directions: object,
+        baseline_id: str | None = None,
+        metrics_summary: object = None,
+        metric_rows: object = None,
+        primary_metric: object = None,
+        baseline_variants: object = None,
+    ) -> tuple[dict[str, Any], dict[str, Any] | None]:
+        normalized_contract = normalize_metric_contract(
+            metric_contract,
+            baseline_id=baseline_id,
+            metrics_summary=metrics_summary,
+            metric_rows=metric_rows,
+            primary_metric=primary_metric,
+            baseline_variants=baseline_variants,
+        )
+        normalized_primary_metric = dict(primary_metric or {}) if isinstance(primary_metric, dict) else None
+        overrides = self._normalize_metric_directions(metric_directions)
+        if not overrides:
+            return normalized_contract, normalized_primary_metric
+
+        metrics_by_id: dict[str, dict[str, Any]] = {}
+        ordered_metric_ids: list[str] = []
+        for raw_metric in normalized_contract.get("metrics", []):
+            if not isinstance(raw_metric, dict):
+                continue
+            metric_id = str(raw_metric.get("metric_id") or "").strip()
+            if not metric_id:
+                continue
+            metrics_by_id[metric_id] = dict(raw_metric)
+            ordered_metric_ids.append(metric_id)
+        for metric_id, direction in overrides.items():
+            current = metrics_by_id.get(metric_id)
+            if current is None:
+                current = {
+                    "metric_id": metric_id,
+                    "label": metric_id,
+                    "direction": direction,
+                    "unit": None,
+                    "decimals": None,
+                    "chart_group": "default",
+                }
+                ordered_metric_ids.append(metric_id)
+            else:
+                current = {
+                    **current,
+                    "direction": direction,
+                }
+            metrics_by_id[metric_id] = current
+
+        primary_metric_id = str(
+            (normalized_primary_metric or {}).get("metric_id")
+            or (normalized_primary_metric or {}).get("name")
+            or (normalized_primary_metric or {}).get("id")
+            or normalized_contract.get("primary_metric_id")
+            or ""
+        ).strip()
+        if normalized_primary_metric and primary_metric_id in overrides:
+            normalized_primary_metric = {
+                **normalized_primary_metric,
+                "direction": overrides[primary_metric_id],
+            }
+
+        return {
+            **normalized_contract,
+            "metrics": [metrics_by_id[metric_id] for metric_id in ordered_metric_ids if metric_id in metrics_by_id],
+        }, normalized_primary_metric
+
+    def _merge_run_metric_contract(
+        self,
+        *,
+        baseline_metric_contract: object,
+        baseline_primary_metric: object,
+        baseline_variants: object,
+        run_metric_contract: object,
+        metrics_summary: object,
+        metric_rows: object,
+        baseline_id: str | None = None,
+    ) -> dict[str, Any]:
+        baseline_contract = normalize_metric_contract(
+            baseline_metric_contract,
+            baseline_id=baseline_id,
+            metrics_summary=metrics_summary,
+            metric_rows=metric_rows,
+            primary_metric=baseline_primary_metric,
+            baseline_variants=baseline_variants,
+        )
+        if not isinstance(run_metric_contract, dict) or not run_metric_contract:
+            return baseline_contract
+
+        overlay_contract = normalize_metric_contract(
+            run_metric_contract,
+            baseline_id=baseline_id,
+            metrics_summary=metrics_summary,
+            metric_rows=metric_rows,
+            primary_metric=baseline_contract.get("primary_metric_id"),
+        )
+        overlay_metrics: dict[str, dict[str, Any]] = {}
+        for raw_metric in overlay_contract.get("metrics", []):
+            if not isinstance(raw_metric, dict):
+                continue
+            metric_id = str(raw_metric.get("metric_id") or "").strip()
+            if metric_id:
+                overlay_metrics[metric_id] = raw_metric
+
+        merged_metrics: list[dict[str, Any]] = []
+        seen_metric_ids: set[str] = set()
+        for raw_metric in baseline_contract.get("metrics", []):
+            if not isinstance(raw_metric, dict):
+                continue
+            metric_id = str(raw_metric.get("metric_id") or "").strip()
+            if not metric_id:
+                continue
+            patch = overlay_metrics.get(metric_id) or {}
+            merged = dict(raw_metric)
+            for field in (
+                "label",
+                "unit",
+                "decimals",
+                "chart_group",
+                "description",
+                "derivation",
+                "source_ref",
+                "required",
+                "origin_path",
+            ):
+                value = patch.get(field)
+                if value is None:
+                    continue
+                if isinstance(value, str) and not value.strip():
+                    continue
+                merged[field] = value
+            merged_metrics.append(merged)
+            seen_metric_ids.add(metric_id)
+
+        for metric_id, raw_metric in overlay_metrics.items():
+            if metric_id in seen_metric_ids:
+                continue
+            merged_metrics.append(dict(raw_metric))
+
+        merged_contract = {
+            **baseline_contract,
+            "metrics": merged_metrics,
+        }
+        if not merged_contract.get("evaluation_protocol") and overlay_contract.get("evaluation_protocol") is not None:
+            merged_contract["evaluation_protocol"] = overlay_contract.get("evaluation_protocol")
+        for key, value in overlay_contract.items():
+            if key in {"contract_id", "primary_metric_id", "metrics", "evaluation_protocol"}:
+                continue
+            if key not in merged_contract and value is not None:
+                merged_contract[key] = value
+        return merged_contract
+
     def _workspace_root_for(self, quest_root: Path, workspace_root: Path | None = None) -> Path:
         if workspace_root is not None:
             return workspace_root
@@ -139,6 +567,73 @@ class ArtifactService:
         except ValueError:
             return str(path)
 
+    @staticmethod
+    def _branch_kind_from_name(branch_name: str | None) -> str:
+        normalized = str(branch_name or "").strip()
+        if normalized in {"main", "master"} or normalized.startswith("quest/"):
+            return "quest"
+        if normalized.startswith("idea/"):
+            return "idea"
+        if normalized.startswith("analysis/"):
+            return "analysis"
+        if normalized.startswith("paper/"):
+            return "paper"
+        if normalized.startswith("run/"):
+            return "run"
+        return "branch"
+
+    def _workspace_mode_for_branch(self, branch_name: str | None, *, has_idea: bool = False) -> str:
+        branch_kind = self._branch_kind_from_name(branch_name)
+        if branch_kind == "paper":
+            return "paper"
+        if branch_kind == "analysis":
+            return "analysis"
+        if branch_kind == "run":
+            return "run"
+        if branch_kind == "idea" or has_idea:
+            return "idea"
+        return "quest"
+
+    def _prepare_branch_worktree_root(
+        self,
+        quest_root: Path,
+        *,
+        branch_name: str,
+        branch_kind: str,
+        run_id: str | None = None,
+        idea_id: str | None = None,
+    ) -> Path:
+        normalized_kind = str(branch_kind or "").strip().lower() or "run"
+        normalized_run_id = str(run_id or "").strip() or None
+        normalized_idea_id = str(idea_id or "").strip() or None
+        if normalized_kind == "idea" and normalized_idea_id:
+            return canonical_worktree_root(quest_root, f"idea-{normalized_idea_id}")
+        if normalized_kind == "paper":
+            return canonical_worktree_root(
+                quest_root,
+                f"paper-{normalized_run_id or slugify(branch_name, 'paper')}",
+            )
+        if normalized_kind == "run" and normalized_run_id:
+            return canonical_worktree_root(quest_root, normalized_run_id)
+        return canonical_worktree_root(quest_root, slugify(branch_name, "branch"))
+
+    def _latest_prepare_branch_record(self, quest_root: Path, branch_name: str) -> dict[str, Any]:
+        normalized_branch = str(branch_name or "").strip()
+        if not normalized_branch:
+            return {}
+        for item in reversed(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("kind") or "").strip() != "decision":
+                continue
+            if str(payload.get("action") or "").strip() != "prepare_branch":
+                continue
+            if str(payload.get("branch") or "").strip() != normalized_branch:
+                continue
+            return payload
+        return {}
+
     def _git_config(self) -> dict[str, Any]:
         config = ConfigManager(self.home).load_named("config")
         payload = config.get("git") if isinstance(config.get("git"), dict) else {}
@@ -623,43 +1118,91 @@ class ArtifactService:
         )
         return normalized
 
-    def _paper_root(self, quest_root: Path) -> Path:
-        return ensure_dir(quest_root / "paper")
+    def _paper_root(
+        self,
+        quest_root: Path,
+        *,
+        workspace_root: Path | None = None,
+        prefer_workspace: bool = True,
+        create: bool = False,
+    ) -> Path:
+        roots: list[Path] = []
+        if prefer_workspace:
+            roots.append(self._workspace_root_for(quest_root, workspace_root))
+        roots.append(quest_root)
+        seen: set[str] = set()
+        first_candidate: Path | None = None
+        for root in roots:
+            key = str(root.resolve())
+            if key in seen:
+                continue
+            seen.add(key)
+            candidate = root / "paper"
+            if first_candidate is None:
+                first_candidate = candidate
+            if candidate.exists():
+                return candidate
+        fallback = first_candidate or (quest_root / "paper")
+        return ensure_dir(fallback) if create else fallback
 
-    def _paper_outline_candidates_root(self, quest_root: Path) -> Path:
-        return ensure_dir(self._paper_root(quest_root) / "outlines" / "candidates")
+    def _paper_outline_candidates_root(self, quest_root: Path, *, workspace_root: Path | None = None) -> Path:
+        return ensure_dir(self._paper_root(quest_root, workspace_root=workspace_root, create=True) / "outlines" / "candidates")
 
-    def _paper_outline_revisions_root(self, quest_root: Path) -> Path:
-        return ensure_dir(self._paper_root(quest_root) / "outlines" / "revisions")
+    def _paper_outline_revisions_root(self, quest_root: Path, *, workspace_root: Path | None = None) -> Path:
+        return ensure_dir(self._paper_root(quest_root, workspace_root=workspace_root, create=True) / "outlines" / "revisions")
 
-    def _paper_selected_outline_path(self, quest_root: Path) -> Path:
-        return self._paper_root(quest_root) / "selected_outline.json"
+    def _paper_selected_outline_path(self, quest_root: Path, *, workspace_root: Path | None = None) -> Path:
+        return self._paper_root(quest_root, workspace_root=workspace_root) / "selected_outline.json"
 
-    def _paper_outline_selection_path(self, quest_root: Path) -> Path:
-        return self._paper_root(quest_root) / "outline_selection.md"
+    def _paper_outline_selection_path(self, quest_root: Path, *, workspace_root: Path | None = None) -> Path:
+        return self._paper_root(quest_root, workspace_root=workspace_root, create=True) / "outline_selection.md"
 
-    def _paper_bundle_manifest_path(self, quest_root: Path) -> Path:
-        return self._paper_root(quest_root) / "paper_bundle_manifest.json"
+    def _paper_bundle_manifest_path(self, quest_root: Path, *, workspace_root: Path | None = None) -> Path:
+        return self._paper_root(quest_root, workspace_root=workspace_root, create=True) / "paper_bundle_manifest.json"
 
-    def _paper_baseline_inventory_path(self, quest_root: Path) -> Path:
-        return self._paper_root(quest_root) / "baseline_inventory.json"
+    def _paper_baseline_inventory_path(self, quest_root: Path, *, workspace_root: Path | None = None) -> Path:
+        return self._paper_root(quest_root, workspace_root=workspace_root, create=True) / "baseline_inventory.json"
 
-    def _open_source_root(self, quest_root: Path) -> Path:
-        return ensure_dir(quest_root / "release" / "open_source")
+    def _open_source_root(
+        self,
+        quest_root: Path,
+        *,
+        workspace_root: Path | None = None,
+        prefer_workspace: bool = True,
+        create: bool = False,
+    ) -> Path:
+        roots: list[Path] = []
+        if prefer_workspace:
+            roots.append(self._workspace_root_for(quest_root, workspace_root))
+        roots.append(quest_root)
+        seen: set[str] = set()
+        first_candidate: Path | None = None
+        for root in roots:
+            key = str(root.resolve())
+            if key in seen:
+                continue
+            seen.add(key)
+            candidate = root / "release" / "open_source"
+            if first_candidate is None:
+                first_candidate = candidate
+            if candidate.exists():
+                return candidate
+        fallback = first_candidate or (quest_root / "release" / "open_source")
+        return ensure_dir(fallback) if create else fallback
 
-    def _open_source_manifest_path(self, quest_root: Path) -> Path:
-        return self._open_source_root(quest_root) / "manifest.json"
+    def _open_source_manifest_path(self, quest_root: Path, *, workspace_root: Path | None = None) -> Path:
+        return self._open_source_root(quest_root, workspace_root=workspace_root, create=True) / "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_cleanup_plan_path(self, quest_root: Path, *, workspace_root: Path | None = None) -> Path:
+        return self._open_source_root(quest_root, workspace_root=workspace_root, create=True) / "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_include_paths_path(self, quest_root: Path, *, workspace_root: Path | None = None) -> Path:
+        return self._open_source_root(quest_root, workspace_root=workspace_root, create=True) / "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 _open_source_exclude_paths_path(self, quest_root: Path, *, workspace_root: Path | None = None) -> Path:
+        return self._open_source_root(quest_root, workspace_root=workspace_root, create=True) / "exclude_paths.json"
 
-    def _write_paper_baseline_inventory(self, quest_root: Path) -> dict[str, Any]:
+    def _write_paper_baseline_inventory(self, quest_root: Path, *, workspace_root: Path | None = None) -> dict[str, Any]:
         quest_yaml = self.quest_service.read_quest_yaml(quest_root)
         confirmed_baseline_ref = (
             dict(quest_yaml.get("confirmed_baseline_ref") or {})
@@ -675,22 +1218,23 @@ class ArtifactService:
             ],
             "updated_at": utc_now(),
         }
-        write_json(self._paper_baseline_inventory_path(quest_root), payload)
+        write_json(self._paper_baseline_inventory_path(quest_root, workspace_root=workspace_root), payload)
         return payload
 
     def _ensure_open_source_prep(
         self,
         quest_root: Path,
         *,
+        workspace_root: Path | None,
         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)
+        root = self._open_source_root(quest_root, workspace_root=workspace_root, create=True)
+        cleanup_plan_path = self._open_source_cleanup_plan_path(quest_root, workspace_root=workspace_root)
+        include_paths_path = self._open_source_include_paths_path(quest_root, workspace_root=workspace_root)
+        exclude_paths_path = self._open_source_exclude_paths_path(quest_root, workspace_root=workspace_root)
+        manifest_path = self._open_source_manifest_path(quest_root, workspace_root=workspace_root)
         if not cleanup_plan_path.exists():
             write_text(
                 cleanup_plan_path,
@@ -737,11 +1281,17 @@ class ArtifactService:
             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()
+            "cleanup_plan_path": str(
+                existing.get("cleanup_plan_path") or self._workspace_relative(quest_root, cleanup_plan_path) or ""
+            ).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()
+            "include_paths_path": str(
+                existing.get("include_paths_path") or self._workspace_relative(quest_root, include_paths_path) or ""
+            ).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()
+            "exclude_paths_path": str(
+                existing.get("exclude_paths_path") or self._workspace_relative(quest_root, exclude_paths_path) or ""
+            ).strip()
             or "release/open_source/exclude_paths.json",
             "created_at": existing.get("created_at") or utc_now(),
             "updated_at": utc_now(),
@@ -859,6 +1409,9 @@ class ArtifactService:
                     continue
                 seen_paths.add(key)
                 payload = read_yaml(path, {})
+                baseline_id = str(payload.get("source_baseline_id") or "").strip() if isinstance(payload, dict) else ""
+                if baseline_id and self.baselines.is_deleted(baseline_id):
+                    continue
                 if isinstance(payload, dict) and payload:
                     attachments.append(payload)
         if not attachments:
@@ -871,6 +1424,48 @@ class ArtifactService:
             ),
         )
 
+    def _baseline_workspace_roots(self, quest_root: Path) -> list[Path]:
+        roots: list[Path] = [quest_root]
+        research_state = read_json(quest_root / ".ds" / "research_state.json", {})
+        if isinstance(research_state, dict):
+            for key in (
+                "research_head_worktree_root",
+                "current_workspace_root",
+                "analysis_parent_worktree_root",
+                "paper_parent_worktree_root",
+            ):
+                raw = str(research_state.get(key) or "").strip()
+                if raw:
+                    roots.append(Path(raw))
+        worktrees_root = quest_root / ".ds" / "worktrees"
+        if worktrees_root.exists():
+            roots.extend(path for path in sorted(worktrees_root.iterdir()) if path.is_dir())
+        deduped: list[Path] = []
+        seen: set[str] = set()
+        for root in roots:
+            key = str(root.resolve(strict=False))
+            if key in seen:
+                continue
+            seen.add(key)
+            deduped.append(root)
+        return deduped
+
+    @staticmethod
+    def _remove_baseline_materialization(root: Path, baseline_id: str) -> list[str]:
+        deleted_paths: list[str] = []
+        for candidate in (
+            root / "baselines" / "imported" / baseline_id,
+            root / "baselines" / "local" / baseline_id,
+        ):
+            if not candidate.exists():
+                continue
+            if candidate.is_dir():
+                shutil.rmtree(candidate)
+            else:
+                candidate.unlink()
+            deleted_paths.append(str(candidate))
+        return deleted_paths
+
     def _resolve_baseline_path(
         self,
         quest_root: Path,
@@ -1064,6 +1659,7 @@ class ArtifactService:
             "metric_contract": metric_contract,
             "primary_metric": entry.get("primary_metric"),
             "metrics_summary": metrics_summary,
+            "metric_details": entry.get("metric_details") or [],
         }
         json_path = ensure_dir(baseline_root / "json") / "metric_contract.json"
         write_json(json_path, payload)
@@ -1169,9 +1765,43 @@ class ArtifactService:
             "Use `artifact.confirm_baseline(...)` or `artifact.waive_baseline(...)` first."
         )
 
+    @staticmethod
+    def _artifact_record_identity(path: Path, payload: dict[str, Any], *, kind: str | None = None) -> str:
+        normalized_kind = str(kind or payload.get("kind") or path.parent.name or "artifact").strip() or "artifact"
+        branch_name = str(payload.get("branch") or "").strip()
+        run_id = str(payload.get("run_id") or "").strip()
+        if normalized_kind == "run" and run_id and branch_name:
+            return f"{normalized_kind}:branch_run:{branch_name}:{run_id}"
+        artifact_id = str(payload.get("artifact_id") or payload.get("id") or "").strip()
+        if artifact_id:
+            return f"{normalized_kind}:artifact:{artifact_id}"
+        if normalized_kind == "run" and run_id:
+            return f"{normalized_kind}:run:{run_id}"
+        idea_id = str(payload.get("idea_id") or "").strip()
+        if normalized_kind == "idea" and idea_id and branch_name:
+            return f"{normalized_kind}:branch_idea:{branch_name}:{idea_id}"
+        if normalized_kind == "idea" and idea_id:
+            return f"{normalized_kind}:idea:{idea_id}"
+        baseline_id = str(payload.get("baseline_id") or payload.get("entry_id") or "").strip()
+        if baseline_id:
+            return f"{normalized_kind}:baseline:{baseline_id}"
+        interaction_id = str(payload.get("interaction_id") or "").strip()
+        if interaction_id:
+            return f"{normalized_kind}:interaction:{interaction_id}"
+        return f"path:{path.resolve()}"
+
+    @staticmethod
+    def _artifact_record_rank(payload: dict[str, Any], *, path: Path, mtime_ns: int) -> tuple[str, str, int, int, str]:
+        return (
+            str(payload.get("updated_at") or ""),
+            str(payload.get("created_at") or ""),
+            len(payload),
+            mtime_ns,
+            str(path),
+        )
+
     def _main_run_artifacts(self, quest_root: Path) -> list[dict[str, Any]]:
-        records: list[dict[str, Any]] = []
-        seen_paths: set[str] = set()
+        records_by_identity: dict[str, dict[str, Any]] = {}
         for root in self.quest_service.workspace_roots(quest_root):
             artifacts_root = root / "artifacts" / "runs"
             if not artifacts_root.exists():
@@ -1179,10 +1809,6 @@ class ArtifactService:
             for path in sorted(artifacts_root.glob("*.json")):
                 if not path.is_file():
                     continue
-                key = str(path.resolve())
-                if key in seen_paths:
-                    continue
-                seen_paths.add(key)
                 payload = read_json(path, {})
                 if not isinstance(payload, dict) or not payload:
                     continue
@@ -1194,7 +1820,19 @@ class ArtifactService:
                     enriched["_artifact_mtime_ns"] = path.stat().st_mtime_ns
                 except OSError:
                     enriched["_artifact_mtime_ns"] = 0
-                records.append(enriched)
+                identity = self._artifact_record_identity(path, enriched, kind="run")
+                existing = records_by_identity.get(identity)
+                if existing is None or self._artifact_record_rank(
+                    enriched,
+                    path=path,
+                    mtime_ns=int(enriched.get("_artifact_mtime_ns") or 0),
+                ) >= self._artifact_record_rank(
+                    existing,
+                    path=Path(str(existing.get("_artifact_path") or path)),
+                    mtime_ns=int(existing.get("_artifact_mtime_ns") or 0),
+                ):
+                    records_by_identity[identity] = enriched
+        records = list(records_by_identity.values())
         records.sort(
             key=lambda item: (
                 str(item.get("updated_at") or item.get("created_at") or ""),
@@ -1277,6 +1915,173 @@ class ArtifactService:
                 continue
         return None
 
+    def _branch_activation_worktree_root(
+        self,
+        quest_root: Path,
+        *,
+        branch_name: str,
+        idea_id: str | None = None,
+        run_id: str | None = None,
+    ) -> Path:
+        normalized_branch = str(branch_name or "").strip()
+        branch_kind = self._branch_kind_from_name(normalized_branch)
+        normalized_idea_id = str(idea_id or "").strip() or None
+        if branch_kind == "paper":
+            normalized_run_id = str(run_id or "").strip() or None
+            return canonical_worktree_root(
+                quest_root,
+                f"paper-{normalized_run_id or slugify(normalized_branch, 'paper')}",
+            )
+        if normalized_idea_id and branch_kind == "idea":
+            return canonical_worktree_root(quest_root, f"idea-{normalized_idea_id}")
+        normalized_run_id = str(run_id or "").strip() or None
+        if normalized_run_id and branch_kind == "run":
+            return canonical_worktree_root(quest_root, normalized_run_id)
+        return canonical_worktree_root(quest_root, f"branch-{slugify(normalized_branch, 'branch')}")
+
+    @staticmethod
+    def _resolve_activate_branch_anchor(
+        *,
+        anchor: str | None,
+        has_idea: bool,
+        has_main_result: bool,
+    ) -> str:
+        normalized_anchor = str(anchor or "auto").strip().lower() or "auto"
+        if normalized_anchor == "auto":
+            if has_main_result:
+                return "decision"
+            if has_idea:
+                return "experiment"
+            return "idea"
+        aliases = {
+            "analysis": "analysis-campaign",
+        }
+        resolved_anchor = aliases.get(normalized_anchor, normalized_anchor)
+        allowed = {
+            "scout",
+            "baseline",
+            "idea",
+            "experiment",
+            "analysis-campaign",
+            "write",
+            "finalize",
+            "decision",
+        }
+        if resolved_anchor not in allowed:
+            allowed_text = ", ".join(sorted(allowed | {"auto"}))
+            raise ValueError(f"Unsupported activate_branch anchor `{anchor}`. Allowed values: {allowed_text}.")
+        return resolved_anchor
+
+    def _resolve_branch_activation_target(
+        self,
+        quest_root: Path,
+        *,
+        branch: str | None = None,
+        idea_id: str | None = None,
+        run_id: str | None = None,
+    ) -> dict[str, Any]:
+        provided = sum(
+            1
+            for value in (
+                str(branch or "").strip(),
+                str(idea_id or "").strip(),
+                str(run_id or "").strip(),
+            )
+            if value
+        )
+        if provided != 1:
+            raise ValueError("activate_branch requires exactly one of `branch`, `idea_id`, or `run_id`.")
+
+        latest_idea: dict[str, Any] | None = None
+        latest_run: dict[str, Any] | None = None
+        normalized_branch = str(branch or "").strip()
+        normalized_idea_id = str(idea_id or "").strip()
+        normalized_run_id = str(run_id or "").strip()
+
+        if normalized_idea_id:
+            candidates = [
+                item for item in self._idea_artifacts(quest_root) if str(item.get("idea_id") or "").strip() == normalized_idea_id
+            ]
+            if not candidates:
+                raise FileNotFoundError(f"Unknown idea `{normalized_idea_id}`.")
+            latest_idea = candidates[-1]
+            normalized_branch = str(latest_idea.get("branch") or "").strip()
+        elif normalized_run_id:
+            candidates = [
+                item for item in self._main_run_artifacts(quest_root) if str(item.get("run_id") or "").strip() == normalized_run_id
+            ]
+            if not candidates:
+                raise FileNotFoundError(f"Unknown main run `{normalized_run_id}`.")
+            latest_run = candidates[-1]
+            normalized_branch = str(latest_run.get("branch") or "").strip()
+        else:
+            if normalized_branch.startswith("analysis/"):
+                raise ValueError(
+                    "activate_branch only supports durable idea/main branches. "
+                    "Analysis slice branches remain managed by analysis campaigns."
+                )
+            if not branch_exists(quest_root, normalized_branch):
+                raise FileNotFoundError(f"Unknown branch `{normalized_branch}`.")
+
+        if not normalized_branch:
+            raise ValueError("Unable to resolve a durable branch to activate.")
+
+        prepare_record = self._latest_prepare_branch_record(quest_root, normalized_branch)
+        prepare_details = dict(prepare_record.get("details") or {}) if isinstance(prepare_record.get("details"), dict) else {}
+        recorded_parent_branch = (
+            str(prepare_record.get("parent_branch") or prepare_details.get("parent_branch") or "").strip() or None
+        )
+        recorded_branch_kind = (
+            str(prepare_record.get("branch_kind") or prepare_details.get("branch_kind") or "").strip().lower()
+            or self._branch_kind_from_name(normalized_branch)
+        )
+
+        latest_idea = latest_idea or self._latest_idea_for_branch(quest_root, normalized_branch)
+        latest_run = latest_run or self._latest_main_run_for_branch(quest_root, normalized_branch)
+        if not latest_run and recorded_branch_kind == "idea":
+            latest_run = self._latest_child_main_run_for_branch(quest_root, normalized_branch)
+        if not latest_run and recorded_parent_branch:
+            latest_run = self._latest_main_run_for_branch(quest_root, recorded_parent_branch)
+        resolved_idea_id = (
+            normalized_idea_id
+            or str((latest_run or {}).get("idea_id") or "").strip()
+            or str((latest_idea or {}).get("idea_id") or "").strip()
+            or str(prepare_record.get("idea_id") or "").strip()
+            or self._latest_branch_idea_id(quest_root, normalized_branch)
+            or None
+        )
+        idea_paths = dict((latest_idea or {}).get("paths") or {}) if isinstance((latest_idea or {}).get("paths"), dict) else {}
+        recorded_root = (
+            str((latest_idea or {}).get("worktree_root") or "").strip()
+            or str((latest_run or {}).get("worktree_root") or "").strip()
+            or str(prepare_record.get("worktree_root") or "").strip()
+            or None
+        )
+        return {
+            "branch": normalized_branch,
+            "idea_id": resolved_idea_id,
+            "run_id": normalized_run_id or str((latest_run or {}).get("run_id") or "").strip() or None,
+            "has_main_result": bool((latest_run or {}).get("run_id")),
+            "latest_idea": latest_idea,
+            "latest_main_run": latest_run,
+            "branch_kind": recorded_branch_kind,
+            "parent_branch": recorded_parent_branch,
+            "recorded_worktree_root": recorded_root,
+            "idea_md_path": str(idea_paths.get("idea_md") or "").strip() or None,
+            "idea_draft_path": str(idea_paths.get("idea_draft_md") or "").strip() or None,
+            "suggested_worktree_root": self._branch_activation_worktree_root(
+                quest_root,
+                branch_name=normalized_branch,
+                idea_id=resolved_idea_id,
+                run_id=(
+                    normalized_run_id
+                    or str(prepare_record.get("run_id") or "").strip()
+                    or str((latest_run or {}).get("run_id") or "").strip()
+                    or None
+                ),
+            ),
+        }
+
     def _normalize_foundation_ref(self, foundation_ref: dict[str, Any] | str | None) -> dict[str, Any]:
         if foundation_ref is None:
             return {"kind": "current_head", "ref": None}
@@ -1445,6 +2250,17 @@ class ArtifactService:
         ]
         return candidates[-1] if candidates else None
 
+    def _latest_child_main_run_for_branch(self, quest_root: Path, branch_name: str) -> dict[str, Any] | None:
+        normalized_branch = str(branch_name or "").strip()
+        if not normalized_branch:
+            return None
+        candidates = [
+            item
+            for item in self._main_run_artifacts(quest_root)
+            if str(item.get("parent_branch") or "").strip() == normalized_branch
+        ]
+        return candidates[-1] if candidates else None
+
     def _latest_idea_for_branch(self, quest_root: Path, branch_name: str) -> dict[str, Any] | None:
         normalized_branch = str(branch_name or "").strip()
         if not normalized_branch:
@@ -1506,8 +2322,19 @@ class ArtifactService:
     ) -> 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()
+        paper_parent_root_raw = str(state.get("paper_parent_worktree_root") or "").strip()
+        current_branch_raw = str(state.get("current_workspace_branch") or "").strip()
+        research_head_branch_raw = str(state.get("research_head_branch") or "").strip()
+        paper_parent_branch_raw = str(state.get("paper_parent_branch") or "").strip()
+        workspace_mode = str(state.get("workspace_mode") or "").strip().lower()
+        prefer_paper_parent = workspace_mode == "paper" or self._branch_kind_from_name(current_branch_raw) == "paper"
         parent_worktree_root: Path | None = None
-        for raw in (current_root_raw, head_root_raw):
+        root_candidates = (
+            (paper_parent_root_raw, head_root_raw, current_root_raw)
+            if prefer_paper_parent
+            else (current_root_raw, head_root_raw, paper_parent_root_raw)
+        )
+        for raw in root_candidates:
             if not raw:
                 continue
             candidate = Path(raw)
@@ -1518,15 +2345,36 @@ class ArtifactService:
             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))
+            (
+                paper_parent_branch_raw
+                or research_head_branch_raw
+                or current_branch_raw
+                or current_branch(parent_worktree_root)
+                or current_branch(self._workspace_root_for(quest_root))
+            )
+            if prefer_paper_parent
+            else (
+                current_branch_raw
+                or research_head_branch_raw
+                or paper_parent_branch_raw
+                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.")
 
+        if self._branch_kind_from_name(parent_branch) == "idea":
+            latest_child_run = self._latest_child_main_run_for_branch(quest_root, parent_branch)
+            if isinstance(latest_child_run, dict) and str(latest_child_run.get("branch") or "").strip():
+                parent_branch = str(latest_child_run.get("branch") or "").strip()
+                recorded_worktree_root = str(latest_child_run.get("worktree_root") or "").strip()
+                if recorded_worktree_root:
+                    candidate = Path(recorded_worktree_root)
+                    if candidate.exists():
+                        parent_worktree_root = candidate
+
         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
 
@@ -1568,15 +2416,22 @@ class ArtifactService:
                 state=state,
                 foundation_ref={"kind": "idea", "ref": str(latest_idea.get("idea_id") or "").strip()},
             )
+        current_workspace_branch = str(state.get("current_workspace_branch") or "").strip()
+        research_head_branch = str(state.get("research_head_branch") or "").strip()
         active_branch = (
-            str(state.get("research_head_branch") or "").strip()
-            or str(state.get("current_workspace_branch") or "").strip()
+            current_workspace_branch
+            or research_head_branch
+            or current_branch(self._workspace_root_for(quest_root))
         )
         if normalized_branch and active_branch and normalized_branch == active_branch:
             return self._resolve_idea_foundation(
                 quest_root,
                 state=state,
-                foundation_ref=None,
+                foundation_ref=(
+                    {"kind": "branch", "ref": normalized_branch}
+                    if current_workspace_branch and research_head_branch and current_workspace_branch != research_head_branch
+                    else None
+                ),
             )
         return self._resolve_idea_foundation(
             quest_root,
@@ -1614,8 +2469,8 @@ class ArtifactService:
     ) -> tuple[str, str, dict[str, Any]]:
         normalized_intent = self._normalize_lineage_intent(lineage_intent) or "continue_line"
         active_branch = (
-            str(state.get("research_head_branch") or "").strip()
-            or str(state.get("current_workspace_branch") or "").strip()
+            str(state.get("current_workspace_branch") or "").strip()
+            or str(state.get("research_head_branch") or "").strip()
         )
         if not active_branch:
             active_branch = current_branch(self._workspace_root_for(quest_root))
@@ -1643,6 +2498,7 @@ class ArtifactService:
     def list_research_branches(self, quest_root: Path) -> dict[str, Any]:
         state = self.quest_service.read_research_state(quest_root)
         active_head_branch = str(state.get("research_head_branch") or "").strip() or None
+        active_workspace_branch = str(state.get("current_workspace_branch") or "").strip() or None
         idea_records = self._idea_artifacts(quest_root)
         main_runs = self._main_run_artifacts(quest_root)
 
@@ -1709,6 +2565,7 @@ class ArtifactService:
                     "verdict": record.get("verdict"),
                     "status": record.get("status"),
                     "idea_id": record.get("idea_id"),
+                    "parent_branch": record.get("parent_branch"),
                     "primary_metric_id": details.get("primary_metric_id"),
                     "primary_value": details.get("primary_value"),
                     "delta_vs_baseline": details.get("delta_vs_baseline"),
@@ -1721,6 +2578,8 @@ class ArtifactService:
 
         if active_head_branch:
             ensure_branch_entry(active_head_branch)
+        if active_workspace_branch:
+            ensure_branch_entry(active_workspace_branch)
 
         ordered_branches = sorted(
             grouped.values(),
@@ -1756,10 +2615,15 @@ class ArtifactService:
                 else {}
             )
             parent_branch = str(latest_idea.get("parent_branch") or "").strip() or None
+            experiment_parent_branch = (
+                str((latest_experiment or {}).get("parent_branch") or "").strip()
+                if isinstance(latest_experiment, dict)
+                else None
+            ) or None
             foundation_branch = (
                 str(latest_foundation.get("branch") or latest_foundation.get("ref") or "").strip() or None
             )
-            resolved_parent_branch = parent_branch or foundation_branch
+            resolved_parent_branch = parent_branch or experiment_parent_branch or foundation_branch
             has_main_result = isinstance(latest_experiment, dict) and bool(latest_experiment.get("run_id"))
             numeric_branch_no = recorded_branch_numbers.get(branch_name)
             if numeric_branch_no is None:
@@ -1774,7 +2638,8 @@ class ArtifactService:
                     "branch_name": branch_name,
                     "worktree_root": item.get("worktree_root"),
                     "is_active_head": branch_name == active_head_branch,
-                    "idea_id": latest_idea.get("idea_id"),
+                    "is_active_workspace": branch_name == active_workspace_branch,
+                    "idea_id": latest_idea.get("idea_id") or (latest_experiment.get("idea_id") if isinstance(latest_experiment, dict) else None),
                     "idea_title": latest_idea.get("title"),
                     "idea_problem": latest_idea.get("problem"),
                     "next_target": latest_idea.get("next_target"),
@@ -1810,6 +2675,7 @@ class ArtifactService:
         return {
             "ok": True,
             "active_head_branch": active_head_branch,
+            "active_workspace_branch": active_workspace_branch,
             "count": len(branches),
             "branches": branches,
         }
@@ -1819,9 +2685,10 @@ class ArtifactService:
         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
+        paper_parent_branch = str(state.get("paper_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
+        canonical_branch = analysis_parent_branch or paper_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 {}
@@ -1888,32 +2755,82 @@ class ArtifactService:
         }
 
     def list_paper_outlines(self, quest_root: Path) -> dict[str, Any]:
-        selected_outline = read_json(self._paper_selected_outline_path(quest_root), {})
+        selected_outline_path = self._paper_selected_outline_path(quest_root)
+        selected_outline = read_json(selected_outline_path, {})
         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:
+        if not selected_outline:
+            fallback_selected_outline_path = quest_root / "paper" / "selected_outline.json"
+            fallback_selected_outline = read_json(fallback_selected_outline_path, {})
+            if isinstance(fallback_selected_outline, dict) and fallback_selected_outline:
+                selected_outline = fallback_selected_outline
+                selected_outline_path = fallback_selected_outline_path
+
+        selected_outline_id = str(selected_outline.get("outline_id") or "").strip()
+        status_rank = {"candidate": 1, "revised": 2, "selected": 3}
+        outlines_by_id: dict[str, dict[str, Any]] = {}
+        seen_paper_roots: set[str] = set()
+        paper_roots: list[Path] = []
+        for root in (self._paper_root(quest_root), quest_root / "paper"):
+            try:
+                key = str(root.resolve())
+            except FileNotFoundError:
+                key = str(root)
+            if key in seen_paper_roots:
+                continue
+            seen_paper_roots.add(key)
+            paper_roots.append(root)
+
+        for paper_root in paper_roots:
+            for default_status, relative_parts in (
+                ("candidate", ("outlines", "candidates")),
+                ("revised", ("outlines", "revisions")),
+            ):
+                root = paper_root.joinpath(*relative_parts)
+                if not root.exists():
                     continue
-                outline_id = str(record.get("outline_id") or path.stem).strip() or path.stem
-                outlines.append(
-                    {
+                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
+                    item = {
                         "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,
+                        "status": str(record.get("status") or default_status).strip() or default_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(),
+                        "is_selected": outline_id == selected_outline_id,
                     }
-                )
+                    current = outlines_by_id.get(outline_id)
+                    if current is None or status_rank.get(str(item.get("status") or ""), 0) >= status_rank.get(
+                        str(current.get("status") or ""),
+                        0,
+                    ):
+                        outlines_by_id[outline_id] = item
+
+        if selected_outline_id:
+            selected_item = {
+                "outline_id": selected_outline_id,
+                "title": str(selected_outline.get("title") or selected_outline_id).strip() or selected_outline_id,
+                "status": str(selected_outline.get("status") or "selected").strip() or "selected",
+                "review_result": str(selected_outline.get("review_result") or "").strip() or None,
+                "path": str(selected_outline_path),
+                "is_selected": True,
+            }
+            current = outlines_by_id.get(selected_outline_id)
+            if current is None or status_rank.get(str(selected_item.get("status") or ""), 0) >= status_rank.get(
+                str(current.get("status") or ""),
+                0,
+            ):
+                outlines_by_id[selected_outline_id] = selected_item
+            else:
+                current["is_selected"] = True
+
+        outlines = list(outlines_by_id.values())
         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_ref": selected_outline_id or None,
             "selected_outline": selected_outline or None,
             "count": len(outlines),
             "outlines": outlines,
@@ -2139,65 +3056,438 @@ class ArtifactService:
         self._touch_quest_updated_at(quest_root)
         return {
             "ok": True,
-            "message": message,
-            "guidance": "Checkpoint created. Continue from the updated quest branch state.",
-            **result,
+            "message": message,
+            "guidance": "Checkpoint created. Continue from the updated quest branch state.",
+            **result,
+        }
+
+    def prepare_branch(
+        self,
+        quest_root: Path,
+        *,
+        run_id: str | None = None,
+        idea_id: str | None = None,
+        branch: str | None = None,
+        branch_kind: str = "run",
+        create_worktree_flag: bool = True,
+        start_point: str | None = None,
+    ) -> dict:
+        state = self.quest_service.read_research_state(quest_root)
+        parent_branch = (
+            str(start_point or "").strip()
+            or str(state.get("current_workspace_branch") or "").strip()
+            or str(state.get("research_head_branch") or "").strip()
+            or current_branch(self._workspace_root_for(quest_root))
+            or current_branch(quest_root)
+        )
+        start_ref = start_point or parent_branch
+        branch_name = branch or self._default_branch_name(quest_root, run_id=run_id, idea_id=idea_id, branch_kind=branch_kind)
+        branch_result = ensure_branch(quest_root, branch_name, start_point=start_ref, checkout=False)
+        worktree_result = None
+        worktree_root = None
+        if create_worktree_flag:
+            worktree_root = self._prepare_branch_worktree_root(
+                quest_root,
+                branch_name=branch_name,
+                branch_kind=branch_kind,
+                run_id=run_id,
+                idea_id=idea_id,
+            )
+            worktree_result = create_worktree(
+                quest_root,
+                branch=branch_name,
+                worktree_root=worktree_root,
+                start_point=start_ref,
+            )
+        artifact_result = self.record(
+            quest_root,
+            {
+                "kind": "decision",
+                "status": "prepared",
+                "verdict": "prepared",
+                "action": "prepare_branch",
+                "reason": f"Prepared branch `{branch_name}` for the next quest step.",
+                "branch": branch_name,
+                "run_id": run_id,
+                "idea_id": idea_id,
+                "branch_kind": branch_kind,
+                "parent_branch": parent_branch,
+                "start_point": start_ref,
+                "worktree_root": str(worktree_root) if worktree_root else None,
+                "workspace_mode": self._workspace_mode_for_branch(branch_name, has_idea=bool(idea_id)),
+                "source": {"kind": "system", "role": "artifact"},
+            },
+            checkpoint=False,
+            workspace_root=worktree_root if worktree_root else None,
+        )
+        return {
+            "ok": True,
+            "branch": branch_name,
+            "branch_result": branch_result,
+            "worktree": worktree_result,
+            "worktree_root": str(worktree_root) if worktree_root else None,
+            "parent_branch": parent_branch,
+            "start_point": start_ref,
+            "guidance": "Use this branch/worktree for the isolated idea or run. Keep durable outputs under quest_root.",
+            "artifact": artifact_result,
+        }
+
+    def activate_branch(
+        self,
+        quest_root: Path,
+        *,
+        branch: str | None = None,
+        idea_id: str | None = None,
+        run_id: str | None = None,
+        anchor: str | None = "auto",
+        promote_to_head: bool = False,
+        create_worktree_if_missing: bool = True,
+    ) -> dict[str, Any]:
+        state = self.quest_service.read_research_state(quest_root)
+        active_campaign_id = str(state.get("active_analysis_campaign_id") or "").strip() or None
+        if active_campaign_id:
+            raise ValueError(
+                "activate_branch cannot run while an analysis campaign is active. "
+                "Finish or close the campaign first."
+            )
+
+        target = self._resolve_branch_activation_target(
+            quest_root,
+            branch=branch,
+            idea_id=idea_id,
+            run_id=run_id,
+        )
+        branch_name = str(target.get("branch") or "").strip()
+        if str(target.get("branch_kind") or self._branch_kind_from_name(branch_name)).strip().lower() != "paper":
+            self._require_baseline_gate_open(quest_root, action="activate_branch")
+        resolved_idea_id = str(target.get("idea_id") or "").strip() or None
+        latest_main_run = (
+            dict(target.get("latest_main_run") or {})
+            if isinstance(target.get("latest_main_run"), dict)
+            else {}
+        )
+        latest_idea = (
+            dict(target.get("latest_idea") or {})
+            if isinstance(target.get("latest_idea"), dict)
+            else {}
+        )
+        branch_kind = str(target.get("branch_kind") or self._branch_kind_from_name(branch_name)).strip().lower() or "branch"
+        source_parent_branch = str(target.get("parent_branch") or "").strip() or None
+
+        workspace_root = self._branch_workspace_root(quest_root, branch_name)
+        worktree_result = None
+        worktree_created = False
+        if workspace_root is None:
+            recorded_root = str(target.get("recorded_worktree_root") or "").strip()
+            if recorded_root:
+                candidate = Path(recorded_root)
+                if candidate.exists():
+                    workspace_root = candidate
+            if workspace_root is None:
+                if not create_worktree_if_missing:
+                    raise FileNotFoundError(
+                        f"No existing worktree is available for branch `{branch_name}` and create_worktree_if_missing=False."
+                    )
+                workspace_root = Path(target.get("suggested_worktree_root") or "")
+                worktree_result = create_worktree(
+                    quest_root,
+                    branch=branch_name,
+                    worktree_root=workspace_root,
+                    start_point=branch_name,
+                )
+                if not bool(worktree_result.get("ok")):
+                    raise RuntimeError(
+                        f"Failed to activate branch `{branch_name}`: {worktree_result.get('stderr') or 'worktree creation failed.'}"
+                    )
+                worktree_created = True
+
+        resolved_workspace_root = workspace_root or quest_root
+        idea_md_path = (
+            str(target.get("idea_md_path") or "").strip()
+            or str((dict(latest_idea.get("paths") or {}) if isinstance(latest_idea.get("paths"), dict) else {}).get("idea_md") or "").strip()
+            or (str(resolved_workspace_root / "memory" / "ideas" / resolved_idea_id / "idea.md") if resolved_idea_id else "")
+        )
+        idea_draft_path = (
+            str(target.get("idea_draft_path") or "").strip()
+            or str((dict(latest_idea.get("paths") or {}) if isinstance(latest_idea.get("paths"), dict) else {}).get("idea_draft_md") or "").strip()
+            or (str(resolved_workspace_root / "memory" / "ideas" / resolved_idea_id / "draft.md") if resolved_idea_id else "")
+        )
+        resolved_idea_md_path = idea_md_path if resolved_idea_id else None
+        resolved_idea_draft_path = idea_draft_path if resolved_idea_id else None
+        has_main_result = bool(latest_main_run.get("run_id"))
+        if branch_kind == "paper":
+            next_anchor = "write" if str(anchor or "auto").strip().lower() == "auto" else self._resolve_activate_branch_anchor(
+                anchor=anchor,
+                has_idea=bool(resolved_idea_id),
+                has_main_result=has_main_result,
+            )
+        else:
+            next_anchor = self._resolve_activate_branch_anchor(
+                anchor=anchor,
+                has_idea=bool(resolved_idea_id),
+                has_main_result=has_main_result,
+            )
+        workspace_mode = self._workspace_mode_for_branch(branch_name, has_idea=bool(resolved_idea_id))
+        source_run_id = (
+            str(target.get("run_id") or "").strip()
+            or str(latest_main_run.get("run_id") or "").strip()
+            or None
+        )
+
+        artifact = self.record(
+            quest_root,
+            {
+                "kind": "decision",
+                "status": "completed",
+                "verdict": "continue",
+                "action": "activate_branch",
+                "summary": f"Activated durable branch `{branch_name}` as the current workspace.",
+                "reason": (
+                    "Return to an existing research branch without creating a new lineage node, "
+                    "so follow-up experiments or decisions continue from the correct historical context."
+                ),
+                "idea_id": resolved_idea_id,
+                "run_id": str(latest_main_run.get("run_id") or "").strip() or None,
+                "branch": branch_name,
+                "worktree_root": str(resolved_workspace_root),
+                "worktree_rel_path": self._workspace_relative(quest_root, resolved_workspace_root),
+                "flow_type": "branch_activation",
+                "protocol_step": "activate",
+                "details": {
+                    "activate_branch_by": (
+                        "idea_id"
+                        if str(idea_id or "").strip()
+                        else "run_id"
+                        if str(run_id or "").strip()
+                        else "branch"
+                    ),
+                    "promote_to_head": bool(promote_to_head),
+                    "worktree_created": worktree_created,
+                    "next_anchor": next_anchor,
+                    "workspace_mode": workspace_mode,
+                    "latest_main_run_id": str(latest_main_run.get("run_id") or "").strip() or None,
+                    "branch_kind": branch_kind,
+                    "paper_parent_branch": source_parent_branch if branch_kind == "paper" else None,
+                },
+            },
+            checkpoint=False,
+            workspace_root=resolved_workspace_root,
+        )
+
+        research_state_updates: dict[str, Any] = {
+            "active_idea_id": resolved_idea_id,
+            "current_workspace_branch": branch_name,
+            "current_workspace_root": str(resolved_workspace_root),
+            "active_idea_md_path": resolved_idea_md_path,
+            "active_idea_draft_path": resolved_idea_draft_path,
+            "active_analysis_campaign_id": None,
+            "analysis_parent_branch": None,
+            "analysis_parent_worktree_root": None,
+            "paper_parent_branch": source_parent_branch if branch_kind == "paper" else None,
+            "paper_parent_worktree_root": (
+                str(self._branch_workspace_root(quest_root, source_parent_branch))
+                if branch_kind == "paper" and source_parent_branch and self._branch_workspace_root(quest_root, source_parent_branch)
+                else None
+            ),
+            "paper_parent_run_id": source_run_id if branch_kind == "paper" else None,
+            "next_pending_slice_id": None,
+            "workspace_mode": workspace_mode,
+            "last_flow_type": "branch_activation",
+        }
+        if promote_to_head:
+            research_state_updates["research_head_branch"] = branch_name
+            research_state_updates["research_head_worktree_root"] = str(resolved_workspace_root)
+        research_state = self.quest_service.update_research_state(quest_root, **research_state_updates)
+        self.quest_service.update_settings(self._quest_id(quest_root), active_anchor=next_anchor)
+
+        interaction = self.interact(
+            quest_root,
+            kind="milestone",
+            message=(
+                f"Activated branch `{branch_name}`.\n"
+                f"- Worktree: `{resolved_workspace_root}`\n"
+                f"- Active idea: `{resolved_idea_id or 'none'}`\n"
+                f"- Latest main run: `{str(latest_main_run.get('run_id') or '').strip() or 'none'}`\n"
+                f"- Promoted to head: `{bool(promote_to_head)}`\n"
+                f"- Next anchor: `{next_anchor}`"
+            ),
+            deliver_to_bound_conversations=True,
+            include_recent_inbound_messages=False,
+            attachments=[
+                {
+                    "kind": "branch_activation",
+                    "branch": branch_name,
+                    "worktree_root": str(resolved_workspace_root),
+                    "idea_id": resolved_idea_id,
+                    "latest_main_run_id": str(latest_main_run.get("run_id") or "").strip() or None,
+                    "next_anchor": next_anchor,
+                    "promote_to_head": bool(promote_to_head),
+                }
+            ],
+        )
+        return {
+            "ok": True,
+            "branch": branch_name,
+            "worktree_root": str(resolved_workspace_root),
+            "idea_id": resolved_idea_id,
+            "latest_main_run_id": str(latest_main_run.get("run_id") or "").strip() or None,
+            "branch_kind": branch_kind,
+            "source_parent_branch": source_parent_branch,
+            "idea_md_path": resolved_idea_md_path,
+            "idea_draft_path": resolved_idea_draft_path,
+            "workspace_mode": workspace_mode,
+            "next_anchor": next_anchor,
+            "promote_to_head": bool(promote_to_head),
+            "worktree_created": worktree_created,
+            "worktree": worktree_result,
+            "artifact": artifact,
+            "interaction": interaction,
+            "research_state": research_state,
         }
 
-    def prepare_branch(
+    def _promote_workspace_to_run_branch(
         self,
         quest_root: Path,
         *,
-        run_id: str | None = None,
-        idea_id: str | None = None,
-        branch: str | None = None,
-        branch_kind: str = "run",
-        create_worktree_flag: bool = True,
-        start_point: str | None = None,
-    ) -> dict:
-        parent_branch = current_branch(quest_root)
-        start_ref = start_point or parent_branch
-        branch_name = branch or self._default_branch_name(quest_root, run_id=run_id, idea_id=idea_id, branch_kind=branch_kind)
-        branch_result = ensure_branch(quest_root, branch_name, start_point=start_ref, checkout=False)
-        worktree_result = None
-        worktree_root = None
-        if create_worktree_flag:
-            worktree_root = canonical_worktree_root(quest_root, run_id or branch_name)
-            worktree_result = create_worktree(
-                quest_root,
-                branch=branch_name,
-                worktree_root=worktree_root,
-                start_point=start_ref,
+        run_id: str,
+        idea_id: str | None,
+        workspace_root: Path,
+        current_branch_name: str,
+    ) -> tuple[str, str | None, bool]:
+        branch_kind = self._branch_kind_from_name(current_branch_name)
+        if branch_kind == "paper":
+            raise ValueError(
+                "record_main_experiment cannot run while the active workspace is a paper branch. "
+                "Return to the evidence branch or create a new run branch first."
             )
-        artifact_result = self.record(
+        if branch_kind == "run":
+            prepare_record = self._latest_prepare_branch_record(quest_root, current_branch_name)
+            parent_branch = str(prepare_record.get("parent_branch") or "").strip() or None
+            return current_branch_name, parent_branch, False
+
+        target_branch = self._default_branch_name(quest_root, run_id=run_id, idea_id=idea_id, branch_kind="run")
+        if branch_exists(quest_root, target_branch):
+            raise ValueError(
+                f"Run branch `{target_branch}` already exists. Reuse that run branch or choose a new `run_id`."
+            )
+
+        ensure_branch(quest_root, target_branch, start_point=current_branch_name, checkout=False)
+        run_command(["git", "switch", target_branch], cwd=workspace_root, check=True)
+        self.record(
             quest_root,
             {
                 "kind": "decision",
                 "status": "prepared",
                 "verdict": "prepared",
                 "action": "prepare_branch",
-                "reason": f"Prepared branch `{branch_name}` for the next quest step.",
-                "branch": branch_name,
+                "reason": f"Materialized a dedicated main-experiment branch `{target_branch}` before durable recording.",
+                "branch": target_branch,
                 "run_id": run_id,
                 "idea_id": idea_id,
-                "branch_kind": branch_kind,
-                "parent_branch": parent_branch,
-                "start_point": start_ref,
-                "worktree_root": str(worktree_root) if worktree_root else None,
+                "branch_kind": "run",
+                "parent_branch": current_branch_name,
+                "start_point": current_branch_name,
+                "worktree_root": str(workspace_root),
+                "workspace_mode": "run",
                 "source": {"kind": "system", "role": "artifact"},
             },
             checkpoint=False,
+            workspace_root=workspace_root,
+        )
+        self.quest_service.update_research_state(
+            quest_root,
+            active_idea_id=idea_id,
+            current_workspace_branch=target_branch,
+            current_workspace_root=str(workspace_root),
+            research_head_branch=target_branch,
+            research_head_worktree_root=str(workspace_root),
+            active_analysis_campaign_id=None,
+            analysis_parent_branch=None,
+            analysis_parent_worktree_root=None,
+            paper_parent_branch=None,
+            paper_parent_worktree_root=None,
+            paper_parent_run_id=None,
+            workspace_mode="run",
+            last_flow_type="main_experiment_branch",
+        )
+        return target_branch, current_branch_name, True
+
+    def _ensure_active_paper_workspace(
+        self,
+        quest_root: Path,
+        *,
+        source_branch: str | None = None,
+        source_run_id: str | None = None,
+        source_idea_id: str | None = None,
+    ) -> dict[str, Any]:
+        state = self.quest_service.read_research_state(quest_root)
+        current_branch_name = (
+            str(state.get("current_workspace_branch") or "").strip()
+            or current_branch(self._workspace_root_for(quest_root))
+        )
+        current_workspace_root = self._workspace_root_for(quest_root)
+        if (
+            str(state.get("workspace_mode") or "").strip() == "paper"
+            and self._branch_kind_from_name(current_branch_name) == "paper"
+        ):
+            return {
+                "ok": True,
+                "branch": current_branch_name,
+                "worktree_root": str(current_workspace_root),
+                "source_branch": str(state.get("paper_parent_branch") or "").strip() or None,
+                "source_run_id": str(state.get("paper_parent_run_id") or "").strip() or None,
+                "source_idea_id": str(state.get("active_idea_id") or "").strip() or None,
+            }
+
+        resolved_source_branch = (
+            str(source_branch or "").strip()
+            or str(state.get("paper_parent_branch") or "").strip()
+            or str(state.get("current_workspace_branch") or "").strip()
+            or str(state.get("research_head_branch") or "").strip()
+            or current_branch(current_workspace_root)
+        )
+        if not resolved_source_branch:
+            raise ValueError("Unable to resolve the source branch for the paper workspace.")
+
+        latest_main_run = self._latest_main_run_for_branch(quest_root, resolved_source_branch)
+        resolved_run_id = (
+            str(source_run_id or "").strip()
+            or str((latest_main_run or {}).get("run_id") or "").strip()
+            or None
+        )
+        resolved_idea_id = (
+            str(source_idea_id or "").strip()
+            or str((latest_main_run or {}).get("idea_id") or "").strip()
+            or str(state.get("active_idea_id") or "").strip()
+            or None
+        )
+        paper_branch = (
+            self._default_branch_name(quest_root, run_id=resolved_run_id, idea_id=resolved_idea_id, branch_kind="paper")
+            if resolved_run_id
+            else f"paper/{slugify(resolved_source_branch, 'paper')}"
+        )
+        if not branch_exists(quest_root, paper_branch):
+            self.prepare_branch(
+                quest_root,
+                run_id=resolved_run_id,
+                idea_id=resolved_idea_id,
+                branch=paper_branch,
+                branch_kind="paper",
+                create_worktree_flag=True,
+                start_point=resolved_source_branch,
+            )
+        activated = self.activate_branch(
+            quest_root,
+            branch=paper_branch,
+            anchor="write",
+            promote_to_head=False,
+            create_worktree_if_missing=True,
         )
         return {
-            "ok": True,
-            "branch": branch_name,
-            "branch_result": branch_result,
-            "worktree": worktree_result,
-            "worktree_root": str(worktree_root) if worktree_root else None,
-            "parent_branch": parent_branch,
-            "start_point": start_ref,
-            "guidance": "Use this branch/worktree for the isolated idea or run. Keep durable outputs under quest_root.",
-            "artifact": artifact_result,
+            **activated,
+            "source_branch": resolved_source_branch,
+            "source_run_id": resolved_run_id,
+            "source_idea_id": resolved_idea_id,
         }
 
     def submit_idea(
@@ -2235,8 +3525,8 @@ class ArtifactService:
         if normalized_mode == "create":
             resolved_idea_id = str(idea_id or generate_id("idea")).strip()
             active_branch = (
-                str(state.get("research_head_branch") or "").strip()
-                or str(state.get("current_workspace_branch") or "").strip()
+                str(state.get("current_workspace_branch") or "").strip()
+                or str(state.get("research_head_branch") or "").strip()
                 or current_branch(self._workspace_root_for(quest_root))
             )
             active_parent_branch = self._idea_parent_branch(self._latest_idea_for_branch(quest_root, active_branch))
@@ -2376,19 +3666,26 @@ class ArtifactService:
                 worktree_root,
                 message=f"idea: create {resolved_idea_id}",
             )
+            idea_md_rel_path = self._workspace_relative(quest_root, idea_md_path)
+            idea_draft_rel_path = self._workspace_relative(quest_root, idea_draft_path)
             interaction = self.interact(
                 quest_root,
                 kind="milestone",
-                message=(
-                    f"Idea `{resolved_idea_id}` is now active.\n"
-                    f"- Branch no: `{branch_no}`\n"
-                    f"- Branch: `{branch_name}`\n"
-                    f"- Lineage: `{normalized_lineage_intent or 'manual'}`\n"
-                    f"- Foundation: `{foundation.get('label') or foundation.get('branch') or 'current head'}`\n"
-                    f"- Worktree: `{worktree_root}`\n"
-                    f"- Idea file: `{idea_md_path}`\n"
-                    f"- Draft file: `{idea_draft_path}`\n"
-                    f"- Next target: `{next_target}`"
+                message=self._build_idea_interaction_message(
+                    action="create",
+                    idea_id=resolved_idea_id,
+                    title=title,
+                    problem=problem,
+                    hypothesis=hypothesis,
+                    mechanism=mechanism,
+                    foundation_label=self._format_foundation_label(
+                        foundation,
+                        fallback=foundation.get("branch") or "current head",
+                    ),
+                    branch_name=branch_name,
+                    next_target=next_target,
+                    idea_md_rel_path=idea_md_rel_path,
+                    draft_md_rel_path=idea_draft_rel_path,
                 ),
                 deliver_to_bound_conversations=True,
                 include_recent_inbound_messages=False,
@@ -2441,9 +3738,17 @@ class ArtifactService:
             raise ValueError("submit_idea(mode='revise') requires an existing active `idea_id`.")
         if normalized_lineage_intent:
             raise ValueError("submit_idea(mode='revise') does not accept `lineage_intent`; use mode='create' for new branch lineage.")
-        branch_name = str(state.get("research_head_branch") or f"idea/{quest_id}-{resolved_idea_id}").strip()
+        branch_name = str(
+            state.get("current_workspace_branch")
+            or state.get("research_head_branch")
+            or f"idea/{quest_id}-{resolved_idea_id}"
+        ).strip()
         worktree_root = Path(
-            str(state.get("research_head_worktree_root") or canonical_worktree_root(quest_root, f"idea-{resolved_idea_id}"))
+            str(
+                state.get("current_workspace_root")
+                or state.get("research_head_worktree_root")
+                or canonical_worktree_root(quest_root, f"idea-{resolved_idea_id}")
+            )
         )
         ensure_dir(worktree_root / "memory" / "ideas" / resolved_idea_id)
         idea_md_path = worktree_root / "memory" / "ideas" / resolved_idea_id / "idea.md"
@@ -2545,34 +3850,48 @@ class ArtifactService:
             checkpoint=False,
             workspace_root=worktree_root,
         )
+        research_state_updates: dict[str, Any] = {
+            "active_idea_id": resolved_idea_id,
+            "current_workspace_branch": branch_name,
+            "current_workspace_root": str(worktree_root),
+            "active_idea_md_path": str(idea_md_path),
+            "active_idea_draft_path": str(idea_draft_path),
+            "workspace_mode": "idea",
+            "last_flow_type": "idea_revision",
+        }
+        current_head_branch = str(state.get("research_head_branch") or "").strip()
+        if not current_head_branch or current_head_branch == branch_name:
+            research_state_updates["research_head_branch"] = branch_name
+            research_state_updates["research_head_worktree_root"] = str(worktree_root)
         research_state = self.quest_service.update_research_state(
             quest_root,
-            active_idea_id=resolved_idea_id,
-            research_head_branch=branch_name,
-            research_head_worktree_root=str(worktree_root),
-            current_workspace_branch=branch_name,
-            current_workspace_root=str(worktree_root),
-            active_idea_md_path=str(idea_md_path),
-            active_idea_draft_path=str(idea_draft_path),
-            workspace_mode="idea",
-            last_flow_type="idea_revision",
+            **research_state_updates,
         )
         self.quest_service.update_settings(quest_id, active_anchor="experiment")
         checkpoint_result = self._checkpoint_with_optional_push(
             worktree_root,
             message=f"idea: revise {resolved_idea_id}",
         )
+        idea_md_rel_path = self._workspace_relative(quest_root, idea_md_path)
+        idea_draft_rel_path = self._workspace_relative(quest_root, idea_draft_path)
         interaction = self.interact(
             quest_root,
             kind="progress",
-            message=(
-                f"Idea `{resolved_idea_id}` was revised.\n"
-                f"- Branch: `{branch_name}`\n"
-                f"- Foundation: `{(existing_foundation_ref or {}).get('branch') or 'current head'}`\n"
-                f"- Worktree: `{worktree_root}`\n"
-                f"- Idea file: `{idea_md_path}`\n"
-                f"- Draft file: `{idea_draft_path}`\n"
-                f"- Next target: `{next_target}`"
+            message=self._build_idea_interaction_message(
+                action="revise",
+                idea_id=resolved_idea_id,
+                title=title,
+                problem=problem,
+                hypothesis=hypothesis,
+                mechanism=mechanism,
+                foundation_label=self._format_foundation_label(
+                    existing_foundation_ref,
+                    fallback=(existing_foundation_ref or {}).get("branch") or "current head",
+                ),
+                branch_name=branch_name,
+                next_target=next_target,
+                idea_md_rel_path=idea_md_rel_path,
+                draft_md_rel_path=idea_draft_rel_path,
             ),
             deliver_to_bound_conversations=True,
             include_recent_inbound_messages=False,
@@ -2712,14 +4031,21 @@ class ArtifactService:
         baseline_id: str | None = None,
         baseline_variant_id: str | None = None,
         evaluation_summary: dict[str, Any] | None = None,
+        strict_metric_contract: bool = False,
     ) -> dict[str, Any]:
         self._require_baseline_gate_open(quest_root, action="record_main_experiment")
         state = self.quest_service.read_research_state(quest_root)
-        if str(state.get("workspace_mode") or "").strip() == "analysis":
+        workspace_mode = str(state.get("workspace_mode") or "").strip()
+        if workspace_mode == "analysis":
             raise ValueError(
                 "record_main_experiment cannot run while the active workspace is an analysis slice. "
                 "Finish or close the analysis campaign first."
             )
+        if workspace_mode == "paper":
+            raise ValueError(
+                "record_main_experiment cannot run while the active workspace is a paper branch. "
+                "Return to the source evidence branch or create a new run branch first."
+            )
 
         run_identifier = str(run_id or "").strip()
         if not run_identifier:
@@ -2727,7 +4053,18 @@ class ArtifactService:
 
         active_idea_id = str(state.get("active_idea_id") or "").strip() or None
         workspace_root = self._workspace_root_for(quest_root)
-        branch_name = str(state.get("research_head_branch") or current_branch(workspace_root)).strip()
+        current_branch_name = str(
+            state.get("current_workspace_branch")
+            or state.get("research_head_branch")
+            or current_branch(workspace_root)
+        ).strip()
+        branch_name, parent_branch, auto_promoted_run_branch = self._promote_workspace_to_run_branch(
+            quest_root,
+            run_id=run_identifier,
+            idea_id=active_idea_id,
+            workspace_root=workspace_root,
+            current_branch_name=current_branch_name,
+        )
         attachment = self._active_baseline_attachment(quest_root, workspace_root=workspace_root)
         baseline_entry = dict(attachment.get("entry") or {}) if isinstance(attachment, dict) else {}
         selected_variant = dict(attachment.get("selected_variant") or {}) if isinstance(attachment, dict) else {}
@@ -2757,16 +4094,49 @@ class ArtifactService:
                 for item in normalized_metric_rows
                 if str(item.get("metric_id") or "").strip()
             }
-        effective_metric_contract = normalize_metric_contract(
-            metric_contract or baseline_entry.get("metric_contract"),
-            baseline_id=resolved_baseline_id,
-            metrics_summary=normalized_metrics_summary,
-            primary_metric=baseline_entry.get("primary_metric"),
-            baseline_variants=baseline_entry.get("baseline_variants"),
+        baseline_contract_payload = self._load_metric_contract_payload(quest_root, metric_contract_json_rel_path)
+        baseline_metric_contract = baseline_entry.get("metric_contract")
+        baseline_primary_metric = baseline_entry.get("primary_metric")
+        if isinstance(baseline_contract_payload, dict) and baseline_contract_payload:
+            payload_metric_contract = baseline_contract_payload.get("metric_contract")
+            if isinstance(payload_metric_contract, dict) and payload_metric_contract:
+                baseline_metric_contract = payload_metric_contract
+            payload_primary_metric = baseline_contract_payload.get("primary_metric")
+            if isinstance(payload_primary_metric, dict) and payload_primary_metric:
+                baseline_primary_metric = payload_primary_metric
+        effective_metric_contract = (
+            self._merge_run_metric_contract(
+                baseline_metric_contract=baseline_metric_contract,
+                baseline_primary_metric=baseline_primary_metric,
+                baseline_variants=baseline_entry.get("baseline_variants"),
+                run_metric_contract=metric_contract,
+                metrics_summary=normalized_metrics_summary,
+                metric_rows=normalized_metric_rows,
+                baseline_id=resolved_baseline_id,
+            )
+            if isinstance(baseline_metric_contract, dict) and baseline_metric_contract
+            else normalize_metric_contract(
+                metric_contract or baseline_entry.get("metric_contract"),
+                baseline_id=resolved_baseline_id,
+                metrics_summary=normalized_metrics_summary,
+                metric_rows=normalized_metric_rows,
+                primary_metric=baseline_primary_metric,
+                baseline_variants=baseline_entry.get("baseline_variants"),
+            )
         )
+        metric_validation: dict[str, Any] | None = None
+        if strict_metric_contract:
+            metric_validation = validate_main_experiment_against_baseline_contract(
+                baseline_contract_payload=baseline_contract_payload,
+                run_metric_contract=effective_metric_contract,
+                metric_rows=normalized_metric_rows,
+                metrics_summary=normalized_metrics_summary,
+                dataset_scope=dataset_scope,
+            )
         baseline_metrics = selected_baseline_metrics(baseline_entry, resolved_variant_id)
         comparisons = compare_with_baseline(
             metrics_summary=normalized_metrics_summary,
+            metric_rows=normalized_metric_rows,
             metric_contract=effective_metric_contract,
             baseline_metrics=baseline_metrics,
         )
@@ -2827,6 +4197,7 @@ class ArtifactService:
             "",
             f"- Run id: `{run_identifier}`",
             f"- Branch: `{branch_name}`",
+            f"- Parent branch: `{parent_branch or 'none'}`",
             f"- Worktree: `{workspace_root}`",
             f"- Idea: `{active_idea_id or 'none'}`",
             f"- Baseline: `{resolved_baseline_id or 'none'}`",
@@ -2924,6 +4295,7 @@ class ArtifactService:
             "verdict": verdict,
             "idea_id": active_idea_id,
             "branch": branch_name,
+            "parent_branch": parent_branch,
             "worktree_root": str(workspace_root),
             "head_commit": head_commit(workspace_root),
             "baseline_ref": {
@@ -2956,6 +4328,7 @@ class ArtifactService:
             "evidence_paths": resolved_evidence_paths,
             "files_changed": resolved_changed_files,
             "run_md_path": str(run_md_path),
+            "metric_validation": metric_validation,
         }
         write_json(result_json_path, result_payload)
 
@@ -2970,6 +4343,7 @@ class ArtifactService:
                 "reason": conclusion.strip() or progress_eval.get("reason") or "Main experiment result recorded.",
                 "idea_id": active_idea_id,
                 "branch": branch_name,
+                "parent_branch": parent_branch,
                 "worktree_root": str(workspace_root),
                 "worktree_rel_path": self._workspace_relative(quest_root, workspace_root),
                 "flow_type": "main_experiment",
@@ -2989,6 +4363,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"),
+                    "auto_promoted_run_branch": auto_promoted_run_branch,
                     "changed_file_count": len(resolved_changed_files),
                     "evidence_count": len(resolved_evidence_paths),
                     "evaluation_summary": normalized_evaluation_summary,
@@ -3008,6 +4383,7 @@ class ArtifactService:
                 },
                 "progress_eval": progress_eval,
                 "evaluation_summary": normalized_evaluation_summary,
+                "metric_validation": metric_validation,
                 "files_changed": resolved_changed_files,
                 "evidence_paths": resolved_evidence_paths,
                 "verdict": verdict,
@@ -3018,14 +4394,21 @@ class ArtifactService:
         interaction = self.interact(
             quest_root,
             kind="milestone",
-            message=(
-                f"Main experiment `{run_identifier}` has been recorded.\n"
-                f"- Branch: `{branch_name}`\n"
-                f"- Run log: `{run_md_path}`\n"
-                f"- Result: `{result_json_path}`\n"
-                f"- Verdict: `{verdict}`\n"
-                f"- Breakthrough: `{progress_eval.get('breakthrough_level')}`\n"
-                f"- Recommended next route: `{delivery_policy.get('recommended_next_route')}`"
+            message=self._build_main_experiment_interaction_message(
+                run_id=run_identifier,
+                branch_name=branch_name,
+                verdict=verdict,
+                primary_metric_id=primary_metric_id,
+                primary_value=primary_value,
+                primary_baseline=primary_baseline,
+                primary_delta=primary_delta,
+                decimals=decimals if isinstance(decimals, int) else None,
+                conclusion=conclusion.strip() or progress_eval.get("reason"),
+                evaluation_summary=normalized_evaluation_summary,
+                breakthrough_level=str(progress_eval.get("breakthrough_level") or "").strip() or None,
+                recommended_next_route=str(delivery_policy.get("recommended_next_route") or "").strip() or None,
+                run_md_rel_path=self._workspace_relative(quest_root, run_md_path),
+                result_json_rel_path=self._workspace_relative(quest_root, result_json_path),
             ),
             deliver_to_bound_conversations=True,
             include_recent_inbound_messages=False,
@@ -3049,6 +4432,22 @@ class ArtifactService:
             ],
         )
         self.quest_service.update_settings(self._quest_id(quest_root), active_anchor="decision")
+        research_state = self.quest_service.update_research_state(
+            quest_root,
+            active_idea_id=active_idea_id,
+            current_workspace_branch=branch_name,
+            current_workspace_root=str(workspace_root),
+            research_head_branch=branch_name,
+            research_head_worktree_root=str(workspace_root),
+            active_analysis_campaign_id=None,
+            analysis_parent_branch=None,
+            analysis_parent_worktree_root=None,
+            paper_parent_branch=None,
+            paper_parent_worktree_root=None,
+            paper_parent_run_id=None,
+            workspace_mode="run",
+            last_flow_type="main_experiment_recorded",
+        )
         return {
             "ok": True,
             "guidance": artifact.get("guidance"),
@@ -3058,10 +4457,14 @@ class ArtifactService:
             "suggested_artifact_calls": artifact.get("suggested_artifact_calls"),
             "next_instruction": artifact.get("next_instruction"),
             "run_id": run_identifier,
+            "branch": branch_name,
+            "parent_branch": parent_branch,
+            "auto_promoted_run_branch": auto_promoted_run_branch,
             "run_md_path": str(run_md_path),
             "result_json_path": str(result_json_path),
             "artifact": artifact,
             "interaction": interaction,
+            "research_state": research_state,
             "metrics_summary": normalized_metrics_summary,
             "baseline_comparisons": {
                 key: value for key, value in comparisons.items() if key != "primary"
@@ -3069,6 +4472,7 @@ class ArtifactService:
             "progress_eval": progress_eval,
             "evaluation_summary": normalized_evaluation_summary,
             "delivery_policy": delivery_policy,
+            "metric_validation": metric_validation,
         }
 
     def create_analysis_campaign(
@@ -3091,6 +4495,14 @@ class ArtifactService:
             quest_root,
             state=state,
         )
+        runtime_refs = self.resolve_runtime_refs(quest_root)
+        resolved_parent_run_id = (
+            str(parent_run_id or "").strip()
+            or str(state.get("paper_parent_run_id") or "").strip()
+            or str((self._latest_main_run_for_branch(quest_root, parent_branch) or {}).get("run_id") or "").strip()
+            or str(runtime_refs.get("latest_main_run_id") or "").strip()
+            or None
+        )
         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.")
@@ -3104,6 +4516,54 @@ class ArtifactService:
         normalized_research_questions = self._normalize_string_list(research_questions)
         normalized_experimental_designs = self._normalize_string_list(experimental_designs)
         normalized_todo_items = self._normalize_campaign_todo_items(todo_items)
+        quest_data = self.quest_service.read_quest_yaml(quest_root)
+        active_anchor = str(quest_data.get("active_anchor") or "").strip().lower()
+        campaign_origin_kind = (
+            str(normalized_campaign_origin.get("kind") or "").strip().lower()
+            if isinstance(normalized_campaign_origin, dict)
+            else ""
+        )
+        writing_facing = bool(
+            resolved_outline_ref
+            or normalized_research_questions
+            or normalized_experimental_designs
+            or normalized_todo_items
+            or str(state.get("workspace_mode") or "").strip().lower() == "paper"
+            or active_anchor == "write"
+            or campaign_origin_kind in {"write", "paper", "rebuttal", "revision"}
+        )
+        if writing_facing:
+            if not resolved_outline_ref:
+                raise ValueError(
+                    "Writing-facing analysis campaigns require `selected_outline_ref` before slices can be launched."
+                )
+            if not normalized_research_questions:
+                raise ValueError(
+                    "Writing-facing analysis campaigns require non-empty `research_questions`."
+                )
+            if not normalized_experimental_designs:
+                raise ValueError(
+                    "Writing-facing analysis campaigns require non-empty `experimental_designs`."
+                )
+            if not normalized_todo_items:
+                raise ValueError(
+                    "Writing-facing analysis campaigns require non-empty `todo_items`."
+                )
+            todo_slice_ids = {
+                str(item.get("slice_id") or "").strip()
+                for item in normalized_todo_items
+                if str(item.get("slice_id") or "").strip()
+            }
+            missing_slice_ids = [
+                str(raw.get("slice_id") or "").strip()
+                for raw in slices
+                if str(raw.get("slice_id") or "").strip() and str(raw.get("slice_id") or "").strip() not in todo_slice_ids
+            ]
+            if missing_slice_ids:
+                raise ValueError(
+                    "Writing-facing analysis campaigns require one todo item per slice. "
+                    f"Missing todo items for: {', '.join(missing_slice_ids)}."
+                )
         slice_contexts: list[dict[str, Any]] = []
         inventory_entries: list[dict[str, Any]] = []
         for index, raw in enumerate(slices, start=1):
@@ -3366,7 +4826,7 @@ class ArtifactService:
             {
                 "title": campaign_title,
                 "goal": campaign_goal,
-                "parent_run_id": parent_run_id,
+                "parent_run_id": resolved_parent_run_id,
                 "active_idea_id": active_idea_id,
                 "parent_branch": parent_branch,
                 "parent_worktree_root": str(parent_worktree_root),
@@ -3441,7 +4901,7 @@ class ArtifactService:
                 "details": {
                     "campaign_title": campaign_title,
                     "campaign_goal": campaign_goal,
-                    "parent_run_id": parent_run_id,
+                    "parent_run_id": resolved_parent_run_id,
                     "campaign_origin": normalized_campaign_origin,
                     "selected_outline_ref": resolved_outline_ref,
                     "todo_manifest_path": str(todo_manifest_path),
@@ -3493,14 +4953,13 @@ class ArtifactService:
         interaction = self.interact(
             quest_root,
             kind="milestone",
-            message=(
-                f"Analysis campaign `{campaign_id}` is ready.\n"
-                f"- Parent branch: `{parent_branch}`\n"
-                f"- Parent worktree: `{parent_worktree_root}`\n"
-                f"- Next slice: `{first_slice['slice_id']}`\n"
-                f"- Slice branch: `{first_slice['branch']}`\n"
-                f"- Slice worktree: `{first_slice['worktree_root']}`\n"
-                f"- Core requirement: {first_slice['must_not_simplify'] or 'Follow the full evaluation protocol.'}"
+            message=self._build_analysis_campaign_interaction_message(
+                campaign_id=campaign_id,
+                goal=campaign_goal,
+                parent_branch=parent_branch,
+                selected_outline_ref=resolved_outline_ref,
+                first_slice=first_slice,
+                todo_manifest_rel_path=self._workspace_relative(quest_root, todo_manifest_path),
             ),
             deliver_to_bound_conversations=True,
             include_recent_inbound_messages=False,
@@ -3560,11 +5019,32 @@ class ArtifactService:
         if normalized_mode not in {"candidate", "select", "revise"}:
             raise ValueError("submit_paper_outline mode must be `candidate`, `select`, or `revise`.")
 
-        existing_selected = read_json(self._paper_selected_outline_path(quest_root), {})
+        paper_context = (
+            self._ensure_active_paper_workspace(quest_root)
+            if normalized_mode in {"select", "revise"}
+            else {
+                "worktree_root": str(self._workspace_root_for(quest_root)),
+                "branch": str(self.quest_service.read_research_state(quest_root).get("current_workspace_branch") or "").strip() or None,
+            }
+        )
+        workspace_root = Path(str(paper_context.get("worktree_root") or self._workspace_root_for(quest_root)))
+        paper_root = (
+            ensure_dir(workspace_root / "paper")
+            if normalized_mode in {"select", "revise"}
+            else self._paper_root(quest_root, workspace_root=workspace_root, create=True)
+        )
+        if normalized_mode in {"select", "revise"}:
+            selected_outline_path = paper_root / "selected_outline.json"
+        else:
+            selected_outline_path = self._paper_selected_outline_path(quest_root, workspace_root=workspace_root)
+        existing_selected = read_json(selected_outline_path, {})
+        if not isinstance(existing_selected, dict) or not existing_selected:
+            existing_selected = read_json(quest_root / "paper" / "selected_outline.json", {})
         existing_selected = existing_selected if isinstance(existing_selected, dict) else {}
         if normalized_mode == "candidate":
             resolved_outline_id = str(outline_id or self._next_paper_outline_id(quest_root)).strip()
-            candidate_path = self._paper_outline_candidates_root(quest_root) / f"{resolved_outline_id}.json"
+            candidate_path = self._paper_outline_candidates_root(quest_root, workspace_root=workspace_root) / f"{resolved_outline_id}.json"
+            canonical_candidate_path = quest_root / "paper" / "outlines" / "candidates" / f"{resolved_outline_id}.json"
             existing = read_json(candidate_path, {})
             existing = existing if isinstance(existing, dict) else {}
             record = self._normalize_paper_outline_record(
@@ -3579,6 +5059,8 @@ class ArtifactService:
                 created_at=str(existing.get("created_at") or "") or None,
             )
             write_json(candidate_path, record)
+            if canonical_candidate_path.resolve() != candidate_path.resolve():
+                write_json(canonical_candidate_path, record)
             artifact = self.record(
                 quest_root,
                 {
@@ -3599,7 +5081,7 @@ class ArtifactService:
                     },
                 },
                 checkpoint=False,
-                workspace_root=self._workspace_root_for(quest_root),
+                workspace_root=workspace_root,
             )
             return {
                 "ok": True,
@@ -3613,8 +5095,13 @@ class ArtifactService:
         source_outline_id = str(outline_id or existing_selected.get("outline_id") or "").strip()
         if not source_outline_id:
             raise ValueError("submit_paper_outline(select/revise) requires an existing `outline_id` or selected outline.")
-        source_candidate_path = self._paper_outline_candidates_root(quest_root) / f"{source_outline_id}.json"
+        source_candidate_path = paper_root / "outlines" / "candidates" / f"{source_outline_id}.json"
         source_record = read_json(source_candidate_path, {})
+        if not isinstance(source_record, dict) or not source_record:
+            fallback_candidate_path = quest_root / "paper" / "outlines" / "candidates" / f"{source_outline_id}.json"
+            source_record = read_json(fallback_candidate_path, {})
+            if isinstance(source_record, dict) and source_record:
+                source_candidate_path = fallback_candidate_path
         if not isinstance(source_record, dict) or not source_record:
             source_record = existing_selected if str(existing_selected.get("outline_id") or "").strip() == source_outline_id else {}
         if not source_record:
@@ -3632,18 +5119,23 @@ class ArtifactService:
             created_at=str(source_record.get("created_at") or "") or None,
         )
 
-        selected_outline_path = self._paper_selected_outline_path(quest_root)
         write_json(selected_outline_path, resolved_record)
+        canonical_selected_outline_path = quest_root / "paper" / "selected_outline.json"
+        if canonical_selected_outline_path.resolve() != selected_outline_path.resolve():
+            write_json(canonical_selected_outline_path, resolved_record)
         if source_candidate_path.exists():
             source_record["status"] = "selected" if normalized_mode == "select" else "revised"
             source_record["updated_at"] = utc_now()
             write_json(source_candidate_path, source_record)
         revised_outline_path = None
         if normalized_mode == "revise":
-            revised_outline_path = self._paper_outline_revisions_root(quest_root) / f"{source_outline_id}.json"
+            revised_outline_path = ensure_dir(paper_root / "outlines" / "revisions") / f"{source_outline_id}.json"
             write_json(revised_outline_path, resolved_record)
+            canonical_revised_outline_path = quest_root / "paper" / "outlines" / "revisions" / f"{source_outline_id}.json"
+            if canonical_revised_outline_path.resolve() != revised_outline_path.resolve():
+                write_json(canonical_revised_outline_path, resolved_record)
 
-        outline_selection_path = self._paper_outline_selection_path(quest_root)
+        outline_selection_path = paper_root / "outline_selection.md"
         action_label = "selected" if normalized_mode == "select" else "revised"
         selection_lines = [
             f"# Outline {normalized_mode.capitalize()}",
@@ -3682,7 +5174,47 @@ class ArtifactService:
                 },
             },
             checkpoint=False,
-            workspace_root=self._workspace_root_for(quest_root),
+            workspace_root=workspace_root,
+        )
+        selected_outline_rel_path = self._workspace_relative(quest_root, selected_outline_path)
+        outline_selection_rel_path = self._workspace_relative(quest_root, outline_selection_path)
+        revised_outline_rel_path = self._workspace_relative(quest_root, revised_outline_path) if revised_outline_path else None
+        interaction = self.interact(
+            quest_root,
+            kind="milestone" if normalized_mode == "select" else "progress",
+            message=self._build_outline_interaction_message(
+                action=normalized_mode,
+                outline_id=source_outline_id,
+                title=str(resolved_record.get("title") or "").strip() or source_outline_id,
+                selected_reason=selected_reason or note,
+                story=str(resolved_record.get("story") or "").strip() or None,
+                research_questions=(
+                    (resolved_record.get("detailed_outline") or {})
+                    if isinstance(resolved_record.get("detailed_outline"), dict)
+                    else {}
+                ).get("research_questions"),
+                experimental_designs=(
+                    (resolved_record.get("detailed_outline") or {})
+                    if isinstance(resolved_record.get("detailed_outline"), dict)
+                    else {}
+                ).get("experimental_designs"),
+                selected_outline_rel_path=selected_outline_rel_path,
+                outline_selection_rel_path=outline_selection_rel_path,
+                revised_outline_rel_path=revised_outline_rel_path,
+            ),
+            deliver_to_bound_conversations=True,
+            include_recent_inbound_messages=False,
+            attachments=[
+                {
+                    "kind": "paper_outline_selected" if normalized_mode == "select" else "paper_outline_revised",
+                    "outline_id": source_outline_id,
+                    "title": resolved_record.get("title"),
+                    "selected_reason": selected_reason,
+                    "selected_outline_path": str(selected_outline_path),
+                    "outline_selection_path": str(outline_selection_path),
+                    "revised_outline_path": str(revised_outline_path) if revised_outline_path else None,
+                }
+            ],
         )
         return {
             "ok": True,
@@ -3693,6 +5225,7 @@ class ArtifactService:
             "revised_outline_path": str(revised_outline_path) if revised_outline_path else None,
             "record": resolved_record,
             "artifact": artifact,
+            "interaction": interaction,
         }
 
     def submit_paper_bundle(
@@ -3710,24 +5243,44 @@ class ArtifactService:
         pdf_path: str | None = None,
         latex_root_path: str | None = None,
     ) -> dict[str, Any]:
-        selected_outline_path = self._paper_selected_outline_path(quest_root)
+        paper_context = self._ensure_active_paper_workspace(quest_root)
+        workspace_root = Path(str(paper_context.get("worktree_root") or self._workspace_root_for(quest_root)))
+        paper_root = self._paper_root(quest_root, workspace_root=workspace_root, create=True)
+        selected_outline_path = self._paper_selected_outline_path(quest_root, workspace_root=workspace_root)
         selected_outline = read_json(selected_outline_path, {})
+        if not isinstance(selected_outline, dict) or not selected_outline:
+            fallback_selected_outline_path = quest_root / "paper" / "selected_outline.json"
+            selected_outline = read_json(fallback_selected_outline_path, {})
+            if isinstance(selected_outline, dict) and selected_outline:
+                selected_outline_path = fallback_selected_outline_path
         selected_outline = selected_outline if isinstance(selected_outline, dict) else {}
         if not selected_outline and not str(outline_path or "").strip():
             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))
-        )
+        manifest_path = self._paper_bundle_manifest_path(quest_root, workspace_root=workspace_root)
+        baseline_inventory = self._write_paper_baseline_inventory(quest_root, workspace_root=workspace_root)
+        baseline_inventory_path = self._paper_baseline_inventory_path(quest_root, workspace_root=workspace_root)
+        source_branch = str(paper_context.get("source_branch") or "").strip() or None
+        paper_branch = str(paper_context.get("branch") or "").strip() or current_branch(workspace_root)
+        source_run_id = str(paper_context.get("source_run_id") or "").strip() or None
+        source_idea_id = str(paper_context.get("source_idea_id") or "").strip() or None
+        paper_manifest_rel = self._workspace_relative(quest_root, manifest_path) or "paper/paper_bundle_manifest.json"
+        paper_inventory_rel = self._workspace_relative(quest_root, baseline_inventory_path) or "paper/baseline_inventory.json"
         open_source_manifest = self._ensure_open_source_prep(
             quest_root,
+            workspace_root=workspace_root,
             source_branch=source_branch,
-            source_bundle_manifest_path="paper/paper_bundle_manifest.json",
-            baseline_inventory_path="paper/baseline_inventory.json",
+            source_bundle_manifest_path=paper_manifest_rel,
+            baseline_inventory_path=paper_inventory_rel,
+        )
+        default_draft_path = self._workspace_relative(quest_root, paper_root / "draft.md") or "paper/draft.md"
+        default_writing_plan_path = self._workspace_relative(quest_root, paper_root / "writing_plan.md") or "paper/writing_plan.md"
+        default_references_path = self._workspace_relative(quest_root, paper_root / "references.bib") or "paper/references.bib"
+        default_claim_map_path = (
+            self._workspace_relative(quest_root, paper_root / "claim_evidence_map.json") or "paper/claim_evidence_map.json"
+        )
+        default_compile_report_path = (
+            self._workspace_relative(quest_root, paper_root / "build" / "compile_report.json") or "paper/build/compile_report.json"
         )
         manifest = {
             "schema_version": 1,
@@ -3740,15 +5293,23 @@ class ArtifactService:
             or "paper",
             "summary": str(summary or "").strip() or None,
             "outline_path": str(outline_path or selected_outline_path).strip() or None,
-            "draft_path": str(draft_path or "paper/draft.md").strip() or None,
-            "writing_plan_path": str(writing_plan_path or "paper/writing_plan.md").strip() or None,
-            "references_path": str(references_path or "paper/references.bib").strip() or None,
-            "claim_evidence_map_path": str(claim_evidence_map_path or "paper/claim_evidence_map.json").strip() or None,
-            "compile_report_path": str(compile_report_path or "paper/build/compile_report.json").strip() or None,
+            "paper_branch": paper_branch,
+            "source_branch": source_branch,
+            "source_run_id": source_run_id,
+            "source_idea_id": source_idea_id,
+            "draft_path": str(draft_path or default_draft_path).strip() or None,
+            "writing_plan_path": str(writing_plan_path or default_writing_plan_path).strip() or None,
+            "references_path": str(references_path or default_references_path).strip() or None,
+            "claim_evidence_map_path": str(claim_evidence_map_path or default_claim_map_path).strip() or None,
+            "compile_report_path": str(compile_report_path or default_compile_report_path).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",
+            "baseline_inventory_path": paper_inventory_rel,
+            "open_source_manifest_path": self._workspace_relative(
+                quest_root,
+                self._open_source_manifest_path(quest_root, workspace_root=workspace_root),
+            )
+            or "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,
@@ -3773,24 +5334,27 @@ class ArtifactService:
                     "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)),
+                    "open_source_manifest_path": str(self._open_source_manifest_path(quest_root, workspace_root=workspace_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"),
+                    "paper_branch": paper_branch,
+                    "source_branch": source_branch,
+                    "source_run_id": source_run_id,
                 },
             },
             checkpoint=False,
-            workspace_root=self._workspace_root_for(quest_root),
+            workspace_root=workspace_root,
         )
         return {
             "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)),
+            "open_source_manifest_path": str(self._open_source_manifest_path(quest_root, workspace_root=workspace_root)),
             "artifact": artifact,
         }
 
@@ -3828,7 +5392,17 @@ 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_metric_rows = normalize_metric_rows(metric_rows or [])
+        normalized_metrics_summary = {
+            str(item.get("metric_id") or "").strip(): item.get("value")
+            for item in normalized_metric_rows
+            if str(item.get("metric_id") or "").strip()
+        }
+        normalized_metric_contract = normalize_metric_contract(
+            {},
+            metrics_summary=normalized_metrics_summary,
+            metric_rows=normalized_metric_rows,
+        )
         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
@@ -3896,9 +5470,9 @@ class ArtifactService:
             result_lines.extend([f"- `{item}`" for item in evidence_paths])
         else:
             result_lines.append("- None recorded.")
-        if metric_rows:
+        if normalized_metric_rows:
             result_lines.extend(["", "## Metric Rows", ""])
-            for row in metric_rows:
+            for row in normalized_metric_rows:
                 result_lines.append(f"- `{row}`")
         result_lines.extend(["", "## Comparison Baselines", ""])
         if normalized_comparison_baselines:
@@ -3918,16 +5492,6 @@ class ArtifactService:
             result_lines.extend(["", "## Subset Approval", "", f"`{subset_approval_ref}`"])
         write_text(result_path, "\n".join(result_lines).rstrip() + "\n")
 
-        metrics_summary: dict[str, Any] = {}
-        for row in metric_rows:
-            name = str(row.get("name") or row.get("metric") or "").strip()
-            if name:
-                metrics_summary[name] = row.get("value")
-                continue
-            keys = [key for key in row.keys() if key not in {"split", "seed", "note", "notes"}]
-            if len(keys) == 1:
-                metrics_summary[keys[0]] = row.get(keys[0])
-
         result_payload = {
             "schema_version": 1,
             "result_kind": "analysis_slice",
@@ -3939,8 +5503,9 @@ class ArtifactService:
             "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,
+            "metrics_summary": normalized_metrics_summary,
+            "metric_rows": normalized_metric_rows,
+            "metric_contract": normalized_metric_contract,
             "dataset_scope": normalized_scope,
             "subset_approval_ref": subset_approval_ref,
             "setup": setup.strip() or None,
@@ -4026,7 +5591,11 @@ class ArtifactService:
                 "parent_branch": parent_branch,
                 "worktree_root": str(slice_worktree_root),
                 "worktree_rel_path": self._workspace_relative(quest_root, slice_worktree_root),
-                "metrics_summary": metrics_summary,
+                "metrics_summary": normalized_metrics_summary,
+                "metric_rows": normalized_metric_rows,
+                "metric_contract": normalized_metric_contract,
+                "comparison_baselines": normalized_comparison_baselines,
+                "evidence_paths": evidence_paths,
                 "flow_type": "analysis_slice",
                 "protocol_step": "record",
                 "paths": {
@@ -4040,7 +5609,7 @@ class ArtifactService:
                     "must_not_simplify": target.get("must_not_simplify"),
                     "dataset_scope": normalized_scope,
                     "subset_approval_ref": subset_approval_ref,
-                    "metric_rows": metric_rows,
+                    "metric_rows": normalized_metric_rows,
                     "claim_impact": normalized_claim_impact,
                     "reviewer_resolution": normalized_reviewer_resolution,
                     "manuscript_update_hint": normalized_manuscript_update_hint,
@@ -4080,6 +5649,8 @@ class ArtifactService:
             updated["reviewer_resolution"] = normalized_reviewer_resolution
             updated["manuscript_update_hint"] = normalized_manuscript_update_hint
             updated["next_recommendation"] = normalized_next_recommendation
+            updated["metrics_summary"] = normalized_metrics_summary
+            updated["metric_rows"] = normalized_metric_rows
             updated["comparison_baselines"] = normalized_comparison_baselines
             updated["evaluation_summary"] = normalized_evaluation_summary
             updated_slices.append(updated)
@@ -4137,13 +5708,13 @@ class ArtifactService:
             interaction = self.interact(
                 quest_root,
                 kind="progress",
-                message=(
-                    f"Analysis slice `{slice_id}` is complete.\n"
-                    f"- Parent branch mirror updated: `{mirror_path}`\n"
-                    f"- Next slice: `{next_slice['slice_id']}`\n"
-                    f"- Next branch: `{next_slice['branch']}`\n"
-                    f"- Next worktree: `{next_slice['worktree_root']}`\n"
-                    f"- Core requirement: {next_slice.get('must_not_simplify') or 'Use the full intended evaluation protocol.'}"
+                message=self._build_analysis_slice_interaction_message(
+                    campaign_id=campaign_id,
+                    slice_id=slice_id,
+                    evaluation_summary=normalized_evaluation_summary,
+                    claim_impact=normalized_claim_impact,
+                    next_slice=next_slice,
+                    mirror_rel_path=self._workspace_relative(quest_root, mirror_path),
                 ),
                 deliver_to_bound_conversations=True,
                 include_recent_inbound_messages=False,
@@ -4229,26 +5800,55 @@ class ArtifactService:
             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(
+        startup_contract = self._startup_contract(quest_root)
+        raw_need_research_paper = startup_contract.get("need_research_paper")
+        need_research_paper = raw_need_research_paper if isinstance(raw_need_research_paper, bool) else True
+        base_research_state = self.quest_service.update_research_state(
             quest_root,
             active_idea_id=restored_idea_id,
             active_analysis_campaign_id=None,
+            analysis_parent_branch=None,
+            analysis_parent_worktree_root=None,
+            paper_parent_branch=None,
+            paper_parent_worktree_root=None,
+            paper_parent_run_id=None,
             next_pending_slice_id=None,
             current_workspace_branch=parent_branch,
             current_workspace_root=str(parent_worktree_root),
-            workspace_mode="idea",
+            workspace_mode="run" if self._branch_kind_from_name(parent_branch) == "run" else "idea",
             last_flow_type="analysis_campaign_complete",
         )
-        self.quest_service.update_settings(self._quest_id(quest_root), active_anchor="decision")
+        writing_workspace: dict[str, Any] | None = None
+        if need_research_paper:
+            try:
+                writing_workspace = self._ensure_active_paper_workspace(
+                    quest_root,
+                    source_branch=parent_branch,
+                    source_run_id=str(manifest.get("parent_run_id") or "").strip() or None,
+                    source_idea_id=restored_idea_id,
+                )
+            except Exception:
+                writing_workspace = None
+
+        if writing_workspace:
+            research_state = self.quest_service.read_research_state(quest_root)
+            self.quest_service.update_settings(self._quest_id(quest_root), active_anchor="write")
+        else:
+            research_state = base_research_state
+            self.quest_service.update_settings(self._quest_id(quest_root), active_anchor="decision")
         interaction = self.interact(
             quest_root,
             kind="milestone",
-            message=(
-                f"All analysis slices in `{campaign_id}` are complete.\n"
-                f"- Returned to parent branch: `{parent_branch}`\n"
-                f"- Parent worktree: `{parent_worktree_root}`\n"
-                f"- Analysis summary: `{summary_path}`\n"
-                "Use the completed analysis evidence to make the next durable route decision."
+            message=self._build_analysis_complete_interaction_message(
+                campaign_id=campaign_id,
+                completed_slices=updated_slices,
+                summary_rel_path=self._workspace_relative(quest_root, summary_path),
+                writing_branch=writing_workspace.get("branch") if writing_workspace else None,
+                writing_worktree_rel_path=(
+                    self._workspace_relative(quest_root, Path(str(writing_workspace.get("worktree_root"))))
+                    if writing_workspace and str(writing_workspace.get("worktree_root") or "").strip()
+                    else None
+                ),
             ),
             deliver_to_bound_conversations=True,
             include_recent_inbound_messages=False,
@@ -4259,6 +5859,8 @@ class ArtifactService:
                     "parent_branch": parent_branch,
                     "parent_worktree_root": str(parent_worktree_root),
                     "summary_path": str(summary_path),
+                    "writing_branch": writing_workspace.get("branch") if writing_workspace else None,
+                    "writing_worktree_root": writing_workspace.get("worktree_root") if writing_workspace else None,
                 }
             ],
         )
@@ -4284,6 +5886,8 @@ class ArtifactService:
             "completed": True,
             "returned_to_branch": parent_branch,
             "returned_to_worktree_root": str(parent_worktree_root),
+            "writing_branch": writing_workspace.get("branch") if writing_workspace else None,
+            "writing_worktree_root": writing_workspace.get("worktree_root") if writing_workspace else None,
         }
 
     def publish_baseline(self, quest_root: Path, payload: dict) -> dict:
@@ -4334,6 +5938,81 @@ class ArtifactService:
             "guidance": "The selected baseline is now attached under baselines/imported. Reuse it before considering a fresh reproduction.",
         }
 
+    def delete_baseline(self, baseline_id: str) -> dict[str, Any]:
+        existing = self.baselines.get(baseline_id, include_deleted=True)
+        if existing is None:
+            raise FileNotFoundError(f"Unknown baseline: {baseline_id}")
+
+        normalized_baseline_id = str(existing.get("baseline_id") or existing.get("entry_id") or baseline_id).strip()
+        already_deleted = self.baselines.is_deleted(normalized_baseline_id)
+        deleted_entry = self.baselines.delete(normalized_baseline_id) if not already_deleted else dict(existing)
+
+        affected_quest_ids: list[str] = []
+        cleared_requested_refs = 0
+        cleared_confirmed_refs = 0
+        deleted_paths: list[str] = []
+        warnings: list[str] = []
+        quests_root = self.home / "quests"
+
+        for quest_yaml in sorted(quests_root.glob("*/quest.yaml")):
+            quest_root = quest_yaml.parent
+            quest_id = quest_root.name
+            quest_touched = False
+            quest_payload = self.quest_service.read_quest_yaml(quest_root)
+
+            requested_ref = (
+                dict(quest_payload.get("requested_baseline_ref") or {})
+                if isinstance(quest_payload.get("requested_baseline_ref"), dict)
+                else {}
+            )
+            if str(requested_ref.get("baseline_id") or "").strip() == normalized_baseline_id:
+                self.quest_service.update_startup_context(quest_root, requested_baseline_ref=None)
+                cleared_requested_refs += 1
+                quest_touched = True
+
+            confirmed_ref = (
+                dict(quest_payload.get("confirmed_baseline_ref") or {})
+                if isinstance(quest_payload.get("confirmed_baseline_ref"), dict)
+                else {}
+            )
+            if str(confirmed_ref.get("baseline_id") or "").strip() == normalized_baseline_id:
+                self.quest_service.update_baseline_state(
+                    quest_root,
+                    baseline_gate="pending",
+                    confirmed_baseline_ref=None,
+                    active_anchor="baseline",
+                )
+                cleared_confirmed_refs += 1
+                quest_touched = True
+
+            for root in self._baseline_workspace_roots(quest_root):
+                try:
+                    removed = self._remove_baseline_materialization(root, normalized_baseline_id)
+                except OSError as exc:
+                    warnings.append(
+                        f"Unable to remove baseline materialization under `{root}` for quest `{quest_id}`: {exc}"
+                    )
+                    continue
+                if removed:
+                    deleted_paths.extend(removed)
+                    quest_touched = True
+
+            if quest_touched:
+                affected_quest_ids.append(quest_id)
+
+        return {
+            "ok": True,
+            "baseline_id": normalized_baseline_id,
+            "deleted": not already_deleted,
+            "already_deleted": already_deleted,
+            "baseline_registry_entry": deleted_entry,
+            "affected_quest_ids": affected_quest_ids,
+            "cleared_requested_refs": cleared_requested_refs,
+            "cleared_confirmed_refs": cleared_confirmed_refs,
+            "deleted_paths": deleted_paths,
+            "warnings": warnings,
+        }
+
     def confirm_baseline(
         self,
         quest_root: Path,
@@ -4345,9 +6024,11 @@ class ArtifactService:
         summary: str | None = None,
         baseline_kind: str | None = None,
         metric_contract: dict[str, Any] | None = None,
+        metric_directions: dict[str, str] | None = None,
         metrics_summary: dict[str, Any] | None = None,
         primary_metric: dict[str, Any] | None = None,
         auto_advance: bool = True,
+        strict_metric_contract: bool = False,
     ) -> dict[str, Any]:
         resolved = self._resolve_baseline_path(quest_root, baseline_path, baseline_id=baseline_id)
         resolved_baseline_id = str(resolved["baseline_id"] or "").strip()
@@ -4439,6 +6120,85 @@ class ArtifactService:
                 or ""
             ).strip() or None
 
+        source_metrics_summary = (
+            selected_variant.get("metrics_summary")
+            if isinstance(selected_variant, dict) and selected_variant.get("metrics_summary") is not None
+            else entry.get("metrics_summary")
+        )
+        entry_metric_contract, entry_primary_metric = self._apply_metric_directions_to_contract(
+            metric_contract=entry.get("metric_contract"),
+            metric_directions=metric_directions,
+            baseline_id=resolved_baseline_id,
+            metrics_summary=source_metrics_summary,
+            primary_metric=entry.get("primary_metric"),
+            baseline_variants=entry.get("baseline_variants"),
+        )
+        entry = {
+            **entry,
+            "metric_contract": entry_metric_contract,
+            "primary_metric": entry_primary_metric or entry.get("primary_metric"),
+        }
+        canonical_baseline = (
+            validate_baseline_metric_contract_submission(
+                metric_contract=entry.get("metric_contract"),
+                metrics_summary=source_metrics_summary,
+                primary_metric=entry.get("primary_metric"),
+            )
+            if strict_metric_contract
+            else canonicalize_baseline_submission(
+                metric_contract=entry.get("metric_contract"),
+                metrics_summary=source_metrics_summary,
+                primary_metric=entry.get("primary_metric"),
+            )
+        )
+        entry = {
+            **entry,
+            "metrics_summary": canonical_baseline["metrics_summary"],
+            "metric_contract": canonical_baseline["metric_contract"],
+            "metric_details": canonical_baseline["metric_details"],
+        }
+        if isinstance(selected_variant, dict):
+            selected_variant = {
+                **selected_variant,
+                "metrics_summary": canonical_baseline["metrics_summary"],
+            }
+        if isinstance(entry.get("baseline_variants"), list):
+            entry["baseline_variants"] = [
+                (
+                    {
+                        **variant,
+                        "metrics_summary": canonical_baseline["metrics_summary"],
+                    }
+                    if isinstance(variant, dict)
+                    and str(variant.get("variant_id") or "").strip() == str(resolved_variant_id or "").strip()
+                    else variant
+                )
+                for variant in entry.get("baseline_variants", [])
+            ]
+        primary_metric_id = str(
+            (entry.get("primary_metric") or {}).get("metric_id")
+            or (entry.get("primary_metric") or {}).get("name")
+            or (entry.get("primary_metric") or {}).get("id")
+            or (canonical_baseline["metric_contract"] or {}).get("primary_metric_id")
+            or ""
+        ).strip()
+        if primary_metric_id and primary_metric_id in canonical_baseline["metrics_summary"]:
+            primary_metric_meta = next(
+                (
+                    item
+                    for item in (canonical_baseline["metric_contract"] or {}).get("metrics", [])
+                    if isinstance(item, dict) and str(item.get("metric_id") or "").strip() == primary_metric_id
+                ),
+                {},
+            )
+            entry["primary_metric"] = {
+                **(dict(entry.get("primary_metric") or {}) if isinstance(entry.get("primary_metric"), dict) else {}),
+                "metric_id": primary_metric_id,
+                "value": canonical_baseline["metrics_summary"][primary_metric_id],
+                "direction": primary_metric_meta.get("direction")
+                or (entry.get("primary_metric") or {}).get("direction"),
+            }
+
         metric_contract_json = self._write_baseline_metric_contract_json(
             quest_root,
             baseline_root=resolved_root,
@@ -4540,7 +6300,10 @@ class ArtifactService:
             "artifact": artifact,
             "baseline_registry_entry": registry_entry,
             "snapshot": self.quest_service.snapshot(self._quest_id(quest_root)),
+            "metric_details": canonical_baseline["metric_details"],
             "legacy_guidance": "Baseline gate confirmed. Idea selection is now the default next anchor.",
+            "metric_contract_json_path": str(metric_contract_json.get("path") or ""),
+            "metric_contract_json_rel_path": str(metric_contract_json.get("rel_path") or ""),
         }
 
     def waive_baseline(
@@ -5159,6 +6922,8 @@ class ArtifactService:
             return f"idea/{quest_id}-{idea_id}"
         if branch_kind == "quest":
             return f"quest/{quest_id}"
+        if branch_kind == "paper":
+            return f"paper/{run_id or generate_id('paper')}"
         return f"run/{run_id or generate_id('run')}"
 
     def _bound_conversations(self, quest_root: Path) -> list[str]:
@@ -5187,7 +6952,14 @@ class ArtifactService:
         return targets
 
     def _connectors_config(self) -> dict[str, Any]:
-        return ConfigManager(self.home).load_named_normalized("connectors")
+        manager = ConfigManager(self.home)
+        connectors = manager.load_named_normalized("connectors")
+        for name, config in list(connectors.items()):
+            if str(name).startswith("_") or not isinstance(config, dict):
+                continue
+            if not manager.is_connector_system_enabled(str(name)):
+                config["enabled"] = False
+        return connectors
 
     @staticmethod
     def _delivery_policy(connectors: dict[str, Any]) -> str: