@researai/deepscientist 1.5.6 → 1.5.7

package/src/deepscientist/daemon/app.py

@@ -29,7 +29,14 @@ from ..channels.slack_socket import SlackSocketModeService
 from ..channels.telegram_polling import TelegramPollingService
 from ..channels.whatsapp_local_session import WhatsAppLocalSessionService
 from ..cloud import CloudLinkService
-from ..connector_profiles import PROFILEABLE_CONNECTOR_NAMES, connector_profile_label, list_connector_profiles, merge_connector_profile_config
+from ..connector_profiles import (
+    CONNECTOR_PROFILE_SPECS,
+    PROFILEABLE_CONNECTOR_NAMES,
+    connector_profile_label,
+    list_connector_profiles,
+    merge_connector_profile_config,
+    normalize_connector_config,
+)
 from ..connector_runtime import conversation_identity_key, format_conversation_id, normalize_conversation_id, parse_conversation_id
 from ..config import ConfigManager
 from ..home import repo_root
@@ -38,7 +45,7 @@ from ..network import urlopen_with_proxy as urlopen
 from ..latex_runtime import QuestLatexService
 from ..prompts import PromptBuilder
 from ..prompts.builder import STANDARD_SKILLS
-from ..qq_profiles import list_qq_profiles, merge_qq_profile_config
+from ..qq_profiles import list_qq_profiles, merge_qq_profile_config, normalize_qq_connector_config
 from ..quest import QuestService
 from ..runners import CodexRunner, RunRequest, get_runner_factory, register_builtin_runners
 from ..runtime_logs import JsonlLogger
@@ -73,7 +80,7 @@ class DaemonApp:
         self.daemon_managed_by = str(os.environ.get("DS_DAEMON_MANAGED_BY") or "manual").strip() or "manual"
         self.repo_root = repo_root()
         self.config_manager = ConfigManager(home)
-        self.runners_config = self.config_manager.load_named("runners")
+        self.runners_config = self.config_manager.load_runners_config()
         self.connectors_config = self.config_manager.load_named_normalized("connectors")
         self.skill_installer = SkillInstaller(self.repo_root, home)
         self.quest_service = QuestService(home, skill_installer=self.skill_installer)
@@ -647,6 +654,22 @@ class DaemonApp:
             ),
         }
 
+    def reload_runners_config(self) -> dict[str, object]:
+        self.runners_config = self.config_manager.load_runners_config()
+        codex_config = self.runners_config.get("codex", {})
+        if isinstance(codex_config, dict):
+            self.codex_runner.binary = str(codex_config.get("binary") or "codex")
+        return {
+            "ok": True,
+            "runners": sorted(name for name, config in self.runners_config.items() if isinstance(config, dict)),
+            "codex": {
+                "binary": self.codex_runner.binary,
+                "approval_policy": codex_config.get("approval_policy") if isinstance(codex_config, dict) else None,
+                "sandbox_mode": codex_config.get("sandbox_mode") if isinstance(codex_config, dict) else None,
+                "mcp_tool_timeout_sec": codex_config.get("mcp_tool_timeout_sec") if isinstance(codex_config, dict) else None,
+            },
+        }
+
     def _preferred_locale(self) -> str:
         config = self.config_manager.load_named("config")
         return str(config.get("default_locale") or "en-US").lower()
@@ -2090,6 +2113,210 @@ class DaemonApp:
         channel = self._channel_with_bindings(connector_name)
         return channel.list_bindings()
 
+    def delete_connector_profile(self, connector_name: str, profile_id: str) -> dict | tuple[int, dict]:
+        normalized_connector = str(connector_name or "").strip().lower()
+        normalized_profile_id = str(profile_id or "").strip()
+        if not normalized_connector:
+            return 400, {"ok": False, "message": "Connector name is required."}
+        if not normalized_profile_id:
+            return 400, {"ok": False, "message": "Profile id is required."}
+        if normalized_connector != "qq" and normalized_connector not in PROFILEABLE_CONNECTOR_NAMES:
+            return 400, {"ok": False, "message": f"Connector `{normalized_connector}` does not support profile deletion."}
+
+        connectors = self.config_manager.load_named_normalized("connectors")
+        connector_config = connectors.get(normalized_connector)
+        if not isinstance(connector_config, dict):
+            return 404, {"ok": False, "message": f"Unknown connector `{normalized_connector}`."}
+
+        if normalized_connector == "qq":
+            profiles = list_qq_profiles(connector_config)
+        else:
+            profiles = list_connector_profiles(normalized_connector, connector_config)
+        if not profiles:
+            return 404, {"ok": False, "message": f"Connector `{normalized_connector}` has no configured profiles."}
+
+        remaining_profiles = [
+            dict(item)
+            for item in profiles
+            if str(item.get("profile_id") or "").strip() != normalized_profile_id
+        ]
+        if len(remaining_profiles) == len(profiles):
+            return 404, {
+                "ok": False,
+                "message": f"Profile `{normalized_profile_id}` was not found under connector `{normalized_connector}`.",
+            }
+
+        deleting_last_profile = len(remaining_profiles) == 0
+        related_conversations = self._connector_profile_bound_conversations(
+            normalized_connector,
+            normalized_profile_id,
+            include_all_if_single_profile=deleting_last_profile,
+        )
+        for conversation_id in related_conversations:
+            self._unbind_connector_conversation_everywhere(normalized_connector, conversation_id)
+
+        next_connector_config = dict(connector_config)
+        next_connector_config["profiles"] = remaining_profiles
+        if deleting_last_profile:
+            next_connector_config["enabled"] = False
+            if normalized_connector == "qq":
+                for key in ("app_id", "app_secret", "app_secret_env", "main_chat_id"):
+                    next_connector_config[key] = None
+            else:
+                profile_spec = CONNECTOR_PROFILE_SPECS.get(normalized_connector, {})
+                for key in profile_spec.get("profile_fields", ()):
+                    if key in {"enabled", "transport", "mode"}:
+                        continue
+                    next_connector_config[key] = None
+        if normalized_connector == "qq":
+            connectors[normalized_connector] = normalize_qq_connector_config(next_connector_config)
+        else:
+            connectors[normalized_connector] = normalize_connector_config(normalized_connector, next_connector_config)
+        save_result = self.config_manager.save_named_payload("connectors", connectors)
+        if not bool(save_result.get("ok")):
+            return 409, {
+                "ok": False,
+                "message": "Failed to persist connector profile deletion.",
+                "errors": save_result.get("errors") or [],
+                "warnings": save_result.get("warnings") or [],
+            }
+
+        self._cleanup_connector_profile_runtime(
+            normalized_connector,
+            normalized_profile_id,
+            clear_all=deleting_last_profile,
+        )
+        self.reload_connectors_config()
+        snapshot = next(
+            (item for item in self.list_connector_statuses() if str(item.get("name") or "").strip().lower() == normalized_connector),
+            None,
+        )
+        return {
+            "ok": True,
+            "connector": normalized_connector,
+            "profile_id": normalized_profile_id,
+            "deleted": True,
+            "deleted_bound_conversations": related_conversations,
+            "remaining_profile_count": len(remaining_profiles),
+            "snapshot": snapshot,
+        }
+
+    def _connector_profile_bound_conversations(
+        self,
+        connector_name: str,
+        profile_id: str,
+        *,
+        include_all_if_single_profile: bool = False,
+    ) -> list[str]:
+        normalized_connector = str(connector_name or "").strip().lower()
+        normalized_profile_id = str(profile_id or "").strip()
+        if not normalized_connector or not normalized_profile_id:
+            return []
+        try:
+            channel = self._channel_with_bindings(normalized_connector)
+        except Exception:
+            return []
+        conversations: list[str] = []
+        seen: set[str] = set()
+        for item in channel.list_bindings():
+            if not isinstance(item, dict):
+                continue
+            conversation_id = str(item.get("conversation_id") or "").strip()
+            if not conversation_id:
+                continue
+            item_profile_id = str(item.get("profile_id") or "").strip()
+            if not include_all_if_single_profile and item_profile_id != normalized_profile_id:
+                continue
+            identity = conversation_identity_key(conversation_id)
+            if identity in seen:
+                continue
+            seen.add(identity)
+            conversations.append(conversation_id)
+        return conversations
+
+    def _unbind_connector_conversation_everywhere(self, connector_name: str, conversation_id: str) -> bool:
+        normalized_connector = str(connector_name or "").strip().lower()
+        normalized_conversation_id = normalize_conversation_id(conversation_id)
+        if not normalized_connector or not normalized_conversation_id:
+            return False
+        try:
+            channel = self._channel_with_bindings(normalized_connector)
+        except Exception:
+            return False
+        bound_quest_id = str(channel.resolve_bound_quest(normalized_conversation_id) or "").strip() or None
+        removed = channel.unbind_conversation(
+            normalized_conversation_id,
+            quest_id=bound_quest_id,
+        )
+        if bound_quest_id:
+            self.sessions.unbind(bound_quest_id, normalized_conversation_id)
+            self.quest_service.unbind_source(bound_quest_id, normalized_conversation_id)
+        return removed
+
+    def _cleanup_connector_profile_runtime(
+        self,
+        connector_name: str,
+        profile_id: str,
+        *,
+        clear_all: bool = False,
+    ) -> None:
+        normalized_connector = str(connector_name or "").strip().lower()
+        normalized_profile_id = str(profile_id or "").strip()
+        if not normalized_connector or not normalized_profile_id:
+            return
+        connector_root = self.home / "logs" / "connectors" / normalized_connector
+        profile_root = connector_root / "profiles" / normalized_profile_id
+        shutil.rmtree(profile_root, ignore_errors=True)
+
+        def matches_profile(payload: object, *, conversation_id: str | None = None) -> bool:
+            if clear_all:
+                return True
+            item = payload if isinstance(payload, dict) else {}
+            item_profile_id = str(item.get("profile_id") or "").strip() if isinstance(item, dict) else ""
+            if item_profile_id:
+                return item_profile_id == normalized_profile_id
+            parsed = parse_conversation_id(conversation_id or "")
+            return str((parsed or {}).get("profile_id") or "").strip() == normalized_profile_id
+
+        bindings_path = connector_root / "bindings.json"
+        bindings_payload = read_json(bindings_path, {"bindings": {}})
+        binding_map = bindings_payload.get("bindings")
+        if isinstance(binding_map, dict):
+            filtered_bindings = {
+                key: value
+                for key, value in binding_map.items()
+                if not matches_profile(value, conversation_id=str(key))
+            }
+            bindings_payload["bindings"] = filtered_bindings
+            write_json(bindings_path, bindings_payload)
+
+        state_path = connector_root / "state.json"
+        state_payload = read_json(state_path, {})
+        if isinstance(state_payload, dict):
+            for key in ("recent_conversations", "known_targets"):
+                raw_items = state_payload.get(key)
+                if isinstance(raw_items, list):
+                    state_payload[key] = [
+                        item
+                        for item in raw_items
+                        if not matches_profile(
+                            item,
+                            conversation_id=str((item or {}).get("conversation_id") or "") if isinstance(item, dict) else "",
+                        )
+                    ]
+            if clear_all:
+                state_payload["last_conversation_id"] = None
+            else:
+                last_conversation_id = str(state_payload.get("last_conversation_id") or "").strip()
+                if last_conversation_id and matches_profile({}, conversation_id=last_conversation_id):
+                    state_payload["last_conversation_id"] = None
+            write_json(state_path, state_payload)
+
+        if clear_all:
+            runtime_path = connector_root / "runtime.json"
+            if runtime_path.exists():
+                write_json(runtime_path, {})
+
     def preview_connector_binding_conflicts(
         self,
         requested_bindings: list[dict[str, object]] | None,

package/src/deepscientist/prompts/builder.py

@@ -91,7 +91,7 @@ class PromptBuilder:
         quest_root = Path(snapshot["quest_root"])
         active_anchor = str(snapshot.get("active_anchor") or skill_id)
         default_locale = str(runtime_config.get("default_locale") or "en-US")
-        system_block = self._prompt_fragment("src/prompts/system.md")
+        system_block = self._prompt_fragment("system.md", quest_root=quest_root)
         connector_contract_block = self._connector_contract_block(quest_id=quest_id, snapshot=snapshot)
         sections = [
             system_block,
@@ -332,7 +332,8 @@ class PromptBuilder:
         connector = self._active_external_connector_name(quest_id=quest_id, snapshot=snapshot)
         if connector is None:
             return ""
-        path = self.repo_root / "src" / "prompts" / "connectors" / f"{connector}.md"
+        quest_root = Path(snapshot["quest_root"])
+        path = self._prompt_path(Path("connectors") / f"{connector}.md", quest_root=quest_root)
         if not path.exists():
             return ""
         return self._markdown_body(path)
@@ -601,10 +602,18 @@ class PromptBuilder:
 
         return "\n".join(lines)
 
-    def _prompt_fragment(self, relative_path: str) -> str:
-        path = self.repo_root / relative_path
+    def _prompt_fragment(self, relative_path: str | Path, *, quest_root: Path | None = None) -> str:
+        path = self._prompt_path(relative_path, quest_root=quest_root)
         return self._markdown_body(path)
 
+    def _prompt_path(self, relative_path: str | Path, *, quest_root: Path | None = None) -> Path:
+        normalized = Path(relative_path)
+        if quest_root is not None:
+            quest_path = quest_root / ".codex" / "prompts" / normalized
+            if quest_path.exists():
+                return quest_path
+        return self.repo_root / "src" / "prompts" / normalized
+
     def _latest_user_message(self, quest_id: str) -> dict | None:
         for item in reversed(self.quest_service.history(quest_id, limit=80)):
             if str(item.get("role") or "") == "user":
@@ -768,6 +777,13 @@ class PromptBuilder:
             "- tool_call_keepalive_protocol: for active multi-step work outside long detached experiment waits, if you have spent roughly 10 to 30 tool calls without a user-visible checkpoint, send one concise artifact.interact progress update before continuing",
             "- human_progress_shape_protocol: ordinary progress updates should usually make three things explicit in human language: the current task, the main difficulty or latest real progress, and the concrete next measure you will take",
             "- eta_visibility_protocol: for baseline reproduction, main experiments, analysis experiments, and other important long-running phases, progress updates should also make the expected time to the next meaningful result, next milestone, or next user-visible update explicit; use roughly 10 to 30 minutes as the normal update window, and if the ETA is unreliable, say that and give a realistic next check-in window instead",
+            "- stage_plan_protocol: for `baseline`, `experiment`, and `analysis-campaign`, do not jump straight into substantial setup, code changes, or real runs; first create or update quest-visible `PLAN.md` and `CHECKLIST.md`, then keep them aligned with the actual route",
+            "- baseline_plan_protocol: in `baseline`, read the source paper and source repo first when they exist, then make `PLAN.md` cover the route, source package, code touchpoints, smoke path, real-run path, fallback options, monitoring rules, and verification targets before substantial work continues",
+            "- experiment_plan_protocol: in `experiment`, make `PLAN.md` start with the selected idea summarized in 1 to 2 sentences and then map the idea into code touchpoints, comparability rules, smoke / pilot path, full-run path, fallback options, monitoring rules, and revision notes",
+            "- analysis_plan_protocol: in `analysis-campaign`, treat `PLAN.md` as the campaign charter and make it cover the slice list, comparability boundary, asset and comparator plan, smoke / full-run policy, reporting plan, and revision log before real slices launch",
+            "- checklist_maintenance_protocol: for those same stages, treat `CHECKLIST.md` as the living execution surface and update it during reading, setup, coding, smoke tests, real runs, validation, aggregation, and route changes instead of letting progress live only in chat",
+            "- plan_revision_protocol: if the route, comparability contract, source package, execution strategy, slice ordering, or campaign interpretation changes materially, revise `PLAN.md` before continuing",
+            "- stage_milestone_summary_protocol: for accepted baseline, selected idea, completed main experiment, and completed analysis-campaign milestones, usually open with 1 to 2 sentences that say what happened, what it means, and the exact next step before expanding into more detail",
             "- idea_milestone_protocol: immediately after a successful accepted artifact.submit_idea(...), send a threaded milestone that explains the idea in plain language and explicitly states whether it currently looks valid, research-worthy, and insight-bearing, plus the main risk and exact next experiment",
             "- idea_divergence_protocol: in the idea stage, separate divergence from convergence; unless strong durable evidence already narrows the route to one obvious serious option, do not collapse onto the first plausible route before generating a small but meaningfully diverse candidate slate",
             "- idea_lens_protocol: when idea candidates cluster around one mechanism family, deliberately switch ideation lenses such as problem-first vs solution-first, tension hunting, analogy transfer, inversion, or adjacent-possible reasoning before final selection",

package/src/deepscientist/qq_profiles.py

@@ -7,16 +7,13 @@ from .shared import slugify
 
 
 QQ_PROFILE_ID_PREFIX = "qq-profile"
-QQ_DEFAULT_SECRET_ENV = "QQ_APP_SECRET"
-
-
 def default_qq_profile() -> dict[str, Any]:
     return {
         "profile_id": None,
         "enabled": True,
         "app_id": None,
         "app_secret": None,
-        "app_secret_env": QQ_DEFAULT_SECRET_ENV,
+        "app_secret_env": None,
         "bot_name": "DeepScientist",
         "main_chat_id": None,
     }
@@ -27,6 +24,13 @@ def _as_text(value: Any) -> str | None:
     return text or None
 
 
+def _normalize_secret_pair(payload: dict[str, Any], direct_key: str, env_key: str) -> None:
+    direct = _as_text(payload.get(direct_key))
+    env_name = _as_text(payload.get(env_key))
+    payload[direct_key] = direct
+    payload[env_key] = None if direct else env_name
+
+
 def _profile_id_seed(*, profile_id: Any, app_id: Any, bot_name: Any, index: int) -> str:
     explicit = _as_text(profile_id)
     if explicit:
@@ -77,12 +81,14 @@ def merge_qq_profile_config(shared_config: dict[str, Any] | None, profile: dict[
     normalized = normalize_qq_connector_config(shared_config)
     merged = deepcopy(normalized)
     merged.pop("profiles", None)
+    app_secret = _as_text(profile.get("app_secret"))
+    app_secret_env = _as_text(profile.get("app_secret_env"))
     merged.update(
         {
             "profile_id": str(profile.get("profile_id") or "").strip() or None,
             "app_id": _as_text(profile.get("app_id")),
-            "app_secret": _as_text(profile.get("app_secret")),
-            "app_secret_env": _as_text(profile.get("app_secret_env")) or QQ_DEFAULT_SECRET_ENV,
+            "app_secret": app_secret,
+            "app_secret_env": None if app_secret else app_secret_env,
             "bot_name": _as_text(profile.get("bot_name")) or str(normalized.get("bot_name") or "DeepScientist"),
             "main_chat_id": _as_text(profile.get("main_chat_id")),
             "enabled": bool(normalized.get("enabled", False)) and bool(profile.get("enabled", True)),
@@ -113,7 +119,7 @@ def normalize_qq_connector_config(config: dict[str, Any] | None) -> dict[str, An
         "transport": "gateway_direct",
         "app_id": None,
         "app_secret": None,
-        "app_secret_env": QQ_DEFAULT_SECRET_ENV,
+        "app_secret_env": None,
         "bot_name": "DeepScientist",
         "command_prefix": "/",
         "main_chat_id": None,
@@ -132,7 +138,7 @@ def normalize_qq_connector_config(config: dict[str, Any] | None) -> dict[str, An
     shared["transport"] = "gateway_direct"
     shared["command_prefix"] = _as_text(shared.get("command_prefix")) or "/"
     shared["bot_name"] = _as_text(shared.get("bot_name")) or "DeepScientist"
-    shared["app_secret_env"] = _as_text(shared.get("app_secret_env")) or QQ_DEFAULT_SECRET_ENV
+    _normalize_secret_pair(shared, "app_secret", "app_secret_env")
 
     raw_profiles = payload.get("profiles")
     items = list(raw_profiles) if isinstance(raw_profiles, list) else []
@@ -144,7 +150,9 @@ def normalize_qq_connector_config(config: dict[str, Any] | None) -> dict[str, An
         "main_chat_id": payload.get("main_chat_id"),
     }
     if not items:
-        if any(_as_text(legacy_profile_seed.get(key)) for key in ("app_id", "app_secret", "main_chat_id", "bot_name")):
+        has_direct_profile_seed = any(_as_text(legacy_profile_seed.get(key)) for key in ("app_id", "app_secret", "main_chat_id"))
+        has_env_profile_seed = bool(payload.get("enabled")) and bool(_as_text(legacy_profile_seed.get("app_secret_env")))
+        if has_direct_profile_seed or has_env_profile_seed:
             items = [legacy_profile_seed]
 
     profiles: list[dict[str, Any]] = []
@@ -157,6 +165,7 @@ def normalize_qq_connector_config(config: dict[str, Any] | None) -> dict[str, An
         current["app_id"] = _as_text(current.get("app_id"))
         current["app_secret"] = _as_text(current.get("app_secret"))
         current["app_secret_env"] = _as_text(current.get("app_secret_env")) or shared["app_secret_env"]
+        _normalize_secret_pair(current, "app_secret", "app_secret_env")
         current["bot_name"] = _as_text(current.get("bot_name")) or shared["bot_name"]
         current["main_chat_id"] = _as_text(current.get("main_chat_id"))
         current["profile_id"] = _unique_profile_id(
@@ -181,6 +190,7 @@ def normalize_qq_connector_config(config: dict[str, Any] | None) -> dict[str, An
     else:
         shared["app_id"] = None
         shared["app_secret"] = None
+        shared["app_secret_env"] = None
         shared["main_chat_id"] = None
 
     return shared

package/src/deepscientist/quest/layout.py

@@ -30,6 +30,7 @@ QUEST_DIRECTORIES = (
     "memory/papers",
     "paper",
     "release/open_source",
+    ".codex/prompts",
     ".codex/skills",
     ".claude/agents",
     ".ds/bash_exec",

package/src/deepscientist/runners/codex.py

@@ -499,6 +499,7 @@ class CodexRunner:
         workspace_root = request.worktree_root or request.quest_root
         run_root = ensure_dir(request.quest_root / ".ds" / "runs" / request.run_id)
         history_root = ensure_dir(request.quest_root / ".ds" / "codex_history" / request.run_id)
+        runner_config = self._load_runner_config()
         prompt = self.prompt_builder.build(
             quest_id=request.quest_id,
             skill_id=request.skill_id,
@@ -514,8 +515,9 @@ class CodexRunner:
             quest_root=request.quest_root,
             quest_id=request.quest_id,
             run_id=request.run_id,
+            runner_config=runner_config,
         )
-        command = self._build_command(request, prompt)
+        command = self._build_command(request, prompt, runner_config=runner_config)
         write_json(
             run_root / "command.json",
             {
@@ -752,9 +754,10 @@ class CodexRunner:
             process.wait(timeout=3)
         return interrupted
 
-    def _build_command(self, request: RunRequest, prompt: str) -> list[str]:
+    def _build_command(self, request: RunRequest, prompt: str, *, runner_config: dict[str, Any] | None = None) -> list[str]:
         workspace_root = request.worktree_root or request.quest_root
         resolved_binary = resolve_runner_binary(self.binary, runner_name="codex")
+        resolved_runner_config = runner_config if isinstance(runner_config, dict) else self._load_runner_config()
         command = [
             resolved_binary or self.binary,
             "--search",
@@ -771,6 +774,11 @@ class CodexRunner:
         reasoning_effort = request.reasoning_effort if request.reasoning_effort is not None else "xhigh"
         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"))
+        if tool_timeout_sec is not None:
+            timeout_value = int(tool_timeout_sec) if float(tool_timeout_sec).is_integer() else float(tool_timeout_sec)
+            for server_name in ("memory", "artifact", "bash_exec"):
+                command.extend(["-c", f"mcp_servers.{server_name}.tool_timeout_sec={timeout_value}"])
         if request.sandbox_mode:
             command.extend(["--sandbox", request.sandbox_mode])
         command.append("-")
@@ -783,6 +791,7 @@ class CodexRunner:
         quest_root: Path,
         quest_id: str,
         run_id: str,
+        runner_config: dict[str, Any] | None = None,
     ) -> Path:
         target = ensure_dir(workspace_root / ".codex")
         source = Path(os.environ.get("CODEX_HOME", str(Path.home() / ".codex"))).expanduser()
@@ -812,6 +821,7 @@ class CodexRunner:
             workspace_root=workspace_root,
             quest_id=quest_id,
             run_id=run_id,
+            runner_config=runner_config,
         )
         return target
 
@@ -823,6 +833,7 @@ class CodexRunner:
         workspace_root: Path,
         quest_id: str,
         run_id: str,
+        runner_config: dict[str, Any] | None = None,
     ) -> None:
         config_path = codex_home / "config.toml"
         existing = config_path.read_text(encoding="utf-8") if config_path.exists() else ""
@@ -834,17 +845,8 @@ class CodexRunner:
             prefix = existing.rstrip()
 
         pythonpath = os.environ.get("PYTHONPATH", "")
-        tool_timeout_sec = None
-        try:
-            runners_cfg = ConfigManager(self.home).load_named("runners")
-            raw_codex_cfg = runners_cfg.get("codex") if isinstance(runners_cfg.get("codex"), dict) else {}
-            raw_timeout = raw_codex_cfg.get("mcp_tool_timeout_sec") if isinstance(raw_codex_cfg, dict) else None
-            if raw_timeout is not None:
-                tool_timeout_sec = float(raw_timeout)
-        except (OSError, ValueError, TypeError, KeyError):
-            tool_timeout_sec = None
-        if tool_timeout_sec is not None and tool_timeout_sec <= 0:
-            tool_timeout_sec = None
+        resolved_runner_config = runner_config if isinstance(runner_config, dict) else self._load_runner_config()
+        tool_timeout_sec = self._positive_timeout_seconds(resolved_runner_config.get("mcp_tool_timeout_sec"))
 
         shared_env = {
             "DEEPSCIENTIST_HOME": str(self.home),
@@ -896,3 +898,19 @@ class CodexRunner:
         for key, value in env.items():
             lines.append(f"{key} = {json.dumps(value)}")
         return "\n".join(lines)
+
+    def _load_runner_config(self) -> dict[str, Any]:
+        try:
+            runners_cfg = ConfigManager(self.home).load_runners_config()
+        except OSError:
+            return {}
+        codex_cfg = runners_cfg.get("codex")
+        return codex_cfg if isinstance(codex_cfg, dict) else {}
+
+    @staticmethod
+    def _positive_timeout_seconds(value: object) -> float | None:
+        try:
+            timeout = float(value)
+        except (TypeError, ValueError):
+            return None
+        return timeout if timeout > 0 else None

package/src/deepscientist/runners/runtime_overrides.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import os
+from copy import deepcopy
+from typing import Any
+
+
+def _as_text(value: Any) -> str | None:
+    text = str(value or "").strip()
+    return text or None
+
+
+def _as_bool_env(name: str) -> bool:
+    value = _as_text(os.environ.get(name))
+    if value is None:
+        return False
+    return value.lower() in {"1", "true", "yes", "on", "y"}
+
+
+def codex_runtime_overrides() -> dict[str, str]:
+    approval_policy = _as_text(os.environ.get("DEEPSCIENTIST_CODEX_APPROVAL_POLICY"))
+    sandbox_mode = _as_text(os.environ.get("DEEPSCIENTIST_CODEX_SANDBOX_MODE"))
+
+    if _as_bool_env("DEEPSCIENTIST_CODEX_YOLO"):
+        approval_policy = approval_policy or "never"
+        sandbox_mode = sandbox_mode or "danger-full-access"
+
+    overrides: dict[str, str] = {}
+    if approval_policy:
+        overrides["approval_policy"] = approval_policy
+    if sandbox_mode:
+        overrides["sandbox_mode"] = sandbox_mode
+    return overrides
+
+
+def apply_codex_runtime_overrides(config: dict[str, Any] | None) -> dict[str, Any]:
+    resolved = deepcopy(config or {})
+    resolved.update(codex_runtime_overrides())
+    return resolved
+
+
+def apply_runners_runtime_overrides(runners_config: dict[str, Any] | None) -> dict[str, Any]:
+    resolved = deepcopy(runners_config or {})
+    codex = resolved.get("codex")
+    resolved["codex"] = apply_codex_runtime_overrides(codex if isinstance(codex, dict) else {})
+    return resolved

package/src/deepscientist/skills/installer.py

@@ -41,6 +41,8 @@ class SkillInstaller:
         }
 
     def sync_quest(self, quest_root: Path) -> dict:
+        prompts_root = ensure_dir(quest_root / ".codex" / "prompts")
+        self._sync_prompt_tree(prompts_root)
         codex_root = ensure_dir(quest_root / ".codex" / "skills")
         claude_root = ensure_dir(quest_root / ".claude" / "agents")
         copied_codex: list[str] = []
@@ -58,6 +60,7 @@ class SkillInstaller:
         self._prune_bundle_targets(codex_root, expected_codex)
         self._prune_bundle_targets(claude_root, expected_claude)
         return {
+            "prompts": [str(path) for path in sorted(prompts_root.rglob("*")) if path.is_file()],
             "codex": copied_codex,
             "claude": copied_claude,
             "notes": [],
@@ -187,6 +190,10 @@ class SkillInstaller:
         temp_path.write_bytes(payload)
         temp_path.replace(path)
 
+    def _sync_prompt_tree(self, target_root: Path) -> None:
+        source_root = self.repo_root / "src" / "prompts"
+        self._sync_bundle_tree(source_root, target_root)
+
     @staticmethod
     def _prune_bundle_targets(root: Path, expected_names: set[str]) -> None:
         for target in sorted(root.glob("deepscientist-*"), reverse=True):