@researai/deepscientist 1.5.7 → 1.5.9

package/src/deepscientist/quest/stage_views.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import json
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from typing import Any
 
 from ..memory.frontmatter import load_markdown_document
@@ -117,7 +117,7 @@ class QuestStageViewBuilder:
         self.snapshot = dict(snapshot or {})
         self.selection = dict(selection or {})
         self.trace = dict(trace or {})
-        self.workspace_root = Path(str(self.snapshot.get("active_workspace_root") or quest_root))
+        self.workspace_root = self._resolve_workspace_root()
         self.branch_name = (
             str(
                 self.selection.get("branch_name")
@@ -135,8 +135,27 @@ class QuestStageViewBuilder:
         self.stage_status = str(self.selection.get("status") or self.trace.get("status") or "").strip() or None
         self.artifacts = sorted(list(self.quest_service._collect_artifacts(quest_root)), key=_artifact_sort_key)
 
+    def _resolve_workspace_root(self) -> Path:
+        for raw in (
+            self.selection.get("worktree_rel_path"),
+            self.trace.get("worktree_rel_path"),
+            self.selection.get("worktree_root"),
+            self.trace.get("worktree_root"),
+            self.snapshot.get("active_workspace_root"),
+        ):
+            text = str(raw or "").strip()
+            if not text:
+                continue
+            candidate = Path(text)
+            if not candidate.is_absolute():
+                candidate = (self.quest_root / text).resolve()
+            if candidate.exists():
+                return candidate
+        return self.quest_root
+
     def build(self) -> dict[str, Any]:
-        if str(self.selection.get("selection_type") or "").strip() == "branch_node":
+        selection_type = str(self.selection.get("selection_type") or "").strip()
+        if selection_type == "branch_node" and self.stage_key not in {"experiment", "analysis", "paper"}:
             return self._build_branch()
         if self.stage_key == "baseline":
             return self._build_baseline()
@@ -208,7 +227,7 @@ class QuestStageViewBuilder:
             "idea": self._idea_scope_paths(),
             "experiment": self._experiment_scope_paths(None),
             "analysis": self._analysis_scope_paths(None),
-            "paper": ["paper"],
+            "paper": self._paper_scope_paths(),
         }
         return defaults.get(self.stage_key, [])
 
@@ -314,6 +333,52 @@ class QuestStageViewBuilder:
         text = str(body or "").strip()
         return text or None
 
+    def _recent_trace_actions(self, *, limit: int = 6) -> list[dict[str, Any]]:
+        raw_actions = self.trace.get("actions") if isinstance(self.trace, dict) else []
+        if not isinstance(raw_actions, list) or not raw_actions:
+            return []
+        normalized: list[dict[str, Any]] = []
+        for item in raw_actions[-limit:]:
+            if not isinstance(item, dict):
+                continue
+            summary = _compact(item.get("summary") or item.get("output") or item.get("args"), limit=1000)
+            normalized.append(
+                {
+                    "action_id": item.get("action_id"),
+                    "title": item.get("title") or item.get("tool_name") or item.get("raw_event_type") or item.get("kind"),
+                    "summary": summary,
+                    "status": item.get("status"),
+                    "created_at": item.get("created_at"),
+                    "tool_name": item.get("tool_name"),
+                    "artifact_kind": item.get("artifact_kind"),
+                }
+            )
+        return normalized
+
+    def _trace_summary(self) -> str | None:
+        if not isinstance(self.trace, dict):
+            return None
+        return _compact(
+            self.trace.get("summary")
+            or self.selection.get("summary")
+            or self.trace.get("title"),
+            limit=600,
+        )
+
+    def _trace_markdown(self, *, limit: int = 5) -> str | None:
+        items = self._recent_trace_actions(limit=limit)
+        if not items:
+            return None
+        lines: list[str] = []
+        for item in items:
+            title = str(item.get("title") or "Trace").strip() or "Trace"
+            summary = str(item.get("summary") or "").strip()
+            if summary:
+                lines.append(f"- **{title}**: {summary}")
+            else:
+                lines.append(f"- **{title}**")
+        return "\n".join(lines) if lines else None
+
     def _file_entry(
         self,
         raw_path: object,
@@ -356,9 +421,29 @@ class QuestStageViewBuilder:
         }
 
     def _paper_bundle_manifest(self) -> dict[str, Any]:
-        payload = read_json(self.quest_root / "paper" / "paper_bundle_manifest.json", {})
+        payload = read_json(self._paper_root() / "paper_bundle_manifest.json", {})
         return payload if isinstance(payload, dict) else {}
 
+    def _paper_root(self) -> Path:
+        candidates = [self.workspace_root / "paper", self.quest_root / "paper"]
+        for candidate in candidates:
+            if candidate.exists():
+                return candidate
+        return candidates[0]
+
+    def _paper_scope_paths(self) -> list[str]:
+        try:
+            return [self._paper_root().relative_to(self.quest_root).as_posix()]
+        except ValueError:
+            return ["paper"]
+
+    def _open_source_root(self) -> Path:
+        candidates = [self.workspace_root / "release" / "open_source", self.quest_root / "release" / "open_source"]
+        for candidate in candidates:
+            if candidate.exists():
+                return candidate
+        return candidates[0]
+
     def _paper_relative_path(self, raw_path: object) -> str | None:
         resolved = self._path_in_quest(raw_path)
         if resolved is None:
@@ -370,9 +455,10 @@ class QuestStageViewBuilder:
         preferred = self._paper_relative_path(bundle_manifest.get("latex_root_path"))
         if preferred:
             return preferred
-        for candidate in ("paper/latex", "paper/tex"):
-            if (self.quest_root / candidate).exists():
-                return candidate
+        paper_root = self._paper_root()
+        for candidate in (paper_root / "latex", paper_root / "tex"):
+            if candidate.exists():
+                return candidate.relative_to(self.quest_root).as_posix()
         return None
 
     def _paper_main_tex(self, latex_root_rel: str | None) -> str | None:
@@ -401,7 +487,7 @@ class QuestStageViewBuilder:
             guessed = str(PurePosixPath(main_tex_rel).with_suffix(".pdf"))
             if (self.quest_root / guessed).exists():
                 candidates.append(guessed)
-        for path in sorted((self.quest_root / "paper").glob("*.pdf")):
+        for path in sorted(self._paper_root().glob("*.pdf")):
             candidates.append(path.relative_to(self.quest_root).as_posix())
         deduped: list[str] = []
         seen: set[str] = set()
@@ -689,6 +775,8 @@ class QuestStageViewBuilder:
             or self.snapshot.get("active_idea_draft_path")
             or str(Path(worktree_root) / "memory" / "ideas" / idea_id / "draft.md")
         )
+        idea_markdown = self._markdown_body_for_path(idea_md_path)
+        idea_md_rel_path = self._relative_path_or_raw(idea_md_path)
         draft_md_rel_path = self._relative_path_or_raw(draft_md_path)
         draft_markdown = self._markdown_body_for_path(draft_md_path)
         lineage_intent = str(payload.get("lineage_intent") or details.get("lineage_intent") or "").strip() or None
@@ -761,9 +849,12 @@ class QuestStageViewBuilder:
                     "risks": details.get("risks") or [],
                     "evidence_paths": details.get("evidence_paths") or [],
                     "lineage_intent": lineage_intent,
+                    "idea_path": idea_md_rel_path,
+                    "idea_markdown": idea_markdown,
                     "draft_path": draft_md_rel_path,
                     "draft_markdown": draft_markdown,
                     "literature_files": literature_files,
+                    "decision_reason": payload.get("reason"),
                 }
             },
             lineage_intent=lineage_intent,
@@ -830,6 +921,7 @@ class QuestStageViewBuilder:
             if isinstance(latest_experiment_payload.get("paths"), dict)
             else {}
         )
+        latest_run_markdown = self._markdown_body_for_path(latest_experiment_paths.get("run_md"))
         latest_result_payload = (
             read_json(Path(str(latest_experiment_paths.get("result_json"))), {})
             if str(latest_experiment_paths.get("result_json") or "").strip()
@@ -865,6 +957,7 @@ class QuestStageViewBuilder:
             if str(analysis_manifest.get("campaign_id") or "").strip()
             else None
         )
+        analysis_summary_markdown = self._markdown_body_for_path(analysis_summary_path)
 
         branch_items = [
             item
@@ -948,7 +1041,7 @@ class QuestStageViewBuilder:
                         description="Merged analysis summary for this branch.",
                     ),
                     self._file_entry(
-                        "paper/selected_outline.json" if (self.quest_root / "paper" / "selected_outline.json").exists() else None,
+                        (self._paper_root() / "selected_outline.json") if (self._paper_root() / "selected_outline.json").exists() else None,
                         label="Selected Outline",
                         description="Current selected paper outline.",
                     ),
@@ -969,6 +1062,11 @@ class QuestStageViewBuilder:
                     "next_target": next_target,
                     "idea_draft_path": idea_draft_rel_path,
                     "idea_draft_markdown": idea_draft_markdown,
+                    "idea_hypothesis": latest_idea_details.get("hypothesis"),
+                    "idea_mechanism": latest_idea_details.get("mechanism"),
+                    "idea_expected_gain": latest_idea_details.get("expected_gain"),
+                    "idea_risks": latest_idea_details.get("risks") or [],
+                    "decision_reason": latest_idea_payload.get("reason"),
                     "latest_main_experiment": {
                         "run_id": latest_run_id,
                         "summary": latest_experiment_payload.get("summary"),
@@ -978,10 +1076,14 @@ class QuestStageViewBuilder:
                         "progress_eval": latest_progress_eval,
                         "evaluation_summary": latest_evaluation_summary,
                         "run_md_path": latest_experiment_paths.get("run_md"),
+                        "run_markdown": latest_run_markdown,
                         "result_json_path": latest_experiment_paths.get("result_json"),
+                        "result_payload": latest_result_payload,
                     }
                     if latest_run_id
                     else None,
+                    "analysis_summary_path": self._relative_path_or_raw(analysis_summary_path),
+                    "analysis_summary_markdown": analysis_summary_markdown,
                 }
             },
             lineage_intent=lineage_intent,
@@ -1018,8 +1120,17 @@ class QuestStageViewBuilder:
         baseline_ref = payload.get("baseline_ref") or result_payload.get("baseline_ref") or {}
         evaluation_summary = _evaluation_summary(payload.get("evaluation_summary") or result_payload.get("evaluation_summary"))
         run_id = str(payload.get("run_id") or "pending").strip() or "pending"
+        run_markdown = self._markdown_body_for_path(paths.get("run_md"))
+        trace_summary = self._trace_summary()
+        trace_markdown = self._trace_markdown()
         note = (
-            str(payload.get("summary") or result_payload.get("conclusion") or (progress_eval or {}).get("reason") or "").strip()
+            str(
+                payload.get("summary")
+                or result_payload.get("conclusion")
+                or (progress_eval or {}).get("reason")
+                or trace_summary
+                or ""
+            ).strip()
             or "No durable main experiment result has been recorded yet."
         )
         title = f"Experiment · {run_id}"
@@ -1080,7 +1191,13 @@ class QuestStageViewBuilder:
                     "metrics_summary": metrics_summary,
                     "progress_eval": progress_eval,
                     "evaluation_summary": evaluation_summary,
+                    "run_path": self._relative_path_or_raw(paths.get("run_md")),
+                    "run_markdown": run_markdown,
+                    "result_json_path": self._relative_path_or_raw(paths.get("result_json")),
                     "result_payload": result_payload,
+                    "trace_summary": trace_summary,
+                    "trace_markdown": trace_markdown,
+                    "trace_actions": self._recent_trace_actions(),
                 }
             },
         )
@@ -1106,7 +1223,9 @@ class QuestStageViewBuilder:
             flow_type = str(payload.get("flow_type") or "").strip()
             if flow_type not in {"analysis_campaign", "analysis_slice"}:
                 continue
-            if campaign_id and str(payload.get("campaign_id") or "").strip() != campaign_id:
+            if campaign_id:
+                if str(payload.get("campaign_id") or "").strip() == campaign_id:
+                    items.append(item)
                 continue
             if self._branch_matches(payload, allow_parent=True, include_unscoped=False):
                 items.append(item)
@@ -1189,13 +1308,23 @@ class QuestStageViewBuilder:
                     "plan_path": item.get("plan_path"),
                     "result_path": item.get("result_path"),
                     "mirror_path": item.get("mirror_path"),
+                    "plan_markdown": self._markdown_body_for_path(item.get("plan_path")),
+                    "result_markdown": self._markdown_body_for_path(item.get("result_path")),
+                    "mirror_markdown": self._markdown_body_for_path(item.get("mirror_path")),
                 }
             )
         title = f"Analysis · {campaign_id}"
+        trace_summary = self._trace_summary()
         note = (
-            str(latest_payload.get("summary") or manifest.get("goal") or "").strip()
+            str(latest_payload.get("summary") or manifest.get("goal") or trace_summary or "").strip()
             or "No durable analysis campaign has been created yet."
         )
+        summary_path = (
+            self.quest_root / "experiments" / "analysis-results" / campaign_id / "SUMMARY.md"
+            if campaign_id != "pending"
+            else None
+        )
+        summary_markdown = self._markdown_body_for_path(summary_path) if summary_path else None
         key_files = self._dedupe_files(
             [
                 self._file_entry(manifest.get("_manifest_path"), label="Campaign Manifest", description="Structured analysis campaign manifest."),
@@ -1254,7 +1383,14 @@ class QuestStageViewBuilder:
                     "summary": latest_payload.get("summary"),
                     "manifest_path": manifest.get("_manifest_path"),
                     "charter_path": manifest.get("charter_path"),
+                    "charter_markdown": self._markdown_body_for_path(manifest.get("charter_path")),
                     "todo_manifest_path": manifest.get("todo_manifest_path"),
+                    "todo_manifest_markdown": self._markdown_body_for_path(manifest.get("todo_manifest_path")),
+                    "summary_path": self._relative_path_or_raw(summary_path) if summary_path else None,
+                    "summary_markdown": summary_markdown,
+                    "trace_summary": trace_summary,
+                    "trace_markdown": self._trace_markdown(),
+                    "trace_actions": self._recent_trace_actions(),
                 }
             },
         )
@@ -1264,23 +1400,25 @@ class QuestStageViewBuilder:
         latex_root_rel = self._paper_latex_root(bundle_manifest)
         main_tex_rel = self._paper_main_tex(latex_root_rel)
         pdf_candidates = self._paper_pdf_candidates(bundle_manifest, main_tex_rel=main_tex_rel)
-        candidates = sorted((self.quest_root / "paper" / "outlines" / "candidates").glob("*.json"))
+        paper_root = self._paper_root()
+        open_source_root = self._open_source_root()
+        candidates = sorted((paper_root / "outlines" / "candidates").glob("*.json"))
         files: list[dict[str, Any] | None] = [
             *[
                 self._file_entry(path, label=f"Outline Candidate · {path.stem}", description="Paper outline candidate JSON.")
                 for path in candidates
             ],
-            self._file_entry("paper/selected_outline.json", label="Selected Outline", description="Chosen paper outline."),
-            self._file_entry("paper/outline_selection.md", label="Outline Selection Note", description="Outline selection rationale."),
-            self._file_entry("paper/draft.md", label="Draft Markdown", description="Current paper draft."),
-            self._file_entry("paper/writing_plan.md", label="Writing Plan", description="Paper writing plan."),
-            self._file_entry("paper/references.bib", label="References", description="Bibliography file."),
-            self._file_entry("paper/claim_evidence_map.json", label="Claim-Evidence Map", description="Claim to evidence mapping."),
-            self._file_entry("paper/baseline_inventory.json", label="Baseline Inventory", description="Canonical and supplementary baseline inventory for writing."),
-            self._file_entry("paper/build/compile_report.json", label="Compile Report", description="Paper build/compile report."),
-            self._file_entry("paper/paper_bundle_manifest.json", label="Bundle Manifest", description="Final paper bundle manifest."),
-            self._file_entry("release/open_source/manifest.json", label="Open Source Manifest", description="Open-source cleanup and release preparation manifest."),
-            self._file_entry("release/open_source/cleanup_plan.md", label="Open Source Cleanup Plan", description="Checklist for cleaning the paper branch into a public release."),
+            self._file_entry(paper_root / "selected_outline.json", label="Selected Outline", description="Chosen paper outline."),
+            self._file_entry(paper_root / "outline_selection.md", label="Outline Selection Note", description="Outline selection rationale."),
+            self._file_entry(paper_root / "draft.md", label="Draft Markdown", description="Current paper draft."),
+            self._file_entry(paper_root / "writing_plan.md", label="Writing Plan", description="Paper writing plan."),
+            self._file_entry(paper_root / "references.bib", label="References", description="Bibliography file."),
+            self._file_entry(paper_root / "claim_evidence_map.json", label="Claim-Evidence Map", description="Claim to evidence mapping."),
+            self._file_entry(paper_root / "baseline_inventory.json", label="Baseline Inventory", description="Canonical and supplementary baseline inventory for writing."),
+            self._file_entry(paper_root / "build" / "compile_report.json", label="Compile Report", description="Paper build/compile report."),
+            self._file_entry(paper_root / "paper_bundle_manifest.json", label="Bundle Manifest", description="Final paper bundle manifest."),
+            self._file_entry(open_source_root / "manifest.json", label="Open Source Manifest", description="Open-source cleanup and release preparation manifest."),
+            self._file_entry(open_source_root / "cleanup_plan.md", label="Open Source Cleanup Plan", description="Checklist for cleaning the paper branch into a public release."),
             self._file_entry(latex_root_rel, label="LaTeX Sources", description="LaTeX source folder.", expected_kind="directory"),
             self._file_entry(main_tex_rel, label="Main TeX", description="Primary TeX source file."),
         ]
@@ -1290,7 +1428,7 @@ class QuestStageViewBuilder:
 
     def _paper_candidates(self) -> list[dict[str, Any]]:
         candidates: list[dict[str, Any]] = []
-        for path in sorted((self.quest_root / "paper" / "outlines" / "candidates").glob("*.json")):
+        for path in sorted((self._paper_root() / "outlines" / "candidates").glob("*.json")):
             payload = read_json(path, {})
             if not isinstance(payload, dict):
                 payload = {}
@@ -1319,7 +1457,8 @@ class QuestStageViewBuilder:
             )
             and self._branch_matches(self._payload(item), allow_parent=True)
         ]
-        selected_outline_path = self.quest_root / "paper" / "selected_outline.json"
+        paper_root = self._paper_root()
+        selected_outline_path = paper_root / "selected_outline.json"
         selected_outline = read_json(selected_outline_path, {}) if selected_outline_path.exists() else {}
         if not isinstance(selected_outline, dict):
             selected_outline = {}
@@ -1329,15 +1468,18 @@ class QuestStageViewBuilder:
             else {}
         )
         candidates = self._paper_candidates()
-        compile_report = read_json(self.quest_root / "paper" / "build" / "compile_report.json", {})
+        compile_report = read_json(paper_root / "build" / "compile_report.json", {})
         if not isinstance(compile_report, dict):
             compile_report = {}
         bundle_manifest = self._paper_bundle_manifest()
         latex_root_rel = self._paper_latex_root(bundle_manifest)
         main_tex_rel = self._paper_main_tex(latex_root_rel)
-        references_bib = read_text(self.quest_root / "paper" / "references.bib", "")
+        references_bib = read_text(paper_root / "references.bib", "")
         references_count = sum(1 for line in references_bib.splitlines() if line.lstrip().startswith("@"))
         pdf_paths = self._paper_pdf_candidates(bundle_manifest, main_tex_rel=main_tex_rel)
+        draft_rel = self._paper_relative_path(paper_root / "draft.md") or "paper/draft.md"
+        writing_plan_rel = self._paper_relative_path(paper_root / "writing_plan.md") or "paper/writing_plan.md"
+        claim_map_rel = self._paper_relative_path(paper_root / "claim_evidence_map.json") or "paper/claim_evidence_map.json"
         selected_title = str(
             detailed.get("title") or selected_outline.get("title") or bundle_manifest.get("title") or "Drafting"
         ).strip() or "Drafting"
@@ -1356,7 +1498,7 @@ class QuestStageViewBuilder:
             overview=[
                 _field("Selected Outline", selected_title if selected_outline else "Not selected"),
                 _field("Candidate Count", len(candidates)),
-                _field("Draft Status", "present" if (self.quest_root / "paper" / "draft.md").exists() else "missing"),
+                _field("Draft Status", "present" if (paper_root / "draft.md").exists() else "missing"),
                 _field("Bundle Status", "present" if bundle_manifest else "missing"),
             ],
             key_facts=[
@@ -1377,10 +1519,10 @@ class QuestStageViewBuilder:
                     "outline_candidates": candidates,
                     "selected_outline": selected_outline,
                     "drafting": {
-                        "writing_plan_path": "paper/writing_plan.md",
-                        "draft_path": "paper/draft.md",
+                        "writing_plan_path": writing_plan_rel,
+                        "draft_path": draft_rel,
                         "references_count": references_count,
-                        "claim_evidence_map_path": "paper/claim_evidence_map.json",
+                        "claim_evidence_map_path": claim_map_rel,
                     },
                     "build": {
                         "compile_report": compile_report,

package/src/deepscientist/registries/baseline.py

@@ -22,26 +22,49 @@ class BaselineRegistry:
         self.reconcile_confirmed_quests()
         entry_files = sorted(self.entries_root.glob("*.yaml"))
         if entry_files:
-            return sorted((self._load_entry_file(path) for path in entry_files), key=self._entry_sort_key)
+            return sorted(
+                (
+                    entry
+                    for path in entry_files
+                    for entry in [self._load_entry_file(path)]
+                    if not self._is_deleted_entry(entry)
+                ),
+                key=self._entry_sort_key,
+            )
 
         latest_by_id: dict[str, dict] = {}
         for item in self._history_entries():
             baseline_id = str(item.get("baseline_id") or item.get("entry_id") or "").strip()
             if baseline_id:
                 latest_by_id[baseline_id] = item
-        return sorted(latest_by_id.values(), key=self._entry_sort_key)
+        return sorted(
+            (item for item in latest_by_id.values() if not self._is_deleted_entry(item)),
+            key=self._entry_sort_key,
+        )
 
-    def get(self, baseline_id: str) -> dict | None:
+    def get(self, baseline_id: str, *, include_deleted: bool = False) -> dict | None:
         normalized_id = self._normalize_identifier(baseline_id, field_name="Baseline id")
         path = self._entry_path(normalized_id)
         if path.exists():
-            return self._load_entry_file(path)
+            entry = self._load_entry_file(path)
+            if self._is_deleted_entry(entry) and not include_deleted:
+                return None
+            return entry
         latest_match = None
         for item in self._history_entries():
             if item.get("baseline_id") == normalized_id or item.get("entry_id") == normalized_id:
                 latest_match = item
+        if self._is_deleted_entry(latest_match) and not include_deleted:
+            return None
         return latest_match
 
+    def is_deleted(self, baseline_id: str) -> bool:
+        try:
+            entry = self.get(baseline_id, include_deleted=True)
+        except ValueError:
+            return False
+        return self._is_deleted_entry(entry)
+
     def publish(self, entry: dict) -> dict:
         timestamp = utc_now()
         baseline_id = self._normalize_identifier(
@@ -201,6 +224,8 @@ class BaselineRegistry:
             }
 
             existing = self._existing_entry(baseline_id)
+            if self._is_deleted_entry(existing):
+                continue
             if self._entry_needs_publish(existing, entry):
                 synchronized.append(self.publish(entry))
             elif existing:
@@ -244,6 +269,27 @@ class BaselineRegistry:
         write_yaml(attachment_root / "attachment.yaml", attachment)
         return attachment
 
+    def delete(self, baseline_id: str) -> dict:
+        normalized_id = self._normalize_identifier(baseline_id, field_name="Baseline id")
+        existing = self.get(normalized_id, include_deleted=True) or {}
+        timestamp = utc_now()
+        deleted_entry = {
+            **existing,
+            "registry_kind": "baseline",
+            "schema_version": 1,
+            "entry_id": normalized_id,
+            "baseline_id": normalized_id,
+            "status": "deleted",
+            "updated_at": timestamp,
+            "deleted_at": timestamp,
+            "summary": str(existing.get("summary") or "").strip(),
+        }
+        if not deleted_entry.get("created_at"):
+            deleted_entry["created_at"] = timestamp
+        write_yaml(self._entry_path(normalized_id), deleted_entry)
+        append_jsonl(self.index_path, deleted_entry)
+        return deleted_entry
+
     def _history_entries(self) -> list[dict]:
         return read_jsonl(self.index_path)
 
@@ -292,6 +338,12 @@ class BaselineRegistry:
         entry = self._load_entry_file(path)
         return entry if isinstance(entry, dict) and entry else None
 
+    @staticmethod
+    def _is_deleted_entry(entry: dict[str, Any] | None) -> bool:
+        if not isinstance(entry, dict):
+            return False
+        return str(entry.get("status") or "").strip().lower() == "deleted"
+
     @staticmethod
     def _entry_needs_publish(existing: dict[str, Any] | None, candidate: dict[str, Any]) -> bool:
         if not existing:

package/src/deepscientist/runners/codex.py

@@ -771,7 +771,7 @@ class CodexRunner:
         ]
         if request.approval_policy:
             command.extend(["-c", f'approval_policy="{request.approval_policy}"'])
-        reasoning_effort = request.reasoning_effort if request.reasoning_effort is not None else "xhigh"
+        reasoning_effort = request.reasoning_effort
         if reasoning_effort:
             command.extend(["-c", f'model_reasoning_effort="{reasoning_effort}"'])
         tool_timeout_sec = self._positive_timeout_seconds(resolved_runner_config.get("mcp_tool_timeout_sec"))

package/src/prompts/connectors/qq.md

@@ -10,7 +10,7 @@
 - qq_summary_first_rule: start with the conclusion the user cares about, then what it means, then the next action
 - qq_progress_shape_rule: make the current task, the main difficulty or latest real progress, and the next concrete measure explicit whenever possible
 - qq_eta_rule: for baseline reproduction, main experiments, analysis experiments, and other important long-running research phases, include a rough ETA for the next meaningful result or the next update; if uncertain, say that and still give the next check-in window
-- qq_tool_call_keepalive_rule: for ordinary active work, if roughly 10 to 30 tool calls pass without a user-visible checkpoint, send one concise QQ progress update before continuing
+- qq_tool_call_keepalive_rule: for ordinary active work, prefer one concise QQ progress update after roughly 10 tool calls when there is already a human-meaningful delta, and do not let work drift beyond roughly 20 tool calls or about 15 minutes without a user-visible checkpoint
 - qq_internal_detail_rule: omit worker names, heartbeat timestamps, retry counters, pending/running/completed counts, file names, and monitor-window narration unless the user asked for them or the detail changes the recommended action
 - qq_translation_rule: convert internal execution and file-management work into user value, such as saying the baseline record is now organized for easier later comparison instead of listing touched files
 - qq_preflight_rule: before sending a QQ progress update, rewrite it if it still sounds like a monitoring log, execution diary, or file inventory

package/src/prompts/contracts/shared_interaction.md

@@ -0,0 +1,14 @@
+# Shared Interaction Contract
+
+This shared contract is injected once per turn and applies across the stage and companion skills that use `artifact.interact(...)` as the main user-visible continuity channel.
+
+## Shared interaction rules
+
+- Treat `artifact.interact(...)` as the main long-lived communication thread across TUI, web, and bound connectors.
+- If `artifact.interact(...)` returns queued user requirements, treat them as the highest-priority user instruction bundle before continuing the current stage or companion-skill task.
+- Immediately follow any non-empty mailbox poll with another `artifact.interact(...)` update that confirms receipt; if the request is directly answerable, answer there, otherwise say the current subtask is paused, give a short plan plus nearest report-back point, and handle that request first.
+- Emit `artifact.interact(kind='progress', reply_mode='threaded', ...)` when there is real user-visible progress: a meaningful checkpoint, route-shaping update, or a concise keepalive once active work has crossed roughly 10 tool calls with a human-meaningful delta. Do not let ordinary active work drift beyond roughly 20 tool calls or about 15 minutes without a user-visible update.
+- Keep progress updates chat-like and easy to understand: say what changed, what it means, and what happens next.
+- Default to plain-language summaries. Do not mention file paths, artifact ids, branch/worktree ids, session ids, raw commands, or raw logs unless the user asks or needs them to act.
+- Use `reply_mode='blocking'` only for real user decisions that cannot be resolved from local evidence.
+- For any blocking decision request, provide 1 to 3 concrete options, put the recommended option first, explain each option's actual content plus pros and cons, and wait up to 1 day when feasible. If the blocker is a missing external credential or secret that only the user can provide, keep the quest waiting, ask the user to supply it or choose an alternative, and do not self-resolve; if resumed without that credential and no other work is possible, a long low-frequency wait such as `bash_exec(command='sleep 3600', mode='await', timeout_seconds=3700)` is acceptable. Otherwise choose the best option yourself and notify the user of the chosen option if the timeout expires.