@researai/deepscientist 1.5.14 → 1.5.16

package/src/deepscientist/quest/stage_views.py

@@ -62,6 +62,26 @@ def _field(label: str, value: object, *, tone: str = "default") -> dict[str, Any
     }
 
 
+def _selection_score_summary(value: object) -> str | None:
+    if not isinstance(value, dict):
+        return None
+    parts: list[str] = []
+    for key, raw in value.items():
+        name = str(key or "").strip()
+        if not name:
+            continue
+        if isinstance(raw, float):
+            rendered = f"{raw:.4f}".rstrip("0").rstrip(".")
+        else:
+            rendered = str(raw).strip()
+        if not rendered:
+            continue
+        parts.append(f"{name}={rendered}")
+        if len(parts) >= 4:
+            break
+    return " · ".join(parts) or None
+
+
 def _evaluation_summary(value: object) -> dict[str, Any]:
     if not isinstance(value, dict):
         return {}
@@ -214,8 +234,11 @@ class QuestStageViewBuilder:
 
     def build(self) -> dict[str, Any]:
         selection_type = str(self.selection.get("selection_type") or "").strip()
+        explicit_stage_key = str(self.selection.get("stage_key") or "").strip()
         self.stage_key = self._resolve_effective_stage_key()
-        if selection_type == "branch_node" and self.stage_key not in {"experiment", "analysis", "paper"}:
+        if selection_type == "idea_candidate":
+            return self._build_idea_candidate()
+        if selection_type == "branch_node" and not explicit_stage_key:
             return self._build_branch()
         if self.stage_key == "baseline":
             return self._build_baseline()
@@ -280,6 +303,8 @@ class QuestStageViewBuilder:
             normalized = [str(item).strip() for item in raw if str(item).strip()]
             if normalized:
                 return normalized
+        if str(self.selection.get("selection_type") or "").strip() == "idea_candidate":
+            return self._idea_candidate_scope_paths()
         if str(self.selection.get("selection_type") or "").strip() == "branch_node":
             return self._branch_scope_paths()
         defaults = {
@@ -693,6 +718,13 @@ class QuestStageViewBuilder:
             "artifacts/reports",
         ]
 
+    def _idea_candidate_scope_paths(self) -> list[str]:
+        candidate_id = str(self.selection.get("selection_ref") or self.selection.get("idea_id") or "").strip()
+        return [
+            *( [f"memory/ideas/_candidates/{candidate_id}"] if candidate_id else []),
+            "artifacts/reports",
+        ]
+
     def _experiment_scope_paths(self, run_id: str | None) -> list[str]:
         return [
             *( [f"experiments/main/{run_id}"] if run_id else []),
@@ -917,6 +949,25 @@ class QuestStageViewBuilder:
                     items.append(item)
         return items
 
+    def _idea_candidate_stage_items(self) -> list[dict[str, Any]]:
+        candidate_id = str(self.selection.get("selection_ref") or self.selection.get("idea_id") or "").strip()
+        if not candidate_id:
+            return []
+        items: list[dict[str, Any]] = []
+        for item in self.artifacts:
+            payload = self._payload(item)
+            if str(payload.get("kind") or "").strip() != "idea":
+                continue
+            if str(payload.get("idea_id") or "").strip() != candidate_id:
+                continue
+            flow_type = str(payload.get("flow_type") or "").strip()
+            protocol_step = str(payload.get("protocol_step") or "").strip()
+            details = dict(payload.get("details") or {}) if isinstance(payload.get("details"), dict) else {}
+            submission_mode = str(details.get("submission_mode") or payload.get("submission_mode") or "").strip().lower()
+            if flow_type == "idea_submission" and (protocol_step == "candidate" or submission_mode == "candidate"):
+                items.append(item)
+        return items
+
     def _build_idea(self) -> dict[str, Any]:
         idea_items = self._idea_stage_items()
         latest = idea_items[-1] if idea_items else None
@@ -944,6 +995,8 @@ class QuestStageViewBuilder:
         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
+        selection_scores = details.get("selection_scores")
+        selection_score_summary = _selection_score_summary(selection_scores)
         note = (
             str(payload.get("summary") or payload.get("reason") or "").strip()
             or "No durable idea submission has been recorded yet."
@@ -987,6 +1040,11 @@ class QuestStageViewBuilder:
                 _field("Problem", details.get("problem") or "Not recorded"),
                 _field("Hypothesis", details.get("hypothesis") or "Not recorded"),
                 _field("Mechanism", details.get("mechanism") or "Not recorded"),
+                _field("Method Brief", details.get("method_brief") or "Not recorded"),
+                _field("Selection Scores", selection_score_summary or "Not recorded"),
+                _field("Mechanism Family", details.get("mechanism_family") or "Not recorded"),
+                _field("Change Layer", details.get("change_layer") or "Not recorded"),
+                _field("Source Lens", details.get("source_lens") or "Not recorded"),
                 _field("Expected Gain", details.get("expected_gain") or "Not recorded"),
                 _field("Risks", details.get("risks") or "Not recorded"),
                 _field("Evidence Paths", details.get("evidence_paths") or "Not recorded"),
@@ -1009,6 +1067,11 @@ class QuestStageViewBuilder:
                     "problem": details.get("problem"),
                     "hypothesis": details.get("hypothesis"),
                     "mechanism": details.get("mechanism"),
+                    "method_brief": details.get("method_brief"),
+                    "selection_scores": selection_scores or None,
+                    "mechanism_family": details.get("mechanism_family"),
+                    "change_layer": details.get("change_layer"),
+                    "source_lens": details.get("source_lens"),
                     "expected_gain": details.get("expected_gain"),
                     "risks": details.get("risks") or [],
                     "evidence_paths": details.get("evidence_paths") or [],
@@ -1028,6 +1091,101 @@ class QuestStageViewBuilder:
             subviews=["overview", "details", "draft"] if draft_markdown else ["overview", "details"],
         )
 
+    def _build_idea_candidate(self) -> dict[str, Any]:
+        candidate_items = self._idea_candidate_stage_items()
+        latest = candidate_items[-1] if candidate_items else None
+        payload = self._payload(latest or {})
+        details = dict(payload.get("details") or {}) if isinstance(payload.get("details"), dict) else {}
+        candidate_id = str(self.selection.get("selection_ref") or payload.get("idea_id") or "candidate").strip() or "candidate"
+        title_text = (
+            str(details.get("title") or self.selection.get("label") or candidate_id).strip() or candidate_id
+        )
+        paths = dict(payload.get("paths") or {}) if isinstance(payload.get("paths"), dict) else {}
+        candidate_root = paths.get("candidate_root") or str(self.quest_root / "memory" / "ideas" / "_candidates" / candidate_id)
+        idea_md_path = paths.get("idea_md") or str(Path(candidate_root) / "idea.md")
+        draft_md_path = paths.get("idea_draft_md") or details.get("idea_draft_path") or str(Path(candidate_root) / "draft.md")
+        idea_markdown = self._markdown_body_for_path(idea_md_path)
+        draft_markdown = self._markdown_body_for_path(draft_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)
+        candidate_root_rel_path = self._relative_path_or_raw(candidate_root)
+        selection_scores = details.get("selection_scores")
+        selection_score_summary = _selection_score_summary(selection_scores)
+        note = (
+            str(payload.get("summary") or payload.get("reason") or self.selection.get("summary") or "").strip()
+            or "No durable candidate brief summary has been recorded yet."
+        )
+        lineage_intent = str(payload.get("lineage_intent") or details.get("lineage_intent") or "").strip() or None
+        parent_branch = str(payload.get("parent_branch") or details.get("parent_branch") or self.selection.get("branch_name") or "").strip() or None
+        foundation_reason = str(payload.get("foundation_reason") or details.get("foundation_reason") or "").strip() or None
+        return self._base_payload(
+            title=f"Candidate Brief · {title_text}",
+            note=note,
+            status=str(payload.get("status") or "candidate").strip() or "candidate",
+            tags=[
+                "candidate-brief",
+                details.get("mechanism_family") or "",
+                details.get("change_layer") or "",
+                details.get("source_lens") or "",
+                lineage_intent or "",
+            ],
+            overview=[
+                _field("Candidate ID", candidate_id),
+                _field("Parent Branch", parent_branch or "Not recorded"),
+                _field("Next Target", details.get("next_target") or "optimize"),
+                _field("Candidate Root", candidate_root_rel_path or candidate_root),
+            ],
+            key_facts=[
+                _field("Problem", details.get("problem") or "Not recorded"),
+                _field("Hypothesis", details.get("hypothesis") or "Not recorded"),
+                _field("Mechanism", details.get("mechanism") or "Not recorded"),
+                _field("Method Brief", details.get("method_brief") or "Not recorded"),
+                _field("Selection Scores", selection_score_summary or "Not recorded"),
+                _field("Mechanism Family", details.get("mechanism_family") or "Not recorded"),
+                _field("Change Layer", details.get("change_layer") or "Not recorded"),
+                _field("Source Lens", details.get("source_lens") or "Not recorded"),
+                _field("Expected Gain", details.get("expected_gain") or "Not recorded"),
+                _field("Foundation Reason", foundation_reason or "Not recorded"),
+            ],
+            key_files=self._dedupe_files(
+                [
+                    self._file_entry(candidate_root, label="Candidate Root", description="Branchless candidate brief workspace.", expected_kind="directory"),
+                    self._file_entry(idea_md_path, label="Candidate Markdown", description="Durable candidate brief document."),
+                    self._file_entry(draft_md_path, label="Candidate Draft", description="Long-form candidate brief draft."),
+                ]
+            ),
+            history=self._artifact_history(candidate_items),
+            details={
+                "idea": {
+                    "idea_id": candidate_id,
+                    "title": title_text,
+                    "problem": details.get("problem"),
+                    "hypothesis": details.get("hypothesis"),
+                    "mechanism": details.get("mechanism"),
+                    "method_brief": details.get("method_brief"),
+                    "selection_scores": selection_scores or None,
+                    "mechanism_family": details.get("mechanism_family"),
+                    "change_layer": details.get("change_layer"),
+                    "source_lens": details.get("source_lens"),
+                    "expected_gain": details.get("expected_gain"),
+                    "next_target": details.get("next_target") or "optimize",
+                    "lineage_intent": lineage_intent,
+                    "parent_branch": parent_branch,
+                    "candidate_root": candidate_root_rel_path or candidate_root,
+                    "idea_path": idea_md_rel_path,
+                    "idea_markdown": idea_markdown,
+                    "draft_path": draft_md_rel_path,
+                    "draft_markdown": draft_markdown,
+                    "decision_reason": payload.get("reason"),
+                },
+                "latest_artifact": self._artifact_detail(latest, payload),
+            },
+            lineage_intent=lineage_intent,
+            idea_draft_path=draft_md_rel_path,
+            draft_available=bool(draft_markdown),
+            subviews=["overview", "details", "draft"] if draft_markdown else ["overview", "details"],
+        )
+
     def _build_branch(self) -> dict[str, Any]:
         idea_items = [
             item
@@ -1050,6 +1208,8 @@ class QuestStageViewBuilder:
         idea_title = str(latest_idea_details.get("title") or "").strip() or None
         idea_problem = str(latest_idea_details.get("problem") or "").strip() or None
         next_target = str(latest_idea_details.get("next_target") or "").strip() or None
+        selection_scores = latest_idea_details.get("selection_scores")
+        selection_score_summary = _selection_score_summary(selection_scores)
         lineage_intent = str(
             latest_idea_payload.get("lineage_intent")
             or latest_idea_details.get("lineage_intent")
@@ -1129,11 +1289,15 @@ class QuestStageViewBuilder:
             for item in self.artifacts
             if self._branch_matches(self._payload(item), allow_parent=True, include_unscoped=False)
         ]
+        latest_branch_payload = self._payload(branch_items[-1] if branch_items else {})
         note = (
             str(
                 latest_experiment_payload.get("summary")
                 or latest_idea_payload.get("summary")
                 or latest_idea_payload.get("reason")
+                or latest_branch_payload.get("summary")
+                or latest_branch_payload.get("message")
+                or latest_branch_payload.get("reason")
                 or self.trace.get("summary")
                 or self.selection.get("summary")
                 or ""
@@ -1169,6 +1333,11 @@ class QuestStageViewBuilder:
             key_facts=[
                 _field("Idea Title", idea_title or "Not recorded"),
                 _field("Idea Problem", idea_problem or "Not recorded"),
+                _field("Method Brief", latest_idea_details.get("method_brief") or "Not recorded"),
+                _field("Selection Scores", selection_score_summary or "Not recorded"),
+                _field("Mechanism Family", latest_idea_details.get("mechanism_family") or "Not recorded"),
+                _field("Change Layer", latest_idea_details.get("change_layer") or "Not recorded"),
+                _field("Source Lens", latest_idea_details.get("source_lens") or "Not recorded"),
                 _field("Foundation", foundation_label or "Current head"),
                 _field("Foundation Reason", foundation_reason or "Not recorded"),
                 _field("Next Target", next_target or "Not recorded"),
@@ -1224,6 +1393,11 @@ class QuestStageViewBuilder:
                     "lineage_intent": lineage_intent,
                     "idea_title": idea_title,
                     "idea_problem": idea_problem,
+                    "method_brief": latest_idea_details.get("method_brief"),
+                    "selection_scores": selection_scores or None,
+                    "mechanism_family": latest_idea_details.get("mechanism_family"),
+                    "change_layer": latest_idea_details.get("change_layer"),
+                    "source_lens": latest_idea_details.get("source_lens"),
                     "next_target": next_target,
                     "idea_draft_path": idea_draft_rel_path,
                     "idea_draft_markdown": idea_draft_markdown,
@@ -1579,11 +1753,13 @@ class QuestStageViewBuilder:
                 for path in candidates
             ],
             self._file_entry(paper_root / "selected_outline.json", label="Selected Outline", description="Chosen paper outline."),
+            self._file_entry(paper_root / "outline" / "manifest.json", label="Outline Manifest", description="Author-facing paper outline manifest."),
             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 / "paper_line_state.json", label="Paper Line State", description="Derived summary state for the active paper line."),
             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."),

package/src/deepscientist/runners/base.py

@@ -17,6 +17,8 @@ class RunRequest:
     approval_policy: str
     sandbox_mode: str
     turn_reason: str = "user_message"
+    turn_intent: str = "continue_stage"
+    turn_mode: str = "stage_execution"
     reasoning_effort: str | None = None
     turn_id: str | None = None
     attempt_index: int = 1

package/src/deepscientist/runners/codex.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import json
 import os
 import signal
-import shutil
 import subprocess
 import sys
 import threading
@@ -11,12 +10,16 @@ from pathlib import Path
 from typing import Any
 
 from ..artifact import ArtifactService
-from ..codex_cli_compat import adapt_profile_only_provider_config, normalize_codex_reasoning_effort
+from ..codex_cli_compat import (
+    materialize_codex_runtime_home,
+    normalize_codex_reasoning_effort,
+    provider_profile_metadata_from_home,
+)
 from ..config import ConfigManager
 from ..gitops import export_git_graph
 from ..prompts import PromptBuilder
 from ..runtime_logs import JsonlLogger
-from ..shared import append_jsonl, ensure_dir, generate_id, read_text, read_yaml, resolve_runner_binary, utc_now, write_json, write_text
+from ..shared import append_jsonl, ensure_dir, generate_id, read_yaml, resolve_runner_binary, utc_now, write_json, write_text
 from ..web_search import extract_web_search_payload
 from .base import RunRequest, RunResult
 
@@ -24,6 +27,55 @@ _TOOL_EVENT_ARGS_TEXT_LIMIT = 8_000
 _TOOL_EVENT_OUTPUT_TEXT_LIMIT = 16_000
 _MAX_QUEST_EVENT_JSON_BYTES = 2_000_000
 _OVERSIZED_EVENT_PREVIEW_TEXT_LIMIT = 12_000
+_BUILTIN_MCP_TOOL_APPROVALS: dict[str, tuple[str, ...]] = {
+    "memory": (
+        "write",
+        "read",
+        "search",
+        "list_recent",
+        "promote_to_global",
+    ),
+    "artifact": (
+        "record",
+        "checkpoint",
+        "prepare_branch",
+        "activate_branch",
+        "submit_idea",
+        "list_research_branches",
+        "resolve_runtime_refs",
+        "get_paper_contract_health",
+        "get_quest_state",
+        "get_global_status",
+        "get_method_scoreboard",
+        "get_optimization_frontier",
+        "read_quest_documents",
+        "get_conversation_context",
+        "get_analysis_campaign",
+        "record_main_experiment",
+        "create_analysis_campaign",
+        "submit_paper_outline",
+        "list_paper_outlines",
+        "submit_paper_bundle",
+        "record_analysis_slice",
+        "publish_baseline",
+        "attach_baseline",
+        "confirm_baseline",
+        "waive_baseline",
+        "arxiv",
+        "refresh_summary",
+        "render_git_graph",
+        "interact",
+        "complete_quest",
+    ),
+    "bash_exec": (
+        "bash_exec",
+    ),
+}
+
+_PROVIDER_ENV_CONFLICT_KEYS = (
+    "OPENAI_API_KEY",
+    "OPENAI_BASE_URL",
+)
 
 
 def _compact_text(value: object, *, limit: int = 1200) -> str:
@@ -151,7 +203,9 @@ def _iter_event_texts(event: dict[str, Any]) -> list[str]:
                     if isinstance(value, str) and value.strip():
                         texts.append(value)
     delta = event.get("delta")
-    if isinstance(delta, dict):
+    if isinstance(delta, str) and delta.strip():
+        texts.append(delta)
+    elif isinstance(delta, dict):
         for key in ("text", "content"):
             value = delta.get(key)
             if isinstance(value, str) and value.strip():
@@ -178,6 +232,36 @@ def _web_search_text_payload(item: dict[str, Any]) -> str:
     return _compact_text(payload, limit=2400)
 
 
+def _message_stream_id(event: dict[str, Any], item: dict[str, Any], *, run_id: str, kind: str) -> str:
+    for value in (
+        event.get("stream_id"),
+        item.get("stream_id"),
+        event.get("message_id"),
+        item.get("message_id"),
+        event.get("item_id"),
+        item.get("id"),
+        event.get("output_item_id"),
+        event.get("response_id"),
+    ):
+        if value:
+            return str(value)
+    normalized_kind = str(kind or "message").strip().lower() or "message"
+    return f"{run_id}:{normalized_kind}"
+
+
+def _message_id(event: dict[str, Any], item: dict[str, Any], *, stream_id: str) -> str:
+    for value in (
+        event.get("message_id"),
+        item.get("message_id"),
+        event.get("item_id"),
+        item.get("id"),
+        event.get("output_item_id"),
+    ):
+        if value:
+            return str(value)
+    return stream_id
+
+
 def _message_events(
     event: dict[str, Any],
     *,
@@ -194,6 +278,8 @@ def _message_events(
 
     if item_type == "agent_message":
         texts = _dedupe_texts(_iter_event_texts(event))
+        stream_id = _message_stream_id(event, item, run_id=run_id, kind="assistant")
+        message_id = _message_id(event, item, stream_id=stream_id)
         for text in texts:
             quest_events.append(
                 {
@@ -204,6 +290,8 @@ def _message_events(
                     "source": "codex",
                     "skill_id": skill_id,
                     "text": text,
+                    "stream_id": stream_id,
+                    "message_id": message_id,
                     "created_at": created_at,
                 }
             )
@@ -211,6 +299,8 @@ def _message_events(
 
     if item_type in {"reasoning", "reasoning_summary"} or "reasoning" in event_type:
         texts = _dedupe_texts(_iter_event_texts(event))
+        stream_id = _message_stream_id(event, item, run_id=run_id, kind=item_type or "reasoning")
+        message_id = _message_id(event, item, stream_id=stream_id)
         for text in texts:
             quest_events.append(
                 {
@@ -221,6 +311,8 @@ def _message_events(
                     "source": "codex",
                     "skill_id": skill_id,
                     "text": text,
+                    "stream_id": stream_id,
+                    "message_id": message_id,
                     "kind": item_type or "reasoning",
                     "created_at": created_at,
                 }
@@ -234,6 +326,8 @@ def _message_events(
         return [], []
 
     texts = _dedupe_texts(_iter_event_texts(event))
+    stream_id = _message_stream_id(event, item, run_id=run_id, kind="assistant")
+    message_id = _message_id(event, item, stream_id=stream_id)
     for text in texts:
         quest_events.append(
             {
@@ -244,6 +338,8 @@ def _message_events(
                 "source": "codex",
                 "skill_id": skill_id,
                 "text": text,
+                "stream_id": stream_id,
+                "message_id": message_id,
                 "created_at": created_at,
             }
         )
@@ -322,9 +418,11 @@ def _tool_output(event: dict[str, Any], item: dict[str, Any]) -> str:
             item.get("result"),
             item.get("output"),
             item.get("content"),
+            item.get("error"),
             event.get("result"),
             event.get("output"),
             event.get("content"),
+            event.get("error"),
             item.get("aggregated_output"),
             event.get("aggregated_output"),
         ):
@@ -338,11 +436,13 @@ def _tool_output(event: dict[str, Any], item: dict[str, Any]) -> str:
         item.get("output"),
         item.get("result"),
         item.get("content"),
+        item.get("error"),
         event.get("aggregated_output"),
         event.get("changes"),
         event.get("output"),
         event.get("result"),
         event.get("content"),
+        event.get("error"),
     ):
         text = _compact_text(value, limit=1200)
         if text:
@@ -642,6 +742,8 @@ class CodexRunner:
             user_message=request.message,
             model=request.model,
             turn_reason=request.turn_reason,
+            turn_intent=request.turn_intent,
+            turn_mode=request.turn_mode,
             retry_context=request.retry_context,
         )
         write_text(run_root / "prompt.md", prompt)
@@ -663,6 +765,8 @@ class CodexRunner:
                 "workspace_root": str(workspace_root),
                 "cwd": str(workspace_root),
                 "turn_reason": request.turn_reason,
+                "turn_intent": request.turn_intent,
+                "turn_mode": request.turn_mode,
             },
         )
 
@@ -672,8 +776,12 @@ class CodexRunner:
             env_key = str(key or "").strip()
             if not env_key or value is None:
                 continue
-            env[env_key] = str(value)
+            env_value = str(value)
+            if env_value == "":
+                continue
+            env[env_key] = env_value
         env["CODEX_HOME"] = str(codex_home)
+        env = self._sanitize_provider_env(env, runner_config=runner_config)
         env["DEEPSCIENTIST_HOME"] = str(self.home)
         env["DS_HOME"] = str(self.home)
         env["DS_QUEST_ID"] = request.quest_id
@@ -681,6 +789,8 @@ class CodexRunner:
         env["DS_WORKTREE_ROOT"] = str(workspace_root)
         env["DS_RUN_ID"] = request.run_id
         env["DS_TURN_REASON"] = request.turn_reason
+        env["DS_TURN_INTENT"] = request.turn_intent
+        env["DS_TURN_MODE"] = request.turn_mode
         quest_yaml = read_yaml(request.quest_root / "quest.yaml", {})
         env["DS_ACTIVE_ANCHOR"] = str(quest_yaml.get("active_anchor", "baseline"))
         env["DS_CONVERSATION_ID"] = f"quest:{request.quest_id}"
@@ -740,6 +850,13 @@ class CodexRunner:
                 timestamp = utc_now()
                 append_jsonl(history_events, {"timestamp": timestamp, "event": payload})
                 append_jsonl(stdout_events, {"timestamp": timestamp, "line": line})
+                try:
+                    self.artifact_service.quest_service.schedule_projection_refresh(
+                        request.quest_root,
+                        kinds=("details",),
+                    )
+                except Exception:
+                    pass
                 tool_event = _tool_event(
                     payload,
                     quest_id=request.quest_id,
@@ -810,6 +927,14 @@ class CodexRunner:
             }
             write_json(run_root / "result.json", result_payload)
             write_json(history_root / "meta.json", result_payload)
+            try:
+                self.artifact_service.quest_service.schedule_projection_refresh(
+                    request.quest_root,
+                    kinds=("details",),
+                    throttle_seconds=0.0,
+                )
+            except Exception:
+                pass
             self.logger.log(
                 "info",
                 "runner.codex.completed",
@@ -822,6 +947,7 @@ class CodexRunner:
                 request.quest_root,
                 {
                     "kind": "run",
+                    "status": "completed" if exit_code == 0 else "failed",
                     "run_id": request.run_id,
                     "run_kind": request.skill_id,
                     "model": request.model,
@@ -902,6 +1028,8 @@ class CodexRunner:
         resolved_runner_config = runner_config if isinstance(runner_config, dict) else self._load_runner_config()
         profile = str(resolved_runner_config.get("profile") or "").strip()
         normalized_model = str(request.model or "").strip()
+        if profile and normalized_model.lower() not in {"", "inherit", "default", "codex-default"}:
+            normalized_model = "inherit"
         command = [
             resolved_binary or self.binary,
             "--search",
@@ -946,35 +1074,16 @@ class CodexRunner:
         run_id: str,
         runner_config: dict[str, Any] | None = None,
     ) -> Path:
-        target = ensure_dir(workspace_root / ".codex")
+        target = ensure_dir(workspace_root / ".ds" / "codex-home")
         resolved_runner_config = runner_config if isinstance(runner_config, dict) else self._load_runner_config()
         configured_home = str(resolved_runner_config.get("config_dir") or os.environ.get("CODEX_HOME") or str(Path.home() / ".codex"))
         profile = str(resolved_runner_config.get("profile") or "").strip()
-        source = Path(configured_home).expanduser()
-        for filename in ("config.toml", "auth.json"):
-            source_path = source / filename
-            target_path = target / filename
-            if source_path.exists() and not target_path.exists():
-                if source_path.resolve() == target_path.resolve():
-                    continue
-                shutil.copy2(source_path, target_path)
-        config_path = target / "config.toml"
-        if profile and config_path.exists():
-            adapted_text, _ = adapt_profile_only_provider_config(read_text(config_path), profile=profile)
-            write_text(config_path, adapted_text)
-        ensure_dir(target / "skills")
-        quest_skills_root = quest_root / ".codex" / "skills"
-        if quest_skills_root.exists():
-            for source_path in sorted(quest_skills_root.rglob("*")):
-                relative = source_path.relative_to(quest_skills_root)
-                target_path = target / "skills" / relative
-                if source_path.is_dir():
-                    ensure_dir(target_path)
-                    continue
-                if source_path.resolve() == target_path.resolve():
-                    continue
-                ensure_dir(target_path.parent)
-                shutil.copy2(source_path, target_path)
+        materialize_codex_runtime_home(
+            source_home=configured_home,
+            target_home=target,
+            profile=profile,
+            quest_codex_root=quest_root / ".codex",
+        )
         self._inject_built_in_mcp(
             target,
             quest_root=quest_root,
@@ -1043,6 +1152,7 @@ class CodexRunner:
         args = ["-m", "deepscientist.mcp.server", "--namespace", name]
         lines = [
             f"[mcp_servers.{name}]",
+            'transport = "stdio"',
             f'command = "{sys.executable}"',
             f"args = [{', '.join(json.dumps(item) for item in args)}]",
         ]
@@ -1057,6 +1167,14 @@ class CodexRunner:
         )
         for key, value in env.items():
             lines.append(f"{key} = {json.dumps(value)}")
+        for tool_name in _BUILTIN_MCP_TOOL_APPROVALS.get(name, ()):
+            lines.extend(
+                [
+                    "",
+                    f"[mcp_servers.{name}.tools.{tool_name}]",
+                    'approval_mode = "approve"',
+                ]
+            )
         return "\n".join(lines)
 
     def _load_runner_config(self) -> dict[str, Any]:
@@ -1074,3 +1192,23 @@ class CodexRunner:
         except (TypeError, ValueError):
             return None
         return timeout if timeout > 0 else None
+
+    @staticmethod
+    def _sanitize_provider_env(
+        env: dict[str, str],
+        *,
+        runner_config: dict[str, Any] | None = None,
+    ) -> dict[str, str]:
+        resolved_runner_config = runner_config if isinstance(runner_config, dict) else {}
+        profile = str(resolved_runner_config.get("profile") or "").strip()
+        config_home = str(resolved_runner_config.get("config_dir") or env.get("CODEX_HOME") or "").strip()
+        if not profile or not config_home:
+            return env
+        metadata = provider_profile_metadata_from_home(config_home, profile=profile)
+        requires_openai_auth = metadata.get("requires_openai_auth")
+        if requires_openai_auth is not False:
+            return env
+        sanitized = dict(env)
+        for key in _PROVIDER_ENV_CONFLICT_KEYS:
+            sanitized.pop(key, None)
+        return sanitized