@researai/deepscientist 1.5.9 → 1.5.11

package/src/deepscientist/artifact/service.py

@@ -5,6 +5,7 @@ import shutil
 from pathlib import Path
 from typing import Any
 
+from ..arxiv_library import ArxivLibraryService
 from ..bridges import register_builtin_connector_bridges
 from ..channels import get_channel_factory, register_builtin_channels
 from ..config import ConfigManager
@@ -38,7 +39,7 @@ from ..shared import (
 )
 from ..quest import QuestService
 from ..memory.frontmatter import dump_markdown_document, load_markdown_document
-from .arxiv import read_arxiv_content
+from .arxiv import fetch_arxiv_metadata, read_arxiv_content
 from .guidance import build_guidance_for_record, guidance_summary
 from .metrics import (
     baseline_metric_lines,
@@ -96,16 +97,77 @@ class ArtifactService:
         self.home = home
         self.baselines = BaselineRegistry(home)
         self.quest_service = QuestService(home)
+        self.arxiv_library = ArxivLibraryService()
 
     @staticmethod
-    def _notification_text(value: object, *, limit: int = 220) -> str | None:
-        text = str(value or "").strip()
-        if not text:
+    def _notification_text(value: object) -> str | None:
+        text = str(value or "")
+        if not text.strip():
             return None
-        text = re.sub(r"\s+", " ", text)
-        if len(text) <= limit:
-            return text
-        return text[: limit - 1].rstrip() + "…"
+        normalized_lines: list[str] = []
+        for raw_line in text.replace("\r\n", "\n").replace("\r", "\n").split("\n"):
+            cleaned = re.sub(r"[ \t]+", " ", raw_line).strip()
+            if not cleaned:
+                if normalized_lines and normalized_lines[-1] != "":
+                    normalized_lines.append("")
+                continue
+            normalized_lines.append(cleaned)
+        while normalized_lines and normalized_lines[-1] == "":
+            normalized_lines.pop()
+        rendered = "\n".join(normalized_lines).strip()
+        return rendered or None
+
+    @classmethod
+    def _notification_block(cls, value: object) -> str | None:
+        if value is None:
+            return None
+        if isinstance(value, dict):
+            lines: list[str] = []
+            for key, item in value.items():
+                label = cls._format_route_label(key) or str(key).strip()
+                block = cls._notification_block(item)
+                if not label or not block:
+                    continue
+                block_lines = block.splitlines()
+                if len(block_lines) == 1:
+                    lines.append(f"- {label}: {block_lines[0]}")
+                    continue
+                lines.append(f"- {label}:")
+                lines.extend(f"  {line}" if line else "" for line in block_lines)
+            return "\n".join(lines).strip() or None
+        if isinstance(value, (list, tuple, set)):
+            lines = []
+            for item in value:
+                block = cls._notification_block(item)
+                if not block:
+                    continue
+                block_lines = block.splitlines()
+                if not block_lines:
+                    continue
+                lines.append(f"- {block_lines[0]}")
+                lines.extend(f"  {line}" if line else "" for line in block_lines[1:])
+            return "\n".join(lines).strip() or None
+        return cls._notification_text(value)
+
+    @classmethod
+    def _append_notification_section(cls, lines: list[str], label: str, value: object) -> None:
+        block = cls._notification_block(value)
+        if not block:
+            return
+        lines.extend(["", f"{label}:", block])
+
+    @staticmethod
+    def _append_notification_file_section(lines: list[str], entries: list[tuple[str, str | None]]) -> None:
+        normalized = [
+            (label, str(path).strip())
+            for label, path in entries
+            if str(path or "").strip()
+        ]
+        if not normalized:
+            return
+        lines.extend(["", "Files:"])
+        for label, path in normalized:
+            lines.append(f"- {label}: `{path}`")
 
     def _normalize_evaluation_summary(self, payload: dict[str, Any] | None) -> dict[str, str] | None:
         if not isinstance(payload, dict):
@@ -180,22 +242,21 @@ class ArtifactService:
     ) -> 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)}")
+        self._append_notification_section(lines, "Title", title)
+        self._append_notification_section(lines, "Problem", problem)
+        self._append_notification_section(lines, "Hypothesis", hypothesis)
+        self._append_notification_section(lines, "Mechanism", mechanism)
         if foundation_label:
-            lines.append(f"Foundation: {foundation_label}")
+            self._append_notification_section(lines, "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}`")
+            self._append_notification_section(lines, "Next route", self._format_route_label(next_target) or next_target)
+        self._append_notification_file_section(
+            lines,
+            [
+                ("Idea doc", idea_md_rel_path),
+                ("Draft", draft_md_rel_path),
+            ],
+        )
         return "\n".join(lines)
 
     def _build_main_experiment_interaction_message(
@@ -217,6 +278,7 @@ class ArtifactService:
         result_json_rel_path: str | None,
     ) -> str:
         lines = [f"Main experiment `{run_id}` finished on branch `{branch_name}`."]
+        outcome_lines: list[str] = []
         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:
@@ -224,27 +286,31 @@ class ArtifactService:
                     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}")
+            outcome_lines.append(f"- Metric: {metric_text}")
+        outcome_lines.append(f"- Verdict: {self._format_route_label(verdict) or verdict}")
         if self._notification_text(breakthrough_level):
-            lines.append(f"Breakthrough level: {self._notification_text(breakthrough_level)}")
+            outcome_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}"
+            outcome_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}`")
+        if outcome_lines:
+            lines.extend(["", "Outcome:", *outcome_lines])
+        self._append_notification_section(
+            lines,
+            "Conclusion",
+            self._notification_text(conclusion) or (evaluation_summary or {}).get("takeaway"),
+        )
+        normalized_evaluation_summary = self._normalize_evaluation_summary(evaluation_summary)
+        if normalized_evaluation_summary:
+            lines.extend(["", "Evaluation summary:", *self._evaluation_summary_markdown_lines(normalized_evaluation_summary)])
+        self._append_notification_file_section(
+            lines,
+            [
+                ("Run log", run_md_rel_path),
+                ("Result", result_json_rel_path),
+            ],
+        )
         return "\n".join(lines)
 
     def _build_outline_interaction_message(
@@ -263,23 +329,24 @@ class ArtifactService:
     ) -> 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}`")
+        self._append_notification_section(lines, "Title", title)
+        self._append_notification_section(lines, "Reason", selected_reason)
+        self._append_notification_section(lines, "Story", story)
+        self._append_notification_section(lines, "Research questions", research_questions)
+        self._append_notification_section(lines, "Experimental designs", experimental_designs)
+        self._append_notification_section(
+            lines,
+            "Next route",
+            "Continue writing on the paper branch, or launch outline-bound analysis if evidence is still missing.",
+        )
+        self._append_notification_file_section(
+            lines,
+            [
+                ("Selected outline", selected_outline_rel_path),
+                ("Selection note", outline_selection_rel_path),
+                ("Revision record", revised_outline_rel_path),
+            ],
+        )
         return "\n".join(lines)
 
     def _build_analysis_campaign_interaction_message(
@@ -293,20 +360,20 @@ class ArtifactService:
         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)}")
+        self._append_notification_section(lines, "Goal", 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')}`"
-        )
+            self._append_notification_section(lines, "Selected outline", f"`{selected_outline_ref}`")
+        next_slice_lines = [
+            f"- Slice: `{first_slice.get('slice_id')}`",
+            f"- 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'))}")
+            next_slice_lines.append(f"- Focus: {self._notification_text(first_slice.get('title'))}")
+        lines.extend(["", "Next slice:", *next_slice_lines])
         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}`")
+            self._append_notification_section(lines, "Core requirement", requirement)
+        self._append_notification_file_section(lines, [("Todo manifest", todo_manifest_rel_path)])
         return "\n".join(lines)
 
     def _build_analysis_slice_interaction_message(
@@ -320,19 +387,22 @@ class ArtifactService:
         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')}`"
+        normalized_evaluation_summary = self._normalize_evaluation_summary(evaluation_summary)
+        if normalized_evaluation_summary:
+            lines.extend(["", "Evaluation summary:", *self._evaluation_summary_markdown_lines(normalized_evaluation_summary)])
+        self._append_notification_section(lines, "Claim impact", claim_impact)
+        lines.extend(
+            [
+                "",
+                "Next slice:",
+                f"- Slice: `{next_slice.get('slice_id')}`",
+                f"- 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}`")
+            self._append_notification_section(lines, "Core requirement", requirement)
+        self._append_notification_file_section(lines, [("Parent mirror", mirror_rel_path)])
         return "\n".join(lines)
 
     def _build_analysis_complete_interaction_message(
@@ -345,33 +415,89 @@ class ArtifactService:
         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}`")
+        overview_lines = [f"- Completed slices: {len(completed_slices)}"]
         if writing_branch:
-            lines.append(f"Next route: writing is active on branch `{writing_branch}`")
+            overview_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}`")
+                overview_lines.append(f"- Writing workspace: `{writing_worktree_rel_path}`")
         else:
-            lines.append("Next route: make the next durable decision from the merged analysis evidence.")
+            overview_lines.append("- Next route: make the next durable decision from the merged analysis evidence.")
+        lines.extend(["", "Overview:", *overview_lines])
+        completed_slice_lines: list[str] = []
+        for item in completed_slices:
+            slice_id = str(item.get("slice_id") or "").strip() or "unknown"
+            title = self._notification_text(item.get("title"))
+            lead = f"- `{slice_id}`"
+            if title:
+                lead += f": {title}"
+            completed_slice_lines.append(lead)
+            takeaway = self._notification_text(
+                ((item.get("evaluation_summary") or {}) if isinstance(item.get("evaluation_summary"), dict) else {}).get(
+                    "takeaway"
+                )
+            )
+            if takeaway:
+                completed_slice_lines.append(f"  Takeaway: {takeaway}")
+            claim_impact = self._notification_text(item.get("claim_impact"))
+            if claim_impact:
+                completed_slice_lines.append(f"  Claim impact: {claim_impact}")
+        if completed_slice_lines:
+            lines.extend(["", "Completed slices:", *completed_slice_lines])
+        self._append_notification_file_section(lines, [("Summary", summary_rel_path)])
+        return "\n".join(lines)
+
+    def _build_paper_bundle_interaction_message(
+        self,
+        *,
+        title: str | None,
+        summary: str | None,
+        paper_branch: str | None,
+        source_branch: str | None,
+        source_run_id: str | None,
+        selected_outline_ref: str | None,
+        manifest_rel_path: str | None,
+        draft_rel_path: str | None,
+        writing_plan_rel_path: str | None,
+        references_rel_path: str | None,
+        claim_evidence_map_rel_path: str | None,
+        compile_report_rel_path: str | None,
+        pdf_rel_path: str | None,
+        latex_root_rel_path: str | None,
+        baseline_inventory_rel_path: str | None,
+        open_source_manifest_rel_path: str | None,
+    ) -> str:
+        bundle_label = self._notification_text(title) or "paper"
+        lines = [f"Paper bundle `{bundle_label}` is ready on branch `{paper_branch or 'paper'}`."]
+        overview_lines: list[str] = []
+        if source_branch:
+            overview_lines.append(f"- Source branch: `{source_branch}`")
+        if source_run_id:
+            overview_lines.append(f"- Source run: `{source_run_id}`")
+        if selected_outline_ref:
+            overview_lines.append(f"- Selected outline: `{selected_outline_ref}`")
+        if overview_lines:
+            lines.extend(["", "Overview:", *overview_lines])
+        self._append_notification_section(lines, "Summary", summary)
+        self._append_notification_file_section(
+            lines,
+            [
+                ("Bundle manifest", manifest_rel_path),
+                ("Draft", draft_rel_path),
+                ("Writing plan", writing_plan_rel_path),
+                ("References", references_rel_path),
+                ("Claim-evidence map", claim_evidence_map_rel_path),
+                ("Compile report", compile_report_rel_path),
+                ("PDF", pdf_rel_path),
+                ("LaTeX root", latex_root_rel_path),
+                ("Baseline inventory", baseline_inventory_rel_path),
+                ("Open-source manifest", open_source_manifest_rel_path),
+            ],
+        )
+        self._append_notification_section(
+            lines,
+            "Next route",
+            "Finalize the paper package, review the bundle artifacts, and publish or close the quest when ready.",
+        )
         return "\n".join(lines)
 
     def _load_metric_contract_payload(self, quest_root: Path, metric_contract_json_rel_path: str | None) -> dict[str, Any] | None:
@@ -2893,8 +3019,296 @@ class ArtifactService:
             deduped.append(path)
         return deduped
 
-    def arxiv(self, paper_id: str, *, full_text: bool = False) -> dict[str, Any]:
-        return read_arxiv_content(paper_id, full_text=full_text)
+    @staticmethod
+    def _arxiv_content_from_item(item: dict[str, Any]) -> str:
+        title = str(item.get("title") or item.get("display_name") or item.get("arxiv_id") or "arXiv paper").strip()
+        authors = [str(author).strip() for author in (item.get("authors") or []) if str(author).strip()]
+        categories = [str(category).strip() for category in (item.get("categories") or []) if str(category).strip()]
+        abstract = str(item.get("abstract") or "").strip() or "Abstract unavailable."
+        overview = str(item.get("overview") or "").strip()
+        lines = [f"# {title}", "", f"- paper_id: {str(item.get('arxiv_id') or '').strip()}"]
+        if item.get("metadata_source"):
+            lines.append(f"- metadata_source: {item['metadata_source']}")
+        if item.get("summary_source"):
+            lines.append(f"- summary_source: {item['summary_source']}")
+        if authors:
+            lines.append(f"- authors: {', '.join(authors)}")
+        if categories:
+            lines.append(f"- categories: {', '.join(categories)}")
+        if item.get("published_at"):
+            lines.append(f"- published_at: {item['published_at']}")
+        if item.get("version") is not None:
+            lines.append(f"- version: v{item['version']}")
+        if overview:
+            lines.extend(["", "## Summary", "", overview])
+            if abstract and abstract != overview:
+                lines.extend(["", "## Abstract", "", abstract])
+        else:
+            lines.extend(["", "## Abstract", "", abstract])
+        return "\n".join(lines).strip()
+
+    @staticmethod
+    def _arxiv_item_needs_refresh(item: dict[str, Any] | None) -> bool:
+        if not isinstance(item, dict):
+            return False
+        title = str(item.get("title") or "").strip()
+        lowered_title = title.lower()
+        authors = item.get("authors") or []
+        categories = item.get("categories") or []
+        published_at = str(item.get("published_at") or "").strip()
+        metadata_source = str(item.get("metadata_source") or "").strip()
+        bibtex = str(item.get("bibtex") or "").strip()
+        overview = str(item.get("overview") or "").strip()
+        overview_markdown = str(item.get("overview_markdown") or "").strip()
+        overview_source = str(item.get("overview_source") or "").strip()
+        return (
+            not title
+            or title.startswith("#")
+            or lowered_title.startswith("research paper analysis")
+            or lowered_title.startswith("## research paper analysis")
+            or not authors
+            or not categories
+            or not published_at
+            or not metadata_source
+            or not bibtex
+            or (not overview and not overview_markdown and not overview_source)
+        )
+
+    def _refresh_arxiv_item_metadata(self, quest_root: Path, item: dict[str, Any]) -> dict[str, Any]:
+        arxiv_id = str(item.get("arxiv_id") or "").strip()
+        if not arxiv_id:
+            return item
+        metadata = fetch_arxiv_metadata(arxiv_id)
+        if not metadata.get("ok"):
+            return item
+        summary = read_arxiv_content(arxiv_id, full_text=False)
+        summary_source = summary.get("summary_source") if summary.get("ok") else None
+        overview_source = summary.get("overview_source") if summary.get("ok") else None
+        return self.arxiv_library.upsert_item(
+            quest_root,
+            {
+                **item,
+                "arxiv_id": metadata.get("paper_id") or arxiv_id,
+                "title": metadata.get("title") or item.get("title") or arxiv_id,
+                "display_name": metadata.get("title") or item.get("display_name") or arxiv_id,
+                "authors": metadata.get("authors") or item.get("authors") or [],
+                "categories": metadata.get("categories") or item.get("categories") or [],
+                "abstract": metadata.get("abstract") or item.get("abstract") or "",
+                "published_at": metadata.get("published_at") or item.get("published_at") or "",
+                "version": metadata.get("version") if metadata.get("version") is not None else item.get("version"),
+                "primary_class": metadata.get("primary_class") or item.get("primary_class") or "",
+                "metadata_source": metadata.get("metadata_source") or item.get("metadata_source"),
+                "metadata_status": "ready",
+                "overview": summary.get("overview") or item.get("overview") or "",
+                "overview_markdown": summary.get("overview_markdown") or item.get("overview_markdown") or "",
+                "summary_source": summary_source or item.get("summary_source"),
+                "overview_source": overview_source or summary_source or item.get("overview_source"),
+                "bibtex": metadata.get("bibtex") or item.get("bibtex"),
+                "abs_url": metadata.get("abs_url") or item.get("abs_url"),
+                "pdf_url": metadata.get("pdf_url") or item.get("pdf_url"),
+            },
+        )
+
+    @staticmethod
+    def _arxiv_file_payload(quest_root: Path, item: dict[str, Any]) -> dict[str, Any]:
+        relative = str(item.get("path") or "").strip()
+        if not relative:
+            return {}
+        document_id = str(item.get("document_id") or f"questpath::{relative}").strip()
+        return {
+            "path": relative,
+            "document_id": document_id,
+            "pdf_rel_path": relative,
+            "pdf_url": f"/api/quests/{quest_root.name}/documents/asset?document_id={document_id}",
+        }
+
+    def arxiv(
+        self,
+        paper_id: str | None = None,
+        *,
+        full_text: bool = False,
+        mode: str = "read",
+        quest_root: Path | None = None,
+    ) -> dict[str, Any]:
+        normalized_mode = str(mode or "read").strip().lower() or "read"
+        if normalized_mode == "list":
+            if quest_root is None:
+                return {
+                    "ok": False,
+                    "mode": "list",
+                    "error": "`quest_root` is required for `artifact.arxiv(mode='list')`.",
+                }
+            items = self.arxiv_library.list_items(quest_root)
+            refreshed_any = False
+            for item in items[:]:
+                if not self._arxiv_item_needs_refresh(item):
+                    continue
+                refreshed = self._refresh_arxiv_item_metadata(quest_root, item)
+                if refreshed != item:
+                    refreshed_any = True
+            if refreshed_any:
+                items = self.arxiv_library.list_items(quest_root)
+            return {
+                "ok": True,
+                "mode": "list",
+                "items": items,
+                "count": len(items),
+            }
+
+        if paper_id is None:
+            return {
+                "ok": False,
+                "mode": normalized_mode,
+                "error": "`paper_id` is required for `artifact.arxiv(mode='read')`.",
+            }
+
+        if quest_root is None:
+            return {
+                **read_arxiv_content(paper_id, full_text=full_text),
+                "mode": normalized_mode,
+            }
+
+        entry = self.arxiv_library.mark_processing(quest_root, paper_id)
+        cached_entry = self.arxiv_library.get_item(quest_root, paper_id)
+        if cached_entry and self._arxiv_item_needs_refresh(cached_entry):
+            refreshed = self._refresh_arxiv_item_metadata(quest_root, cached_entry)
+            if refreshed:
+                cached_entry = refreshed
+        if (
+            cached_entry
+            and not full_text
+            and cached_entry.get("abstract")
+            and (cached_entry.get("summary_source") or cached_entry.get("metadata_status") == "pending")
+        ):
+            paper_ref = str(cached_entry.get("arxiv_id") or paper_id).strip()
+            self.arxiv_library.queue_pdf_download(quest_root, str(cached_entry.get("arxiv_id") or paper_id))
+            return {
+                "ok": True,
+                "mode": normalized_mode,
+                "paper_id": paper_ref,
+                "requested_full_text": full_text,
+                "content_mode": "abstract",
+                "source": "quest_arxiv_library",
+                "source_url": f"https://arxiv.org/abs/{paper_ref}",
+                "title": cached_entry.get("title"),
+                "authors": cached_entry.get("authors") or [],
+                "categories": cached_entry.get("categories") or [],
+                "abstract": cached_entry.get("abstract") or "",
+                "overview": cached_entry.get("overview") or "",
+                "overview_markdown": cached_entry.get("overview_markdown") or "",
+                "summary_source": cached_entry.get("summary_source"),
+                "overview_source": cached_entry.get("overview_source"),
+                "metadata_source": cached_entry.get("metadata_source"),
+                "published_at": cached_entry.get("published_at") or "",
+                "version": cached_entry.get("version"),
+                "primary_class": cached_entry.get("primary_class") or "",
+                "bibtex": cached_entry.get("bibtex") or "",
+                "status": cached_entry.get("status"),
+                "metadata_status": cached_entry.get("metadata_status"),
+                "abs_url": f"https://arxiv.org/abs/{paper_ref}",
+                "pdf_url": f"https://arxiv.org/pdf/{paper_ref}.pdf",
+                "content": self._arxiv_content_from_item(cached_entry),
+                "attempts": [],
+                **self._arxiv_file_payload(quest_root, cached_entry),
+            }
+
+        fetched = read_arxiv_content(str(entry.get("arxiv_id") or paper_id), full_text=full_text)
+        if not fetched.get("ok"):
+            normalized_id = str(entry.get("arxiv_id") or paper_id).strip()
+            placeholder = self.arxiv_library.upsert_item(
+                quest_root,
+                {
+                    **(cached_entry or {}),
+                    "arxiv_id": normalized_id,
+                    "title": str((cached_entry or {}).get("title") or normalized_id).strip(),
+                    "display_name": str((cached_entry or {}).get("display_name") or normalized_id).strip(),
+                    "status": str((cached_entry or {}).get("status") or "processing").strip() or "processing",
+                    "metadata_status": "pending",
+                    "error": None,
+                    "pdf_rel_path": self.arxiv_library.pdf_relative_path(normalized_id),
+                    "abs_url": str((cached_entry or {}).get("abs_url") or f"https://arxiv.org/abs/{normalized_id}"),
+                    "pdf_url": str((cached_entry or {}).get("pdf_url") or f"https://arxiv.org/pdf/{normalized_id}.pdf"),
+                },
+            )
+            self.arxiv_library.queue_pdf_download(
+                quest_root,
+                normalized_id,
+                pdf_url=str(placeholder.get("pdf_url") or "").strip() or None,
+            )
+            latest = self.arxiv_library.get_item(quest_root, normalized_id) or placeholder
+            return {
+                "ok": True,
+                "mode": normalized_mode,
+                "paper_id": normalized_id,
+                "requested_full_text": full_text,
+                "content_mode": "pending",
+                "source": "quest_arxiv_library_partial",
+                "source_url": latest.get("abs_url") or f"https://arxiv.org/abs/{normalized_id}",
+                "title": latest.get("title"),
+                "authors": latest.get("authors") or [],
+                "categories": latest.get("categories") or [],
+                "abstract": latest.get("abstract") or "",
+                "overview": latest.get("overview") or "",
+                "overview_markdown": latest.get("overview_markdown") or "",
+                "summary_source": latest.get("summary_source"),
+                "overview_source": latest.get("overview_source"),
+                "metadata_source": latest.get("metadata_source"),
+                "published_at": latest.get("published_at") or "",
+                "version": latest.get("version"),
+                "primary_class": latest.get("primary_class") or "",
+                "bibtex": latest.get("bibtex") or "",
+                "status": latest.get("status"),
+                "metadata_status": "pending",
+                "metadata_pending": True,
+                "message": "Metadata is temporarily unavailable. Open the arXiv link directly while DeepScientist retries later.",
+                "abs_url": latest.get("abs_url") or f"https://arxiv.org/abs/{normalized_id}",
+                "pdf_url": latest.get("pdf_url") or f"https://arxiv.org/pdf/{normalized_id}.pdf",
+                "content": self._arxiv_content_from_item(latest),
+                "attempts": fetched.get("attempts") or [],
+                "guidance": fetched.get("guidance"),
+                **self._arxiv_file_payload(quest_root, latest),
+            }
+
+        saved = self.arxiv_library.upsert_item(
+            quest_root,
+            {
+                **(cached_entry or {}),
+                "arxiv_id": fetched.get("paper_id") or str(entry.get("arxiv_id") or paper_id),
+                "title": fetched.get("title") or cached_entry.get("title") if cached_entry else fetched.get("title"),
+                "authors": fetched.get("authors") or (cached_entry.get("authors") if cached_entry else []),
+                "categories": fetched.get("categories") or (cached_entry.get("categories") if cached_entry else []),
+                "abstract": fetched.get("abstract") or (cached_entry.get("abstract") if cached_entry else ""),
+                "overview": fetched.get("overview") or (cached_entry.get("overview") if cached_entry else ""),
+                "overview_markdown": fetched.get("overview_markdown") or (cached_entry.get("overview_markdown") if cached_entry else ""),
+                "summary_source": fetched.get("summary_source") or (cached_entry.get("summary_source") if cached_entry else None),
+                "overview_source": fetched.get("overview_source") or (cached_entry.get("overview_source") if cached_entry else None),
+                "metadata_source": fetched.get("metadata_source") or (cached_entry.get("metadata_source") if cached_entry else None),
+                "published_at": fetched.get("published_at") or (cached_entry.get("published_at") if cached_entry else ""),
+                "version": fetched.get("version") if fetched.get("version") is not None else (cached_entry.get("version") if cached_entry else None),
+                "primary_class": fetched.get("primary_class") or (cached_entry.get("primary_class") if cached_entry else ""),
+                "bibtex": fetched.get("bibtex") or (cached_entry.get("bibtex") if cached_entry else None),
+                "abs_url": fetched.get("abs_url") or (cached_entry.get("abs_url") if cached_entry else None),
+                "pdf_url": fetched.get("pdf_url") or (cached_entry.get("pdf_url") if cached_entry else None),
+                "display_name": fetched.get("title") or fetched.get("paper_id") or str(entry.get("arxiv_id") or paper_id),
+                "pdf_rel_path": self.arxiv_library.pdf_relative_path(str(fetched.get("paper_id") or entry.get("arxiv_id") or paper_id)),
+                "status": "processing",
+                "metadata_status": "ready",
+                "error": None,
+            },
+        )
+        self.arxiv_library.queue_pdf_download(
+            quest_root,
+            str(saved.get("arxiv_id") or paper_id),
+            pdf_url=str(fetched.get("pdf_url") or "").strip() or None,
+        )
+        latest = self.arxiv_library.get_item(quest_root, str(saved.get("arxiv_id") or paper_id)) or saved
+        return {
+            **fetched,
+            "mode": normalized_mode,
+            "status": latest.get("status"),
+            "metadata_status": latest.get("metadata_status"),
+            **self._arxiv_file_payload(quest_root, latest),
+        }
 
     def record(
         self,
@@ -5349,6 +5763,50 @@ class ArtifactService:
             checkpoint=False,
             workspace_root=workspace_root,
         )
+        interaction = self.interact(
+            quest_root,
+            kind="milestone",
+            message=self._build_paper_bundle_interaction_message(
+                title=str(manifest.get("title") or "").strip() or None,
+                summary=str(manifest.get("summary") or "").strip() or None,
+                paper_branch=paper_branch,
+                source_branch=source_branch,
+                source_run_id=source_run_id,
+                selected_outline_ref=str(manifest.get("selected_outline_ref") or "").strip() or None,
+                manifest_rel_path=self._workspace_relative(quest_root, manifest_path),
+                draft_rel_path=str(manifest.get("draft_path") or "").strip() or None,
+                writing_plan_rel_path=str(manifest.get("writing_plan_path") or "").strip() or None,
+                references_rel_path=str(manifest.get("references_path") or "").strip() or None,
+                claim_evidence_map_rel_path=str(manifest.get("claim_evidence_map_path") or "").strip() or None,
+                compile_report_rel_path=str(manifest.get("compile_report_path") or "").strip() or None,
+                pdf_rel_path=str(manifest.get("pdf_path") or "").strip() or None,
+                latex_root_rel_path=str(manifest.get("latex_root_path") or "").strip() or None,
+                baseline_inventory_rel_path=paper_inventory_rel,
+                open_source_manifest_rel_path=str(manifest.get("open_source_manifest_path") or "").strip() or None,
+            ),
+            deliver_to_bound_conversations=True,
+            include_recent_inbound_messages=False,
+            attachments=[
+                {
+                    "kind": "paper_bundle",
+                    "title": manifest.get("title"),
+                    "paper_branch": paper_branch,
+                    "source_branch": source_branch,
+                    "source_run_id": source_run_id,
+                    "selected_outline_ref": manifest.get("selected_outline_ref"),
+                    "manifest_path": str(manifest_path),
+                    "draft_path": manifest.get("draft_path"),
+                    "writing_plan_path": manifest.get("writing_plan_path"),
+                    "references_path": manifest.get("references_path"),
+                    "claim_evidence_map_path": manifest.get("claim_evidence_map_path"),
+                    "compile_report_path": manifest.get("compile_report_path"),
+                    "pdf_path": manifest.get("pdf_path"),
+                    "latex_root_path": manifest.get("latex_root_path"),
+                    "baseline_inventory_path": str(baseline_inventory_path),
+                    "open_source_manifest_path": str(self._open_source_manifest_path(quest_root, workspace_root=workspace_root)),
+                }
+            ],
+        )
         return {
             "ok": True,
             "manifest_path": str(manifest_path),
@@ -5356,6 +5814,7 @@ class ArtifactService:
             "baseline_inventory_path": str(baseline_inventory_path),
             "open_source_manifest_path": str(self._open_source_manifest_path(quest_root, workspace_root=workspace_root)),
             "artifact": artifact,
+            "interaction": interaction,
         }
 
     def record_analysis_slice(
@@ -6927,11 +7386,18 @@ class ArtifactService:
         return f"run/{run_id or generate_id('run')}"
 
     def _bound_conversations(self, quest_root: Path) -> list[str]:
-        state_path = quest_root / ".ds" / "bindings.json"
-        payload = read_json(state_path, {"sources": ["local:default"]})
-        sources = [self._normalize_conversation_id(str(item)) for item in (payload.get("sources") or ["local:default"])]
-        connector_sources = self._connector_bound_conversations(self._quest_id(quest_root))
-        return self._dedupe_targets([*connector_sources, *sources])
+        quest_id = self._quest_id(quest_root)
+        sources = [
+            self._normalize_conversation_id(str(item))
+            for item in self.quest_service.binding_sources(quest_id)
+        ]
+        authoritative_keys = {conversation_identity_key(item) for item in sources}
+        connector_sources = [
+            item
+            for item in self._connector_bound_conversations(quest_id)
+            if conversation_identity_key(item) in authoritative_keys
+        ]
+        return self._dedupe_targets([*sources, *connector_sources])
 
     def _connector_bound_conversations(self, quest_id: str) -> list[str]:
         root = self.home / "logs" / "connectors"