@researai/deepscientist 1.5.0 → 1.5.1

package/src/deepscientist/artifact/service.py

@@ -422,6 +422,45 @@ class ArtifactService:
     def _normalize_string_list(values: list[object] | None) -> list[str]:
         return [str(item).strip() for item in (values or []) if str(item).strip()]
 
+    def _normalize_campaign_origin(self, payload: dict[str, Any] | None) -> dict[str, Any] | None:
+        if not isinstance(payload, dict):
+            return None
+        origin_kind = str(payload.get("kind") or "analysis").strip().lower() or "analysis"
+        normalized = {
+            "kind": origin_kind,
+            "reason": str(payload.get("reason") or "").strip() or None,
+            "source_artifact_id": str(payload.get("source_artifact_id") or "").strip() or None,
+            "source_outline_ref": str(payload.get("source_outline_ref") or "").strip() or None,
+            "source_review_round": str(payload.get("source_review_round") or "").strip() or None,
+            "reviewer_item_ids": self._normalize_string_list(payload.get("reviewer_item_ids")),
+        }
+        if not any(value for key, value in normalized.items() if key != "kind"):
+            normalized["reason"] = None
+        return normalized
+
+    def _normalize_campaign_todo_items(self, todo_items: list[dict[str, Any]] | None) -> list[dict[str, Any]]:
+        normalized_items: list[dict[str, Any]] = []
+        for raw in todo_items or []:
+            if not isinstance(raw, dict):
+                continue
+            normalized_items.append(
+                {
+                    "todo_id": str(raw.get("todo_id") or raw.get("slice_id") or "").strip() or None,
+                    "slice_id": str(raw.get("slice_id") or "").strip() or None,
+                    "title": str(raw.get("title") or "").strip() or None,
+                    "status": str(raw.get("status") or "pending").strip() or "pending",
+                    "research_question": str(raw.get("research_question") or "").strip() or None,
+                    "experimental_design": str(raw.get("experimental_design") or "").strip() or None,
+                    "completion_condition": str(raw.get("completion_condition") or "").strip() or None,
+                    "why_now": str(raw.get("why_now") or "").strip() or None,
+                    "success_criteria": str(raw.get("success_criteria") or "").strip() or None,
+                    "abandonment_criteria": str(raw.get("abandonment_criteria") or "").strip() or None,
+                    "reviewer_item_ids": self._normalize_string_list(raw.get("reviewer_item_ids")),
+                    "manuscript_targets": self._normalize_string_list(raw.get("manuscript_targets")),
+                }
+            )
+        return normalized_items
+
     def _normalize_paper_outline_record(
         self,
         *,
@@ -1073,6 +1112,80 @@ class ArtifactService:
         ]
         return candidates[-1] if candidates else None
 
+    def _latest_branch_idea_id(self, quest_root: Path, branch_name: str) -> str | None:
+        normalized_branch = str(branch_name or "").strip()
+        if not normalized_branch:
+            return None
+        latest_idea = self._latest_idea_for_branch(quest_root, normalized_branch)
+        if isinstance(latest_idea, dict):
+            candidate = str(latest_idea.get("idea_id") or "").strip()
+            if candidate:
+                return candidate
+        latest_main_run = self._latest_main_run_for_branch(quest_root, normalized_branch)
+        if isinstance(latest_main_run, dict):
+            candidate = str(latest_main_run.get("idea_id") or "").strip()
+            if candidate:
+                return candidate
+        latest_match: tuple[str, int, str] | None = None
+        latest_candidate: str | None = None
+        for item in self.quest_service._collect_artifacts(quest_root):
+            payload = dict(item.get("payload") or {}) if isinstance(item.get("payload"), dict) else {}
+            if not payload:
+                continue
+            if str(payload.get("branch") or "").strip() != normalized_branch:
+                continue
+            candidate = str(payload.get("idea_id") or "").strip()
+            if not candidate:
+                continue
+            artifact_path = str(item.get("path") or "")
+            try:
+                artifact_mtime_ns = Path(artifact_path).stat().st_mtime_ns if artifact_path else 0
+            except OSError:
+                artifact_mtime_ns = 0
+            sort_key = (
+                str(payload.get("updated_at") or payload.get("created_at") or ""),
+                artifact_mtime_ns,
+                artifact_path,
+            )
+            if latest_match is None or sort_key > latest_match:
+                latest_match = sort_key
+                latest_candidate = candidate
+        if latest_match is not None and latest_candidate:
+            return latest_candidate
+        return None
+
+    def _resolve_analysis_parent_context(
+        self,
+        quest_root: Path,
+        *,
+        state: dict[str, Any],
+    ) -> tuple[str, Path, str | None]:
+        current_root_raw = str(state.get("current_workspace_root") or "").strip()
+        head_root_raw = str(state.get("research_head_worktree_root") or "").strip()
+        parent_worktree_root: Path | None = None
+        for raw in (current_root_raw, head_root_raw):
+            if not raw:
+                continue
+            candidate = Path(raw)
+            if candidate.exists():
+                parent_worktree_root = candidate
+                break
+        if parent_worktree_root is None:
+            parent_worktree_root = self._workspace_root_for(quest_root)
+
+        parent_branch = (
+            str(state.get("current_workspace_branch") or "").strip()
+            or str(state.get("research_head_branch") or "").strip()
+            or current_branch(parent_worktree_root)
+            or current_branch(self._workspace_root_for(quest_root))
+        )
+        parent_branch = str(parent_branch or "").strip()
+        if not parent_branch:
+            raise ValueError("Unable to resolve a parent branch for the analysis campaign.")
+
+        idea_id = self._latest_branch_idea_id(quest_root, parent_branch) or str(state.get("active_idea_id") or "").strip() or None
+        return parent_branch, parent_worktree_root, idea_id
+
     def _idea_parent_branch(self, record: dict[str, Any] | None) -> str | None:
         if not isinstance(record, dict) or not record:
             return None
@@ -1357,6 +1470,111 @@ class ArtifactService:
             "branches": branches,
         }
 
+    def resolve_runtime_refs(self, quest_root: Path) -> dict[str, Any]:
+        state = self.quest_service.read_research_state(quest_root)
+        snapshot = self.quest_service.snapshot(self._quest_id(quest_root))
+        active_campaign_id = str(state.get("active_analysis_campaign_id") or "").strip() or None
+        analysis_parent_branch = str(state.get("analysis_parent_branch") or "").strip() or None
+        current_workspace_branch = str(state.get("current_workspace_branch") or "").strip() or None
+        research_head_branch = str(state.get("research_head_branch") or "").strip() or None
+        canonical_branch = analysis_parent_branch or current_workspace_branch or research_head_branch
+        latest_main_run = self._latest_main_run_for_branch(quest_root, canonical_branch or "")
+        selected_outline = read_json(self._paper_selected_outline_path(quest_root), {})
+        selected_outline = selected_outline if isinstance(selected_outline, dict) else {}
+        active_campaign = (
+            self._read_analysis_manifest(quest_root, active_campaign_id)
+            if active_campaign_id
+            else {}
+        )
+        active_campaign = active_campaign if isinstance(active_campaign, dict) else {}
+        latest_paths = (
+            dict(latest_main_run.get("paths") or {})
+            if isinstance(latest_main_run, dict) and isinstance(latest_main_run.get("paths"), dict)
+            else {}
+        )
+        return {
+            "ok": True,
+            "active_idea_id": str(state.get("active_idea_id") or "").strip() or None,
+            "research_head_branch": research_head_branch,
+            "research_head_worktree_root": str(state.get("research_head_worktree_root") or "").strip() or None,
+            "current_workspace_branch": current_workspace_branch,
+            "current_workspace_root": str(state.get("current_workspace_root") or "").strip() or None,
+            "analysis_parent_branch": analysis_parent_branch,
+            "analysis_parent_worktree_root": str(state.get("analysis_parent_worktree_root") or "").strip() or None,
+            "current_canonical_branch": canonical_branch,
+            "active_analysis_campaign_id": active_campaign_id,
+            "active_campaign_title": str(active_campaign.get("title") or "").strip() or None,
+            "next_pending_slice_id": str(state.get("next_pending_slice_id") or "").strip() or None,
+            "latest_main_run_id": str((latest_main_run or {}).get("run_id") or "").strip() or None,
+            "latest_main_run_branch": str((latest_main_run or {}).get("branch") or "").strip() or None,
+            "latest_main_result_json": str(latest_paths.get("result_json") or "").strip() or None,
+            "selected_outline_ref": str(selected_outline.get("outline_id") or "").strip() or None,
+            "default_reply_interaction_id": str(snapshot.get("default_reply_interaction_id") or "").strip() or None,
+        }
+
+    def get_analysis_campaign(self, quest_root: Path, campaign_id: str | None = None) -> dict[str, Any]:
+        resolved_campaign_id = str(campaign_id or "").strip()
+        if not resolved_campaign_id or resolved_campaign_id == "active":
+            state = self.quest_service.read_research_state(quest_root)
+            resolved_campaign_id = str(state.get("active_analysis_campaign_id") or "").strip()
+        if not resolved_campaign_id:
+            raise ValueError("No active analysis campaign is available.")
+        manifest = self._read_analysis_manifest(quest_root, resolved_campaign_id)
+        slices = [dict(item) for item in (manifest.get("slices") or []) if isinstance(item, dict)]
+        pending_slices = [item for item in slices if str(item.get("status") or "pending").strip() == "pending"]
+        completed_slices = [item for item in slices if str(item.get("status") or "").strip() != "pending"]
+        next_pending_slice = pending_slices[0] if pending_slices else None
+        return {
+            "ok": True,
+            "campaign_id": resolved_campaign_id,
+            "title": str(manifest.get("title") or "").strip() or None,
+            "goal": str(manifest.get("goal") or "").strip() or None,
+            "active_idea_id": str(manifest.get("active_idea_id") or "").strip() or None,
+            "parent_run_id": str(manifest.get("parent_run_id") or "").strip() or None,
+            "parent_branch": str(manifest.get("parent_branch") or "").strip() or None,
+            "parent_worktree_root": str(manifest.get("parent_worktree_root") or "").strip() or None,
+            "selected_outline_ref": str(manifest.get("selected_outline_ref") or "").strip() or None,
+            "campaign_origin": dict(manifest.get("campaign_origin") or {}) if isinstance(manifest.get("campaign_origin"), dict) else None,
+            "todo_items": [dict(item) for item in (manifest.get("todo_items") or []) if isinstance(item, dict)],
+            "slices": slices,
+            "next_pending_slice_id": str((next_pending_slice or {}).get("slice_id") or "").strip() or None,
+            "pending_slice_count": len(pending_slices),
+            "completed_slice_count": len(completed_slices),
+            "manifest": manifest,
+        }
+
+    def list_paper_outlines(self, quest_root: Path) -> dict[str, Any]:
+        selected_outline = read_json(self._paper_selected_outline_path(quest_root), {})
+        selected_outline = selected_outline if isinstance(selected_outline, dict) else {}
+        outlines: list[dict[str, Any]] = []
+        for status, root in (
+            ("candidate", self._paper_outline_candidates_root(quest_root)),
+            ("revised", self._paper_outline_revisions_root(quest_root)),
+        ):
+            for path in sorted(root.glob("outline-*.json")):
+                record = read_json(path, {})
+                if not isinstance(record, dict) or not record:
+                    continue
+                outline_id = str(record.get("outline_id") or path.stem).strip() or path.stem
+                outlines.append(
+                    {
+                        "outline_id": outline_id,
+                        "title": str(record.get("title") or outline_id).strip() or outline_id,
+                        "status": str(record.get("status") or status).strip() or status,
+                        "review_result": str(record.get("review_result") or "").strip() or None,
+                        "path": str(path),
+                        "is_selected": outline_id == str(selected_outline.get("outline_id") or "").strip(),
+                    }
+                )
+        outlines.sort(key=lambda item: (str(item.get("outline_id") or ""), str(item.get("status") or "")))
+        return {
+            "ok": True,
+            "selected_outline_ref": str(selected_outline.get("outline_id") or "").strip() or None,
+            "selected_outline": selected_outline or None,
+            "count": len(outlines),
+            "outlines": outlines,
+        }
+
     def _previous_primary_best(
         self,
         quest_root: Path,
@@ -2508,6 +2726,7 @@ class ArtifactService:
         campaign_goal: str,
         parent_run_id: str | None = None,
         slices: list[dict[str, Any]],
+        campaign_origin: dict[str, Any] | None = None,
         selected_outline_ref: str | None = None,
         research_questions: list[str] | None = None,
         experimental_designs: list[str] | None = None,
@@ -2515,20 +2734,23 @@ class ArtifactService:
     ) -> dict[str, Any]:
         self._require_baseline_gate_open(quest_root, action="create_analysis_campaign")
         state = self.quest_service.read_research_state(quest_root)
-        active_idea_id = str(state.get("active_idea_id") or "").strip()
+        parent_branch, parent_worktree_root, resolved_idea_id = self._resolve_analysis_parent_context(
+            quest_root,
+            state=state,
+        )
+        active_idea_id = str(resolved_idea_id or "").strip()
         if not active_idea_id:
             raise ValueError("An active idea is required before starting an analysis campaign.")
         if not slices:
             raise ValueError("At least one analysis slice is required.")
-        parent_branch = str(state.get("research_head_branch") or current_branch(self._workspace_root_for(quest_root))).strip()
-        parent_worktree_root = Path(str(state.get("research_head_worktree_root") or self._workspace_root_for(quest_root)))
         campaign_id = generate_id("analysis")
         charter_dir = ensure_dir(parent_worktree_root / "experiments" / "analysis-results" / campaign_id)
         charter_path = charter_dir / "campaign.md"
+        normalized_campaign_origin = self._normalize_campaign_origin(campaign_origin)
         resolved_outline_ref = str(selected_outline_ref or "").strip() or None
         normalized_research_questions = self._normalize_string_list(research_questions)
         normalized_experimental_designs = self._normalize_string_list(experimental_designs)
-        normalized_todo_items = [dict(item) for item in (todo_items or []) if isinstance(item, dict)]
+        normalized_todo_items = self._normalize_campaign_todo_items(todo_items)
         slice_contexts: list[dict[str, Any]] = []
         for index, raw in enumerate(slices, start=1):
             slice_id = str(raw.get("slice_id") or generate_id("slice")).strip()
@@ -2550,6 +2772,17 @@ class ArtifactService:
                 worktree_root=worktree_root,
                 start_point=parent_branch,
             )
+            reviewer_item_ids = self._normalize_string_list(
+                raw.get("reviewer_item_ids") or matched_todo.get("reviewer_item_ids")
+            )
+            manuscript_targets = self._normalize_string_list(
+                raw.get("manuscript_targets") or matched_todo.get("manuscript_targets")
+            )
+            why_now = str(raw.get("why_now") or matched_todo.get("why_now") or "").strip()
+            success_criteria = str(raw.get("success_criteria") or matched_todo.get("success_criteria") or "").strip()
+            abandonment_criteria = str(
+                raw.get("abandonment_criteria") or matched_todo.get("abandonment_criteria") or ""
+            ).strip()
             plan_dir = ensure_dir(worktree_root / "experiments" / "analysis" / campaign_id / slice_id)
             plan_path = plan_dir / "plan.md"
             requirement_lines = [
@@ -2567,6 +2800,10 @@ class ArtifactService:
                 "",
                 str(raw.get("experimental_design") or matched_todo.get("experimental_design") or "").strip() or "TBD",
                 "",
+                "## Why Now",
+                "",
+                why_now or "TBD",
+                "",
                 "## Hypothesis",
                 "",
                 str(raw.get("hypothesis") or "").strip() or "TBD",
@@ -2587,6 +2824,14 @@ class ArtifactService:
                 "",
                 str(raw.get("must_not_simplify") or "").strip() or "Full dataset / full protocol only unless explicitly approved.",
                 "",
+                "## Success Criteria",
+                "",
+                success_criteria or "TBD",
+                "",
+                "## Abandonment Criteria",
+                "",
+                abandonment_criteria or "TBD",
+                "",
                 "## Completion Condition",
                 "",
                 str(raw.get("completion_condition") or matched_todo.get("completion_condition") or "").strip()
@@ -2594,6 +2839,17 @@ class ArtifactService:
                 or "Complete the planned analysis slice and mirror the durable result back to the parent branch.",
                 "",
             ]
+            requirement_lines.extend(["## Reviewer Item IDs", ""])
+            if reviewer_item_ids:
+                requirement_lines.extend([f"- `{item}`" for item in reviewer_item_ids])
+            else:
+                requirement_lines.append("- None recorded.")
+            requirement_lines.extend(["", "## Manuscript Targets", ""])
+            if manuscript_targets:
+                requirement_lines.extend([f"- {item}" for item in manuscript_targets])
+            else:
+                requirement_lines.append("- None recorded.")
+            requirement_lines.append("")
             write_text(plan_path, "\n".join(requirement_lines))
             slice_contexts.append(
                 {
@@ -2612,20 +2868,26 @@ class ArtifactService:
                     "experimental_design": str(
                         raw.get("experimental_design") or matched_todo.get("experimental_design") or ""
                     ).strip(),
+                    "why_now": why_now,
                     "hypothesis": str(raw.get("hypothesis") or "").strip(),
                     "required_changes": str(raw.get("required_changes") or "").strip(),
                     "metric_contract": str(raw.get("metric_contract") or "").strip(),
                     "environment_notes": str(raw.get("environment_notes") or "").strip(),
                     "must_not_simplify": str(raw.get("must_not_simplify") or "").strip(),
+                    "success_criteria": success_criteria,
+                    "abandonment_criteria": abandonment_criteria,
                     "completion_condition": str(
                         raw.get("completion_condition") or matched_todo.get("completion_condition") or ""
                     ).strip(),
+                    "reviewer_item_ids": reviewer_item_ids,
+                    "manuscript_targets": manuscript_targets,
                 }
             )
 
         todo_manifest = {
             "schema_version": 1,
             "campaign_id": campaign_id,
+            "campaign_origin": normalized_campaign_origin,
             "selected_outline_ref": resolved_outline_ref,
             "research_questions": normalized_research_questions,
             "experimental_designs": normalized_experimental_designs,
@@ -2635,9 +2897,14 @@ class ArtifactService:
                     "slice_id": context["slice_id"],
                     "title": str(item.get("title") or context["title"]).strip() or context["title"],
                     "status": str(item.get("status") or "pending").strip() or "pending",
-                    "research_question": context.get("research_question") or item.get("research_question"),
-                    "experimental_design": context.get("experimental_design") or item.get("experimental_design"),
-                    "completion_condition": context.get("completion_condition") or item.get("completion_condition") or context.get("must_not_simplify"),
+                    "research_question": item.get("research_question") or context.get("research_question"),
+                    "experimental_design": item.get("experimental_design") or context.get("experimental_design"),
+                    "completion_condition": item.get("completion_condition") or context.get("completion_condition") or context.get("must_not_simplify"),
+                    "why_now": item.get("why_now") or context.get("why_now"),
+                    "success_criteria": item.get("success_criteria") or context.get("success_criteria"),
+                    "abandonment_criteria": item.get("abandonment_criteria") or context.get("abandonment_criteria"),
+                    "reviewer_item_ids": item.get("reviewer_item_ids") or context.get("reviewer_item_ids") or [],
+                    "manuscript_targets": item.get("manuscript_targets") or context.get("manuscript_targets") or [],
                 }
                 for context, item in zip(slice_contexts, normalized_todo_items + [{}] * max(0, len(slice_contexts) - len(normalized_todo_items)))
             ],
@@ -2666,6 +2933,14 @@ class ArtifactService:
             "",
             f"`{resolved_outline_ref or 'none'}`",
             "",
+            "## Campaign Origin",
+            "",
+            f"- Kind: `{(normalized_campaign_origin or {}).get('kind') or 'analysis'}`",
+            f"- Reason: {str((normalized_campaign_origin or {}).get('reason') or 'Not recorded')}",
+            f"- Source Artifact: `{str((normalized_campaign_origin or {}).get('source_artifact_id') or 'none')}`",
+            f"- Source Outline: `{str((normalized_campaign_origin or {}).get('source_outline_ref') or 'none')}`",
+            f"- Source Review Round: `{str((normalized_campaign_origin or {}).get('source_review_round') or 'none')}`",
+            "",
             "## Slices",
             "",
         ]
@@ -2681,8 +2956,13 @@ class ArtifactService:
                     f"- Goal: {item['goal'] or 'TBD'}",
                     f"- Research question: {item['research_question'] or 'TBD'}",
                     f"- Experimental design: {item['experimental_design'] or 'TBD'}",
+                    f"- Why now: {item['why_now'] or 'TBD'}",
+                    f"- Success criteria: {item['success_criteria'] or 'TBD'}",
+                    f"- Abandonment criteria: {item['abandonment_criteria'] or 'TBD'}",
                     f"- Completion condition: {item['completion_condition'] or item['must_not_simplify'] or 'TBD'}",
                     f"- Requirement: {item['must_not_simplify'] or 'TBD'}",
+                    f"- Reviewer items: {', '.join(item['reviewer_item_ids']) or 'none'}",
+                    f"- Manuscript targets: {', '.join(item['manuscript_targets']) or 'none'}",
                     "",
                 ]
             )
@@ -2697,6 +2977,7 @@ class ArtifactService:
                 "active_idea_id": active_idea_id,
                 "parent_branch": parent_branch,
                 "parent_worktree_root": str(parent_worktree_root),
+                "campaign_origin": normalized_campaign_origin,
                 "selected_outline_ref": resolved_outline_ref,
                 "research_questions": normalized_research_questions,
                 "experimental_designs": normalized_experimental_designs,
@@ -2707,6 +2988,44 @@ class ArtifactService:
                 "created_at": utc_now(),
             },
         )
+        for item in slice_contexts:
+            self.record(
+                quest_root,
+                {
+                    "kind": "milestone",
+                    "status": "prepared",
+                    "summary": f"Analysis slice `{item['slice_id']}` prepared as a child branch.",
+                    "reason": "Expose the pending follow-up branch durably so Canvas and Git lineage stay visible before execution.",
+                    "idea_id": active_idea_id,
+                    "campaign_id": campaign_id,
+                    "slice_id": item["slice_id"],
+                    "branch": item["branch"],
+                    "parent_branch": parent_branch,
+                    "worktree_root": item["worktree_root"],
+                    "worktree_rel_path": self._workspace_relative(quest_root, Path(item["worktree_root"])),
+                    "flow_type": "analysis_slice",
+                    "protocol_step": "prepare",
+                    "paths": {
+                        "plan_md": item["plan_path"],
+                    },
+                    "details": {
+                        "title": item["title"],
+                        "goal": item["goal"],
+                        "run_kind": item["run_kind"],
+                        "research_question": item["research_question"],
+                        "experimental_design": item["experimental_design"],
+                        "why_now": item["why_now"],
+                        "completion_condition": item["completion_condition"] or item["must_not_simplify"],
+                        "must_not_simplify": item["must_not_simplify"],
+                        "success_criteria": item["success_criteria"],
+                        "abandonment_criteria": item["abandonment_criteria"],
+                        "reviewer_item_ids": item["reviewer_item_ids"],
+                        "manuscript_targets": item["manuscript_targets"],
+                    },
+                },
+                checkpoint=False,
+                workspace_root=Path(item["worktree_root"]),
+            )
         first_slice = slice_contexts[0]
         artifact = self.record(
             quest_root,
@@ -2729,6 +3048,7 @@ class ArtifactService:
                     "campaign_title": campaign_title,
                     "campaign_goal": campaign_goal,
                     "parent_run_id": parent_run_id,
+                    "campaign_origin": normalized_campaign_origin,
                     "selected_outline_ref": resolved_outline_ref,
                     "todo_manifest_path": str(todo_manifest_path),
                     "slice_count": len(slice_contexts),
@@ -2742,8 +3062,13 @@ class ArtifactService:
                             "goal": item["goal"],
                             "research_question": item["research_question"],
                             "experimental_design": item["experimental_design"],
+                            "why_now": item["why_now"],
                             "completion_condition": item["completion_condition"] or item["must_not_simplify"],
                             "must_not_simplify": item["must_not_simplify"],
+                            "success_criteria": item["success_criteria"],
+                            "abandonment_criteria": item["abandonment_criteria"],
+                            "reviewer_item_ids": item["reviewer_item_ids"],
+                            "manuscript_targets": item["manuscript_targets"],
                         }
                         for item in slice_contexts
                     ],
@@ -2754,6 +3079,7 @@ class ArtifactService:
         )
         research_state = self.quest_service.update_research_state(
             quest_root,
+            active_idea_id=active_idea_id,
             active_analysis_campaign_id=campaign_id,
             analysis_parent_branch=parent_branch,
             analysis_parent_worktree_root=str(parent_worktree_root),
@@ -2785,16 +3111,17 @@ class ArtifactService:
             attachments=[
                 {
                     "kind": "analysis_campaign",
-                "campaign_id": campaign_id,
-                "parent_branch": parent_branch,
-                "parent_worktree_root": str(parent_worktree_root),
-                "selected_outline_ref": resolved_outline_ref,
-                "todo_manifest_path": str(todo_manifest_path),
-                "next_slice": first_slice,
-                "todo_items": todo_manifest["todo_items"],
-                "slices": slice_contexts,
-            }
-        ],
+                    "campaign_id": campaign_id,
+                    "parent_branch": parent_branch,
+                    "parent_worktree_root": str(parent_worktree_root),
+                    "campaign_origin": normalized_campaign_origin,
+                    "selected_outline_ref": resolved_outline_ref,
+                    "todo_manifest_path": str(todo_manifest_path),
+                    "next_slice": first_slice,
+                    "todo_items": todo_manifest["todo_items"],
+                    "slices": slice_contexts,
+                }
+            ],
         )
         return {
             "ok": True,
@@ -2807,6 +3134,7 @@ class ArtifactService:
             "campaign_id": campaign_id,
             "parent_branch": parent_branch,
             "parent_worktree_root": str(parent_worktree_root),
+            "campaign_origin": normalized_campaign_origin,
             "charter_path": str(charter_path),
             "slices": slice_contexts,
             "manifest": manifest,
@@ -3060,6 +3388,10 @@ class ArtifactService:
         evidence_paths: list[str] | None = None,
         metric_rows: list[dict[str, Any]] | None = None,
         deviations: list[str] | None = None,
+        claim_impact: str | None = None,
+        reviewer_resolution: str | None = None,
+        manuscript_update_hint: str | None = None,
+        next_recommendation: str | None = None,
         dataset_scope: str = "full",
         subset_approval_ref: str | None = None,
     ) -> dict[str, Any]:
@@ -3076,6 +3408,10 @@ 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_claim_impact = str(claim_impact or "").strip() or None
+        normalized_reviewer_resolution = str(reviewer_resolution or "").strip() or None
+        normalized_manuscript_update_hint = str(manuscript_update_hint or "").strip() or None
+        normalized_next_recommendation = str(next_recommendation or "").strip() or None
         slice_worktree_root = Path(str(target.get("worktree_root") or ""))
         parent_worktree_root = Path(str(manifest.get("parent_worktree_root") or ""))
         parent_branch = str(manifest.get("parent_branch") or "")
@@ -3104,6 +3440,22 @@ class ArtifactService:
             "",
             results.strip() or "TBD",
             "",
+            "## Claim Impact",
+            "",
+            normalized_claim_impact or "Not recorded.",
+            "",
+            "## Reviewer Resolution",
+            "",
+            normalized_reviewer_resolution or "Not recorded.",
+            "",
+            "## Manuscript Update Hint",
+            "",
+            normalized_manuscript_update_hint or "Not recorded.",
+            "",
+            "## Next Recommendation",
+            "",
+            normalized_next_recommendation or "Not recorded.",
+            "",
             "## Deviations",
             "",
         ]
@@ -3164,6 +3516,14 @@ class ArtifactService:
             "",
             results.strip() or "TBD",
             "",
+            "## Claim Impact",
+            "",
+            normalized_claim_impact or "Not recorded.",
+            "",
+            "## Manuscript Update Hint",
+            "",
+            normalized_manuscript_update_hint or "Not recorded.",
+            "",
         ]
         write_text(mirror_path, "\n".join(mirror_lines).rstrip() + "\n")
 
@@ -3197,6 +3557,10 @@ class ArtifactService:
                     "dataset_scope": normalized_scope,
                     "subset_approval_ref": subset_approval_ref,
                     "metric_rows": metric_rows,
+                    "claim_impact": normalized_claim_impact,
+                    "reviewer_resolution": normalized_reviewer_resolution,
+                    "manuscript_update_hint": normalized_manuscript_update_hint,
+                    "next_recommendation": normalized_next_recommendation,
                     "deviations": deviations,
                     "evidence_paths": evidence_paths,
                 },
@@ -3223,6 +3587,10 @@ class ArtifactService:
             updated["completed_at"] = utc_now()
             updated["result_path"] = str(result_path)
             updated["mirror_path"] = str(mirror_path)
+            updated["claim_impact"] = normalized_claim_impact
+            updated["reviewer_resolution"] = normalized_reviewer_resolution
+            updated["manuscript_update_hint"] = normalized_manuscript_update_hint
+            updated["next_recommendation"] = normalized_next_recommendation
             updated_slices.append(updated)
         next_slice = next((item for item in updated_slices if str(item.get("status") or "") == "pending"), None)
         manifest = self._write_analysis_manifest(
@@ -3336,12 +3704,14 @@ class ArtifactService:
             parent_worktree_root,
             message=f"analysis: summarize {campaign_id}",
         )
+        restored_idea_id = self._latest_branch_idea_id(quest_root, parent_branch) or str(manifest.get("active_idea_id") or "").strip() or None
         research_state = self.quest_service.update_research_state(
             quest_root,
+            active_idea_id=restored_idea_id,
             active_analysis_campaign_id=None,
             next_pending_slice_id=None,
-            current_workspace_branch=state.get("research_head_branch") or parent_branch,
-            current_workspace_root=state.get("research_head_worktree_root") or str(parent_worktree_root),
+            current_workspace_branch=parent_branch,
+            current_workspace_root=str(parent_worktree_root),
             workspace_mode="idea",
             last_flow_type="analysis_campaign_complete",
         )
@@ -3789,6 +4159,8 @@ class ArtifactService:
         expects_reply: bool | None = None,
         reply_mode: str | None = None,
         options: list[dict[str, Any]] | None = None,
+        surface_actions: list[dict[str, Any]] | None = None,
+        connector_hints: dict[str, Any] | None = None,
         allow_free_text: bool = True,
         reply_schema: dict[str, Any] | None = None,
         reply_to_interaction_id: str | None = None,
@@ -3801,6 +4173,9 @@ class ArtifactService:
             "approval_result": "approval",
         }.get(kind, "progress")
         options_resolved = options or []
+        surface_actions_resolved = [dict(item) for item in (surface_actions or []) if isinstance(item, dict)]
+        connector_hints_resolved = self._normalize_connector_hints(connector_hints)
+        attachments_resolved, attachment_issues = self._normalize_interaction_attachments(quest_root, attachments)
         reply_schema_resolved = reply_schema if isinstance(reply_schema, dict) else {}
         reply_mode_resolved = str(
             reply_mode
@@ -3860,10 +4235,14 @@ class ArtifactService:
                 "expects_reply": False,
                 "reply_mode": "none",
                 "delivered": False,
+                "delivery_results": [],
                 "response_phase": response_phase,
                 "delivery_targets": [],
                 "delivery_policy": self._delivery_policy(self._connectors_config()),
                 "preferred_connector": self._preferred_connector(self._connectors_config()),
+                "connector_hints": connector_hints_resolved,
+                "normalized_attachments": attachments_resolved,
+                "attachment_issues": attachment_issues,
                 "recent_inbound_messages": mailbox_payload.get("recent_inbound_messages") or [],
                 "delivery_batch": mailbox_payload.get("delivery_batch"),
                 "recent_interaction_records": mailbox_payload.get("recent_interaction_records") or [],
@@ -3889,11 +4268,13 @@ class ArtifactService:
             "summary": message,
             "interaction_phase": "request" if kind == "decision_request" else response_phase,
             "importance": importance,
-            "attachments": attachments or [],
+            "attachments": attachments_resolved,
             "interaction_id": resolved_interaction_id,
             "expects_reply": expects_reply_resolved,
             "reply_mode": reply_mode_resolved,
             "options": options_resolved,
+            "surface_actions": surface_actions_resolved,
+            "connector_hints": connector_hints_resolved,
             "allow_free_text": allow_free_text,
             "reply_schema": reply_schema_resolved,
             "reply_to_interaction_id": reply_to_interaction_id,
@@ -3929,6 +4310,7 @@ class ArtifactService:
         )
         delivery_targets: list[str] = []
         delivered = False
+        delivery_results: list[dict[str, Any]] = []
         if deliver_to_bound_conversations:
             connectors = self._connectors_config()
             targets = self._select_delivery_targets(
@@ -3950,12 +4332,17 @@ class ArtifactService:
                     "expects_reply": expects_reply_resolved,
                     "reply_mode": reply_mode_resolved,
                     "options": options_resolved,
+                    "surface_actions": surface_actions_resolved,
+                    "connector_hints": connector_hints_resolved,
                     "allow_free_text": allow_free_text,
                     "reply_schema": reply_schema_resolved,
                     "reply_to_interaction_id": reply_to_interaction_id,
-                    "attachments": attachments or [],
+                    "attachments": attachments_resolved,
                 }
-                if self._send_to_channel(channel_name, payload, connectors=connectors):
+                delivery_result = self._deliver_to_channel(channel_name, payload, connectors=connectors)
+                delivery_result["conversation_id"] = target
+                delivery_results.append(delivery_result)
+                if delivery_result.get("ok", False) or delivery_result.get("queued", False):
                     delivery_targets.append(target)
                     delivered = True
 
@@ -3985,6 +4372,8 @@ class ArtifactService:
             message=message,
             response_phase=response_phase,
             reply_mode=reply_mode_resolved,
+            surface_actions=surface_actions_resolved,
+            connector_hints=connector_hints_resolved,
             created_at=(artifact.get("record") or {}).get("updated_at"),
         )
 
@@ -3994,7 +4383,12 @@ class ArtifactService:
             "interaction_id": request_state.get("interaction_id"),
             "expects_reply": expects_reply_resolved,
             "reply_mode": reply_mode_resolved,
+            "surface_actions": surface_actions_resolved,
+            "connector_hints": connector_hints_resolved,
+            "normalized_attachments": attachments_resolved,
+            "attachment_issues": attachment_issues,
             "delivered": delivered,
+            "delivery_results": delivery_results,
             "response_phase": response_phase,
             "delivery_targets": delivery_targets,
             "delivery_policy": self._delivery_policy(self._connectors_config()),
@@ -4296,6 +4690,67 @@ class ArtifactService:
             return enabled[0]
         return None
 
+    @staticmethod
+    def _normalize_connector_hints(connector_hints: dict[str, Any] | None) -> dict[str, Any]:
+        if not isinstance(connector_hints, dict):
+            return {}
+        normalized: dict[str, Any] = {}
+        for key, value in connector_hints.items():
+            name = str(key or "").strip().lower()
+            if not name or not isinstance(value, dict):
+                continue
+            normalized[name] = dict(value)
+        return normalized
+
+    def _normalize_interaction_attachments(
+        self,
+        quest_root: Path,
+        attachments: list[dict[str, Any]] | None,
+    ) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+        normalized: list[dict[str, Any]] = []
+        issues: list[dict[str, Any]] = []
+        for index, raw_item in enumerate(attachments or [], start=1):
+            if not isinstance(raw_item, dict):
+                issues.append(
+                    {
+                        "attachment_index": index,
+                        "error": "attachment must be an object",
+                    }
+                )
+                continue
+            item = dict(raw_item)
+            path_value = str(item.get("path") or "").strip()
+            if path_value:
+                resolved_path = Path(path_value).expanduser()
+                if not resolved_path.is_absolute():
+                    resolved_path = (quest_root / resolved_path).resolve()
+                else:
+                    resolved_path = resolved_path.resolve()
+                item["path"] = str(resolved_path)
+                if not resolved_path.exists():
+                    item["path_error"] = "path_not_found"
+                    issues.append(
+                        {
+                            "attachment_index": index,
+                            "path": str(resolved_path),
+                            "error": "attachment path does not exist",
+                        }
+                    )
+            connector_delivery = item.get("connector_delivery")
+            if isinstance(connector_delivery, dict):
+                normalized_delivery: dict[str, Any] = {}
+                for key, value in connector_delivery.items():
+                    name = str(key or "").strip().lower()
+                    if not name or not isinstance(value, dict):
+                        continue
+                    normalized_delivery[name] = dict(value)
+                if normalized_delivery:
+                    item["connector_delivery"] = normalized_delivery
+                else:
+                    item.pop("connector_delivery", None)
+            normalized.append(item)
+        return normalized, issues
+
     def _select_delivery_targets(self, targets: list[str], *, connectors: dict[str, Any]) -> list[str]:
         if not targets:
             return ["local:default"]
@@ -4445,6 +4900,11 @@ class ArtifactService:
                 "transport": transport,
                 "response_phase": str(payload.get("response_phase") or "").strip() or None,
                 "importance": str(payload.get("importance") or "").strip() or None,
+                "artifact_id": str(payload.get("artifact_id") or "").strip() or None,
+                "interaction_id": str(payload.get("interaction_id") or "").strip() or None,
+                "surface_actions": payload.get("surface_actions") if isinstance(payload.get("surface_actions"), list) else [],
+                "connector_hints": payload.get("connector_hints") if isinstance(payload.get("connector_hints"), dict) else {},
+                "delivery_parts": delivery.get("parts") if isinstance(delivery.get("parts"), list) else [],
                 "error": str(result.get("error") or delivery.get("error") or "").strip() or None,
                 "created_at": utc_now(),
             },