@researai/deepscientist 1.5.16 → 1.6.0

package/src/deepscientist/config/service.py

@@ -2,19 +2,29 @@ from __future__ import annotations
 
 import json
 import os
+import shlex
+import shutil
 import subprocess
 import tempfile
 from copy import deepcopy
 from pathlib import Path
 from urllib.error import URLError
+from urllib.parse import urlencode
 from urllib.request import Request
 
 from ..codex_cli_compat import (
+    active_provider_metadata_from_home,
     adapt_profile_only_provider_config,
+    chat_wire_compatible_codex_version,
+    codex_cli_version,
+    format_codex_cli_version,
     materialize_codex_runtime_home,
+    missing_provider_env_key,
+    missing_provider_env_key_from_text,
     normalize_codex_reasoning_effort,
-    provider_profile_metadata_from_home,
+    provider_base_url_looks_local,
 )
+from ..kimi_cli_compat import materialize_kimi_runtime_home
 from ..connector.connector_profiles import PROFILEABLE_CONNECTOR_NAMES, list_connector_profiles, normalize_connector_config
 from ..connector_runtime import build_discovered_target, infer_connector_transport
 from ..home import repo_root
@@ -43,8 +53,9 @@ from ..connector.qq_profiles import (
 )
 from ..connector.weixin_support import normalize_weixin_base_url, normalize_weixin_cdn_base_url
 from ..network import urlopen_with_proxy as urlopen
+from ..runners.metadata import get_runner_metadata, list_builtin_runner_names
 from ..runners.runtime_overrides import apply_codex_runtime_overrides, apply_runners_runtime_overrides
-from ..shared import read_json, read_text, read_yaml, resolve_runner_binary, run_command, sha256_text, utc_now, which, write_text, write_yaml
+from ..shared import ensure_utf8_subprocess_env, read_json, read_text, read_yaml, resolve_runner_binary, run_command, sha256_text, utc_now, utf8_text_subprocess_kwargs, which, write_json, write_text, write_yaml
 from .models import (
     CONFIG_NAMES,
     OPTIONAL_CONFIG_NAMES,
@@ -205,31 +216,83 @@ class ConfigManager:
         return prepared
 
     def _invalidate_codex_bootstrap_state_if_runner_changed(self, previous: dict, current: dict) -> None:
-        previous_codex = previous.get("codex") if isinstance(previous.get("codex"), dict) else {}
-        current_codex = current.get("codex") if isinstance(current.get("codex"), dict) else {}
-        tracked_keys = (
-            "binary",
-            "config_dir",
-            "profile",
-            "model",
-            "model_reasoning_effort",
-            "approval_policy",
-            "sandbox_mode",
-            "env",
-        )
-        if all(previous_codex.get(key) == current_codex.get(key) for key in tracked_keys):
+        tracked_keys_by_runner = {
+            "codex": (
+                "binary",
+                "config_dir",
+                "profile",
+                "model",
+                "model_reasoning_effort",
+                "approval_policy",
+                "sandbox_mode",
+                "env",
+                "mcp_tool_timeout_sec",
+            ),
+            "claude": (
+                "binary",
+                "config_dir",
+                "model",
+                "permission_mode",
+                "mcp_timeout_ms",
+                "mcp_tool_timeout_ms",
+                "env",
+            ),
+            "kimi": (
+                "binary",
+                "config_dir",
+                "model",
+                "agent",
+                "thinking",
+                "yolo",
+                "mcp_tool_timeout_ms",
+                "env",
+            ),
+            "opencode": (
+                "binary",
+                "config_dir",
+                "model",
+                "permission_mode",
+                "default_agent",
+                "variant",
+                "mcp_timeout_ms",
+                "env",
+            ),
+        }
+        changed_runners: list[str] = []
+        for runner_name, tracked_keys in tracked_keys_by_runner.items():
+            previous_runner = previous.get(runner_name) if isinstance(previous.get(runner_name), dict) else {}
+            current_runner = current.get(runner_name) if isinstance(current.get(runner_name), dict) else {}
+            if all(previous_runner.get(key) == current_runner.get(key) for key in tracked_keys):
+                continue
+            changed_runners.append(runner_name)
+        if not changed_runners:
             return
         config = self.load_named_normalized("config")
         bootstrap = config.get("bootstrap") if isinstance(config.get("bootstrap"), dict) else {}
-        bootstrap["codex_ready"] = False
-        bootstrap["codex_last_checked_at"] = utc_now()
-        bootstrap["codex_last_result"] = {
-            "ok": False,
-            "summary": "Codex runner configuration changed. A new startup probe is required.",
-            "warnings": [],
-            "errors": [],
-            "guidance": [],
-        }
+        runner_readiness = bootstrap.get("runner_readiness") if isinstance(bootstrap.get("runner_readiness"), dict) else {}
+        checked_at = utc_now()
+        for runner_name in changed_runners:
+            try:
+                runner_label = get_runner_metadata(runner_name).label
+            except KeyError:
+                runner_label = runner_name
+            summary = f"{runner_label} runner configuration changed. A new startup probe is required."
+            runner_readiness[runner_name] = {
+                "ready": False,
+                "last_checked_at": checked_at,
+                "last_result": {
+                    "ok": False,
+                    "summary": summary,
+                    "warnings": [],
+                    "errors": [],
+                    "guidance": [],
+                },
+            }
+        bootstrap["runner_readiness"] = runner_readiness
+        codex_state = runner_readiness.get("codex") if isinstance(runner_readiness.get("codex"), dict) else {}
+        bootstrap["codex_ready"] = bool(codex_state.get("ready", False))
+        bootstrap["codex_last_checked_at"] = codex_state.get("last_checked_at")
+        bootstrap["codex_last_result"] = codex_state.get("last_result") if isinstance(codex_state.get("last_result"), dict) else {}
         config["bootstrap"] = bootstrap
         self.save_named_text("config", self.render_named_payload("config", config))
 
@@ -470,12 +533,12 @@ The **Test** button checks:
 
 This is a safe local smoke test.
 
-## Codex startup gate
+## Runner startup gate
 
-- `bootstrap.codex_ready` starts as `false`
-- the launcher runs a real Codex hello probe before first daemon start
-- once Codex answers correctly, DeepScientist flips this flag to `true`
-- if the probe fails, DeepScientist writes the failure summary back into config and blocks startup
+- the launcher runs a real hello probe for the selected runner before first daemon start
+- `codex`, `claude`, `kimi`, and `opencode` can each record readiness under `bootstrap.runner_readiness`
+- if the selected runner fails, DeepScientist writes the failure summary back into config and blocks only that requested startup path
+- you can start with the default runner first, then configure or switch Claude Code / Kimi Code / OpenCode from Settings
 
 ## Figure and chart style policy
 
@@ -491,15 +554,16 @@ This page edits `{home_text}/config/runners.yaml`.
 ## Recommended v1 choice
 
 - keep `codex.enabled: true`
-- keep `claude.enabled: false`
-- `claude` remains TODO / reserved in the current open-source release and is not runnable yet
+- enable whichever runners you actually plan to use (`codex`, `claude`, `kimi`, `opencode`)
+- keep the others disabled if their local CLI or credentials are not ready yet
 - set `codex.profile` only when your Codex CLI uses a named provider profile such as `m27`
 - when you launch DeepScientist ad hoc with a provider profile, you can also use `ds --codex-profile <name>`
 - when you want a one-off Codex binary override, you can also use `ds --codex /absolute/path/to/codex`
 - keep `codex.model_reasoning_effort: xhigh` unless you explicitly want a lighter default
 - keep `codex.retry_on_failure: true` so transient Codex failures can resume automatically
-- keep retry timing near `10s / 6x / 1800s max` so Codex backs off exponentially and the last retry waits about 30 minutes
-- DeepScientist hard-limits one turn to at most `5` total attempts, even if the config says more
+- keep retry timing near `10s / 6x / 1800s max` so Codex backs off exponentially and the final retries sit at the 30-minute cap
+- DeepScientist hard-limits one turn to at most `7` total attempts, even if the config says more
+- one-off diagnostics can target a runner without permanently enabling it: `ds doctor --runner claude`, `ds doctor --runner kimi`, or `ds doctor --runner opencode`
 
 ## Test behavior
 
@@ -507,7 +571,7 @@ The **Test** button checks:
 
 - whether the configured runner binaries are on PATH
 - whether disabled runners are intentionally skipped
-- for Codex, it also runs a real hello probe so login problems, profile misconfiguration, and first-run setup issues surface before quest execution
+- for enabled runners, it also runs a real hello probe so login problems, profile misconfiguration, and first-run setup issues surface before quest execution
 - it does not simulate the full failure/retry loop, so use quest runtime logs when debugging recovery behavior
 """
         if name == "plugins":
@@ -601,21 +665,159 @@ Use **Test** when the file exposes runtime dependencies.
         rendered = self.render_named_payload(name, payload)
         return self.test_named_text(name, rendered, live=live, delivery_targets=delivery_targets)
 
-    def probe_codex_bootstrap(self, *, persist: bool = False, payload: dict | None = None) -> dict:
-        runners_payload = payload if isinstance(payload, dict) else self.load_named_normalized("runners")
-        codex_payload = runners_payload.get("codex") if isinstance(runners_payload.get("codex"), dict) else {}
-        result = self._probe_codex_runner(codex_payload)
+    def test_deepxiv_payload(self, payload: dict | None = None) -> dict:
+        normalized = self._normalize_named_payload("config", payload if isinstance(payload, dict) else self.load_named_normalized("config"))
+        literature = normalized.get("literature") if isinstance(normalized.get("literature"), dict) else {}
+        deepxiv = literature.get("deepxiv") if isinstance(literature.get("deepxiv"), dict) else {}
+        base_url = str(deepxiv.get("base_url") or "https://data.rag.ac.cn").strip() or "https://data.rag.ac.cn"
+        direct_token = str(deepxiv.get("token") or "").strip()
+        token_env_name = str(deepxiv.get("token_env") or "").strip()
+        env_token = str(os.environ.get(token_env_name) or "").strip() if token_env_name else ""
+        resolved_token = direct_token or env_token
+        query = "transformers"
+        result_size = max(1, int(deepxiv.get("default_result_size") or 10))
+        preview_characters = max(200, int(deepxiv.get("preview_characters") or 1200))
+        request_timeout_seconds = max(3, int(deepxiv.get("request_timeout_seconds") or 20))
+        details = {
+            "base_url": base_url,
+            "query": query,
+            "result_size": result_size,
+            "preview_characters": preview_characters,
+            "request_timeout_seconds": request_timeout_seconds,
+            "token_source": "direct_token" if direct_token else ("env" if env_token else "missing"),
+            "token_env": token_env_name or None,
+        }
+        if not resolved_token:
+            return {
+                "ok": False,
+                "summary": "DeepXiv test failed: token is missing.",
+                "warnings": [],
+                "errors": ["Provide a DeepXiv token before running the test."],
+                "details": details,
+                "results": [],
+                "preview": "",
+            }
+        url = f"{base_url.rstrip('/')}/arxiv/?{urlencode({'type': 'retrieve', 'query': query, 'size': str(result_size)})}"
+        request = Request(
+            url,
+            headers={
+                "Accept": "application/json",
+                "Authorization": f"Bearer {resolved_token}",
+                "User-Agent": "DeepScientist/DeepXivTest",
+            },
+        )
+        try:
+            with urlopen(request, timeout=request_timeout_seconds) as response:  # noqa: S310
+                response_text = response.read().decode("utf-8", errors="replace")
+        except Exception as exc:
+            details["request_url"] = url
+            return {
+                "ok": False,
+                "summary": "DeepXiv test request failed.",
+                "warnings": [],
+                "errors": [str(exc)],
+                "details": details,
+                "results": [],
+                "preview": "",
+            }
+        try:
+            parsed = json.loads(response_text)
+        except json.JSONDecodeError:
+            preview = response_text[:preview_characters].rstrip()
+            if len(response_text) > preview_characters:
+                preview = f"{preview}\n...[truncated]"
+            details["request_url"] = url
+            return {
+                "ok": False,
+                "summary": "DeepXiv test returned invalid JSON.",
+                "warnings": [],
+                "errors": ["DeepXiv returned invalid JSON."],
+                "details": details,
+                "results": [],
+                "preview": preview,
+            }
+        results = parsed.get("results") if isinstance(parsed.get("results"), list) else []
+        if not results and isinstance(parsed.get("result"), list):
+            results = parsed.get("result") or []
+        total = parsed.get("total")
+        if total is None:
+            total = parsed.get("total_count")
+        preview_payload = {
+            "total": total,
+            "took": parsed.get("took"),
+            "results": results[: min(3, len(results))],
+        }
+        preview = json.dumps(preview_payload, ensure_ascii=False, indent=2)
+        if len(preview) > preview_characters:
+            preview = f"{preview[:preview_characters].rstrip()}\n...[truncated]"
+        details.update(
+            {
+                "request_url": url,
+                "total": total,
+                "result_count": len(results),
+                "first_title": str((results[0] or {}).get("title") or "").strip() if results else None,
+            }
+        )
+        ok = len(results) > 0
+        return {
+            "ok": ok,
+            "summary": "DeepXiv returned search results for `transformers`." if ok else "DeepXiv returned no search results for `transformers`.",
+            "warnings": [],
+            "errors": [] if ok else ["No results were returned for `transformers`."],
+            "details": details,
+            "results": results[:5],
+            "preview": preview,
+        }
+
+    def probe_runner_bootstrap(self, runner_name: str, *, persist: bool = False, payload: dict | None = None) -> dict:
+        normalized_runner = str(runner_name or "codex").strip().lower() or "codex"
+        runners_payload = payload if isinstance(payload, dict) else self.load_runners_config()
+        runner_payload = runners_payload.get(normalized_runner) if isinstance(runners_payload.get(normalized_runner), dict) else {}
+        if normalized_runner == "codex":
+            result = self._probe_codex_runner(runner_payload)
+        elif normalized_runner == "claude":
+            result = self._probe_claude_runner(runner_payload)
+        elif normalized_runner == "kimi":
+            result = self._probe_kimi_runner(runner_payload)
+        elif normalized_runner == "opencode":
+            result = self._probe_opencode_runner(runner_payload)
+        else:
+            raise KeyError(f"Unknown runner `{normalized_runner}`.")
         if persist:
-            self._persist_codex_bootstrap_result(result)
+            self._persist_runner_bootstrap_result(normalized_runner, result)
         return result
 
-    def codex_bootstrap_state(self) -> dict:
+    def runner_bootstrap_state(self, runner_name: str) -> dict:
+        normalized_runner = str(runner_name or "codex").strip().lower() or "codex"
         config = self.load_named_normalized("config")
         bootstrap = config.get("bootstrap") if isinstance(config.get("bootstrap"), dict) else {}
+        runner_readiness = bootstrap.get("runner_readiness") if isinstance(bootstrap.get("runner_readiness"), dict) else {}
+        runner_state = runner_readiness.get(normalized_runner) if isinstance(runner_readiness.get(normalized_runner), dict) else {}
+        if normalized_runner == "codex" and not runner_state:
+            runner_state = {
+                "ready": bool(bootstrap.get("codex_ready", False)),
+                "last_checked_at": bootstrap.get("codex_last_checked_at"),
+                "last_result": bootstrap.get("codex_last_result") if isinstance(bootstrap.get("codex_last_result"), dict) else {},
+            }
         return {
-            "codex_ready": bool(bootstrap.get("codex_ready", False)),
-            "codex_last_checked_at": bootstrap.get("codex_last_checked_at"),
-            "codex_last_result": bootstrap.get("codex_last_result") if isinstance(bootstrap.get("codex_last_result"), dict) else {},
+            "runner": normalized_runner,
+            "ready": bool(runner_state.get("ready", False)),
+            "last_checked_at": runner_state.get("last_checked_at"),
+            "last_result": runner_state.get("last_result") if isinstance(runner_state.get("last_result"), dict) else {},
+        }
+
+    def runner_readiness_map(self) -> dict[str, dict[str, Any]]:
+        return {name: self.runner_bootstrap_state(name) for name in list_builtin_runner_names()}
+
+    def probe_codex_bootstrap(self, *, persist: bool = False, payload: dict | None = None) -> dict:
+        return self.probe_runner_bootstrap("codex", persist=persist, payload=payload)
+
+    def codex_bootstrap_state(self) -> dict:
+        state = self.runner_bootstrap_state("codex")
+        return {
+            "codex_ready": bool(state.get("ready")),
+            "codex_last_checked_at": state.get("last_checked_at"),
+            "codex_last_result": state.get("last_result") if isinstance(state.get("last_result"), dict) else {},
         }
 
     def git_readiness(self) -> dict:
@@ -695,7 +897,8 @@ Use **Test** when the file exposes runtime dependencies.
 
     def _test_runners_payload(self, payload: dict, *, live: bool) -> dict:
         items = []
-        for name, config in payload.items():
+        normalized_payload = apply_runners_runtime_overrides(self._normalize_named_payload("runners", payload))
+        for name, config in normalized_payload.items():
             if not isinstance(config, dict):
                 continue
             enabled = bool(config.get("enabled", False))
@@ -718,8 +921,8 @@ Use **Test** when the file exposes runtime dependencies.
                     "live_probe_executed": False,
                 },
             }
-            if enabled and name == "codex" and exists and live:
-                probe = self._probe_codex_runner(config)
+            if enabled and exists and live:
+                probe = self.probe_runner_bootstrap(name, persist=False, payload=normalized_payload)
                 item["ok"] = bool(probe.get("ok"))
                 item["warnings"] = [*warnings, *list(probe.get("warnings") or [])]
                 item["errors"] = list(probe.get("errors") or [])
@@ -1215,7 +1418,7 @@ Use **Test** when the file exposes runtime dependencies.
     def _codex_runner_env(config: dict) -> dict[str, str]:
         raw_env = config.get("env")
         if not isinstance(raw_env, dict):
-            return {}
+            return ensure_utf8_subprocess_env({})
         resolved: dict[str, str] = {}
         for key, value in raw_env.items():
             env_key = str(key or "").strip()
@@ -1225,7 +1428,7 @@ Use **Test** when the file exposes runtime dependencies.
             if env_value == "":
                 continue
             resolved[env_key] = env_value
-        return resolved
+        return ensure_utf8_subprocess_env(resolved)
 
     def _prepare_codex_probe_home(
         self,
@@ -1267,34 +1470,233 @@ Use **Test** when the file exposes runtime dependencies.
                 ]
             )
         else:
-            guidance.append("Run `codex --login` (or `codex`) once and finish authentication before starting DeepScientist.")
+            guidance.append("Run `codex login` (or just `codex`) once and finish authentication before starting DeepScientist.")
         guidance.append(
             "If you use a custom Codex path, either set `runners.codex.binary` or launch with `ds --codex /absolute/path/to/codex`."
         )
         return guidance
 
-    def _codex_probe_failure_guidance(self, config: dict) -> tuple[list[str], list[str]]:
+    @staticmethod
+    def _provider_profile_probe_hints(metadata: dict[str, object]) -> list[str]:
+        base_url = str(metadata.get("base_url") or "").strip().lower()
+        model = str(metadata.get("model") or "").strip().lower()
+        provider = str(metadata.get("provider") or "").strip().lower()
+        if "dashscope.aliyuncs.com" not in base_url and "bailian" not in provider and "qwen" not in model:
+            return []
+        if "coding.dashscope.aliyuncs.com" not in base_url:
+            return [
+                "Alibaba Bailian's generic DashScope / Qwen platform API is not supported by the Codex-backed DeepScientist path.",
+                "If you want to use Qwen here, switch the profile to the Bailian Coding Plan endpoint: `https://coding.dashscope.aliyuncs.com/v1`.",
+            ]
+        return [
+            "For Qwen on Alibaba Bailian, only the Coding Plan endpoint is supported here; do not switch back to the generic Bailian / DashScope Qwen API.",
+        ]
+
+    @staticmethod
+    def _local_provider_probe_hints(metadata: dict[str, object]) -> list[str]:
+        base_url = str(metadata.get("base_url") or "").strip()
+        wire_api = str(metadata.get("wire_api") or "").strip().lower()
+        requires_openai_auth = metadata.get("requires_openai_auth")
+        if not base_url:
+            return []
+        is_local_provider = provider_base_url_looks_local(base_url)
+        if requires_openai_auth is not False and not is_local_provider:
+            return []
+        hints = [
+            f"Verify the local provider directly: `curl {base_url}/models`.",
+            f"Then verify the Responses API explicitly: `curl {base_url}/responses ...`.",
+            "Latest Codex CLI requires `wire_api = \"responses\"`; chat-only provider configs are no longer accepted.",
+            "If `/v1/chat/completions` works but `/v1/responses` fails, that backend is not currently compatible with the latest Codex runner.",
+            "If the backend is chat-only and you still want to test it through Codex, try `@openai/codex@0.57.0` with top-level `model_provider` / `model` plus `wire_api = \"chat\"`.",
+            "For local model backends, vLLM is the safest path. Ollama only works when its `/v1/responses` endpoint works; chat-only SGLang deployments will fail with the latest Codex.",
+        ]
+        if requires_openai_auth is not False:
+            hints.insert(
+                0,
+                "For local or self-hosted providers, add `requires_openai_auth = false` so DeepScientist can remove conflicting `OPENAI_*` auth variables.",
+            )
+        if not wire_api:
+            hints.insert(0, "Your current provider config does not declare `wire_api`; set `wire_api = \"responses\"` first.")
+        elif wire_api != "responses":
+            hints.insert(0, f"Your current provider config uses `wire_api = \"{wire_api}\"`; switch it to `wire_api = \"responses\"` first.")
+        return hints
+
+    @staticmethod
+    def _codex_direct_hello_probe_command(*, profile: str = "") -> str:
+        profile_args = f" --profile {shlex.quote(profile)}" if profile else ""
+        return (
+            "printf 'Reply with exactly HELLO.' | "
+            f"codex --search{profile_args} exec --json --cd /tmp --skip-git-repo-check -"
+        )
+
+    @staticmethod
+    def _missing_provider_env_guidance(
+        *,
+        profile: str,
+        env_key: str,
+        metadata: dict[str, object],
+    ) -> list[str]:
+        guidance = [
+            f"Set `runners.codex.env.{env_key}` in `~/DeepScientist/config/runners.yaml`, or export `{env_key}` before launching `ds`.",
+        ]
+        if provider_base_url_looks_local(str(metadata.get("base_url") or "").strip()):
+            guidance.append(
+                f"If `{env_key}` is only a placeholder for a local OpenAI-compatible backend, any non-empty value such as `1234` is usually enough."
+            )
+            if metadata.get("requires_openai_auth") is not False:
+                guidance.append(
+                    "Also add `requires_openai_auth = false` to that local provider profile so DeepScientist can remove conflicting `OPENAI_*` auth variables."
+                )
+        guidance.append(
+            "Before retrying DeepScientist, run a real request such as "
+            f"`{ConfigManager._codex_direct_hello_probe_command(profile=profile)}` and verify it returns `HELLO`."
+        )
+        return guidance
+
+    @staticmethod
+    def _chat_wire_probe_version_block(
+        metadata: dict[str, object],
+        *,
+        resolved_binary: str,
+    ) -> tuple[tuple[int, int, int] | None, dict[str, object] | None]:
+        wire_api = str(metadata.get("wire_api") or "").strip().lower()
+        if wire_api != "chat":
+            return None, None
+        detected_version = codex_cli_version(str(resolved_binary or ""))
+        required_version = chat_wire_compatible_codex_version()
+        if detected_version == required_version:
+            return detected_version, None
+        required_text = format_codex_cli_version(required_version)
+        detected_text = format_codex_cli_version(detected_version)
+        errors = [
+            "This provider uses `wire_api = \"chat\"`, but DeepScientist only probes chat-mode providers with `codex-cli 0.57.0`.",
+        ]
+        if detected_text:
+            errors.append(f"Detected Codex CLI version: `{detected_text}`.")
+        else:
+            errors.append("DeepScientist could not determine the active Codex CLI version from the configured binary.")
+        guidance = [
+            "Install `npm install -g @openai/codex@0.57.0`, or point DeepScientist at a dedicated `0.57.0` binary with `ds --codex /absolute/path/to/codex`.",
+            "If you want to stay on a newer Codex CLI, switch the provider/backend to `wire_api = \"responses\"` instead.",
+            "For chat-mode fallback configs, keep the compatible top-level `model_provider` / `model` entries in `~/.codex/config.toml`.",
+        ]
+        return (
+            detected_version,
+            {
+                "summary": f"Codex startup probe blocked by chat-mode provider compatibility. Required Codex CLI: `{required_text}`.",
+                "errors": errors,
+                "guidance": guidance,
+            },
+        )
+
+    @staticmethod
+    def _codex_probe_text_looks_auth_related(stdout_text: str, stderr_text: str) -> bool:
+        haystack = f"{stdout_text}\n{stderr_text}".lower()
+        markers = (
+            "please login",
+            "not logged in",
+            "login required",
+            "authentication required",
+            "auth required",
+            "oauth",
+            "unauthenticated",
+            "missing credentials",
+            "no credentials",
+        )
+        return any(marker in haystack for marker in markers)
+
+    @staticmethod
+    def _codex_probe_text_looks_network_related(stdout_text: str, stderr_text: str) -> bool:
+        haystack = f"{stdout_text}\n{stderr_text}".lower()
+        markers = (
+            "connection refused",
+            "connection reset",
+            "connection timed out",
+            "network is unreachable",
+            "name or service not known",
+            "temporary failure in name resolution",
+            "dns",
+            "proxy",
+            "tls",
+            "certificate",
+            "ssl",
+            "timeout",
+            "timed out",
+            "econnreset",
+            "econnrefused",
+            "enotfound",
+        )
+        return any(marker in haystack for marker in markers)
+
+    def _codex_probe_failure_guidance(
+        self,
+        config: dict,
+        *,
+        stdout_text: str = "",
+        stderr_text: str = "",
+    ) -> tuple[list[str], list[str]]:
         profile = self._codex_profile_name(config)
+        config_dir = str(config.get("config_dir") or "~/.codex").strip()
+        metadata = active_provider_metadata_from_home(config_dir, profile=profile or None) if config_dir else {}
         if profile:
+            provider_hints = self._provider_profile_probe_hints(metadata)
+            local_hints = self._local_provider_probe_hints(metadata)
             return (
                 [
                     f"Codex profile `{profile}` did not complete the startup hello probe successfully.",
                 ],
                 [
-                    f"Run `codex --profile {profile}` in a terminal and confirm that profile can start normally.",
+                    f"Run `{self._codex_direct_hello_probe_command(profile=profile)}` in a terminal and confirm that a real `HELLO` request succeeds.",
                     "If the profile uses a custom provider, make sure its API key, Base URL, and model configuration are available to Codex.",
                     "If the provider expects the model from the Codex profile itself, set `model: inherit` in `~/DeepScientist/config/runners.yaml`.",
+                    *provider_hints,
+                    *local_hints,
+                    "Then run `ds doctor` and start DeepScientist again.",
+                ],
+            )
+        if self._codex_probe_text_looks_auth_related(stdout_text, stderr_text):
+            return (
+                [
+                    "Codex reported an authentication or first-run setup problem during the startup hello probe.",
+                    "Run `codex login` (or just `codex`) once and complete login before starting DeepScientist.",
+                ],
+                [
+                    "Run `codex login` (or just `codex`) in a terminal and complete login or first-run setup.",
+                    "Then run `printf 'Reply with exactly HELLO.' | codex --search exec --json --cd /tmp --skip-git-repo-check -` and confirm the real request succeeds.",
+                    "If login succeeds but the direct probe still fails, check the configured model, provider profile, proxy, and Codex account access.",
+                    "Then run `ds doctor` and start DeepScientist again.",
+                ],
+            )
+        if self._codex_model_unavailable(stdout_text, stderr_text):
+            return (
+                [
+                    "Codex authentication may be working, but the configured startup probe model was not accepted.",
+                ],
+                [
+                    "Run `printf 'Reply with exactly HELLO.' | codex --search exec --json --cd /tmp --skip-git-repo-check -` in the same shell and confirm the current Codex default model works.",
+                    "Set `runners.codex.model: inherit` in `~/DeepScientist/config/runners.yaml`, or set it to a model that your Codex account can actually use.",
+                    "Then run `ds doctor` and start DeepScientist again.",
+                ],
+            )
+        if self._codex_probe_text_looks_network_related(stdout_text, stderr_text):
+            return (
+                [
+                    "Codex CLI was found, but the real startup hello request appears to have failed at the network, proxy, TLS, or provider layer.",
+                ],
+                [
+                    "Run `printf 'Reply with exactly HELLO.' | codex --search exec --json --cd /tmp --skip-git-repo-check -` from the same shell and verify the request succeeds.",
+                    "If this host needs a proxy, export `HTTP_PROXY`, `HTTPS_PROXY`, and `NO_PROXY` before launching `ds`; for managed or supervised runs, also put required environment variables under `runners.codex.env`.",
                     "Then run `ds doctor` and start DeepScientist again.",
                 ],
             )
         return (
             [
-                "Run `codex --login` (or `codex`) once and complete login before starting DeepScientist.",
+                "Codex CLI was found, but its real startup hello request did not complete successfully.",
             ],
             [
-                "Run `codex --login` (or `codex`) in a terminal and complete login or first-run setup.",
-                "If `codex` is missing, install it explicitly with `npm install -g @openai/codex`.",
-                "If the configured model is not available to your Codex account, update `~/DeepScientist/config/runners.yaml` and try again.",
+                "Run `printf 'Reply with exactly HELLO.' | codex --search exec --json --cd /tmp --skip-git-repo-check -` in the same shell and inspect the Codex stderr/stdout.",
+                "If that direct command succeeds but `ds doctor` fails, compare `which codex`, `CODEX_HOME`, proxy variables, and `~/DeepScientist/config/runners.yaml`.",
+                "If the configured model is not available to your Codex account, set `runners.codex.model: inherit` or another accessible model.",
                 "Then run `ds doctor` and start DeepScientist again.",
             ],
         )
@@ -1417,8 +1819,8 @@ Use **Test** when the file exposes runtime dependencies.
         approval_policy = str(config.get("approval_policy") or "on-request").strip()
         sandbox_mode = str(config.get("sandbox_mode") or "workspace-write").strip()
 
-        env = os.environ.copy()
-        env.update(self._codex_runner_env(config))
+        env = ensure_utf8_subprocess_env(os.environ.copy())
+        env.update(self._claude_auth_runner_env(self._codex_runner_env(config)))
         config_dir = str(config.get("config_dir") or "~/.codex").strip()
         probe_home_handle: tempfile.TemporaryDirectory[str] | None = None
         compatibility_warnings: list[str] = []
@@ -1430,10 +1832,20 @@ Use **Test** when the file exposes runtime dependencies.
             env["CODEX_HOME"] = prepared_home
             if profile_config_warning:
                 compatibility_warnings.append(profile_config_warning)
-        metadata = provider_profile_metadata_from_home(env.get("CODEX_HOME") or config_dir, profile=profile)
+        metadata = active_provider_metadata_from_home(env.get("CODEX_HOME") or config_dir, profile=profile or None)
         if metadata.get("requires_openai_auth") is False:
             env.pop("OPENAI_API_KEY", None)
             env.pop("OPENAI_BASE_URL", None)
+        configured_provider_env_key = missing_provider_env_key(metadata, env)
+        details["provider_env_key"] = str(metadata.get("env_key") or "").strip() or None
+        details["provider_env_missing"] = bool(configured_provider_env_key)
+        details["provider_wire_api"] = str(metadata.get("wire_api") or "").strip() or None
+        detected_codex_version, chat_wire_block = self._chat_wire_probe_version_block(
+            metadata,
+            resolved_binary=resolved_binary,
+        )
+        if detected_codex_version is not None:
+            details["codex_cli_version"] = format_codex_cli_version(detected_codex_version) or None
         prompt = "Reply with exactly HELLO."
         if reasoning_effort_warning:
             compatibility_warnings.append(reasoning_effort_warning)
@@ -1442,6 +1854,15 @@ Use **Test** when the file exposes runtime dependencies.
                 f"Codex profile `{profile}` is provider-backed. DeepScientist is probing it with `model: inherit`."
             )
         base_warnings: list[str] = list(compatibility_warnings)
+        if chat_wire_block is not None:
+            return {
+                "ok": False,
+                "summary": str(chat_wire_block["summary"]),
+                "warnings": base_warnings,
+                "errors": list(chat_wire_block["errors"]),
+                "details": details,
+                "guidance": list(chat_wire_block["guidance"]),
+            }
 
         def run_probe_once(model_for_command: str) -> tuple[list[str], subprocess.CompletedProcess[str] | None, subprocess.TimeoutExpired | None]:
             command = self._build_codex_probe_command(
@@ -1458,10 +1879,10 @@ Use **Test** when the file exposes runtime dependencies.
                     input=prompt,
                     cwd=str(repo_root()),
                     env=env,
-                    text=True,
                     capture_output=True,
                     timeout=90,
                     check=False,
+                    **utf8_text_subprocess_kwargs(),
                 )
             except subprocess.TimeoutExpired as exc:
                 return command, None, exc
@@ -1469,25 +1890,32 @@ Use **Test** when the file exposes runtime dependencies.
 
         command, result, timeout_error = run_probe_once(effective_model)
         if timeout_error is not None:
+            stdout_text = str(timeout_error.stdout or "")
+            stderr_text = str(timeout_error.stderr or "")
             details.update(
                 {
                     "exit_code": None,
-                    "stdout_excerpt": self._compact_probe_text(timeout_error.stdout or ""),
-                    "stderr_excerpt": self._compact_probe_text(timeout_error.stderr or ""),
+                    "stdout_excerpt": self._compact_probe_text(stdout_text),
+                    "stderr_excerpt": self._compact_probe_text(stderr_text),
                     "probe_command": command,
                 }
             )
+            failure_errors, failure_guidance = self._codex_probe_failure_guidance(
+                config,
+                stdout_text=stdout_text,
+                stderr_text=stderr_text,
+            )
             return {
                 "ok": False,
                 "summary": "Codex startup probe timed out.",
                 "warnings": base_warnings,
                 "errors": [
                     "Codex did not answer the startup hello probe within 90 seconds.",
-                    *self._codex_probe_failure_guidance(config)[0],
+                    *failure_errors,
                 ],
                 "details": details,
                 "guidance": [
-                    *self._codex_probe_failure_guidance(config)[1],
+                    *failure_guidance,
                     "If `codex` is missing on PATH, install it explicitly with `npm install -g @openai/codex`.",
                     "Confirm the configured model is available to your Codex setup. DeepScientist currently probes Codex with the configured runner model first.",
                 ],
@@ -1567,8 +1995,31 @@ Use **Test** when the file exposes runtime dependencies.
                 warnings.append("Codex returned stderr during the startup probe.")
             if details.get("model_fallback_attempted") and not details.get("model_fallback_used"):
                 warnings.append("DeepScientist also tried the current Codex default model, but that fallback probe did not succeed.")
-            errors.extend(self._codex_probe_failure_guidance(config)[0])
-        failure_guidance = self._codex_probe_failure_guidance(config)[1]
+            errors.extend(
+                self._codex_probe_failure_guidance(
+                    config,
+                    stdout_text=stdout_text,
+                    stderr_text=stderr_text,
+                )[0]
+            )
+        missing_env_key = missing_provider_env_key_from_text(stdout_text, stderr_text) or configured_provider_env_key
+        failure_guidance = self._codex_probe_failure_guidance(
+            config,
+            stdout_text=stdout_text,
+            stderr_text=stderr_text,
+        )[1]
+        if not ok and missing_env_key and profile:
+            errors.append(
+                f"Codex profile `{profile}` requires environment variable `{missing_env_key}`, but DeepScientist did not receive it."
+            )
+            failure_guidance = [
+                *self._missing_provider_env_guidance(
+                    profile=profile,
+                    env_key=missing_env_key,
+                    metadata=metadata,
+                ),
+                *failure_guidance,
+            ]
         return {
             "ok": ok,
             "summary": "Codex startup probe completed." if ok else "Codex startup probe failed.",
@@ -1578,38 +2029,402 @@ Use **Test** when the file exposes runtime dependencies.
             "guidance": [] if ok else failure_guidance,
         }
 
-    def _persist_codex_bootstrap_result(self, result: dict) -> None:
+    def _persist_runner_bootstrap_result(self, runner_name: str, result: dict) -> None:
+        normalized_runner = str(runner_name or "codex").strip().lower() or "codex"
         config = self.load_named_normalized("config")
         bootstrap = config.get("bootstrap") if isinstance(config.get("bootstrap"), dict) else {}
         details = result.get("details") if isinstance(result.get("details"), dict) else {}
-        bootstrap["codex_ready"] = bool(result.get("ok"))
-        bootstrap["codex_last_checked_at"] = details.get("checked_at") or utc_now()
-        bootstrap["codex_last_result"] = {
-            "ok": bool(result.get("ok")),
-            "summary": result.get("summary"),
-            "warnings": list(result.get("warnings") or []),
-            "errors": list(result.get("errors") or []),
-            "guidance": list(result.get("guidance") or []),
-            "binary": details.get("binary"),
-            "resolved_binary": details.get("resolved_binary"),
-            "profile": details.get("profile"),
-            "model": details.get("model"),
-            "requested_model": details.get("requested_model"),
-            "effective_model": details.get("effective_model"),
-            "model_fallback_attempted": bool(details.get("model_fallback_attempted")),
-            "model_fallback_used": bool(details.get("model_fallback_used")),
-            "approval_policy": details.get("approval_policy"),
-            "sandbox_mode": details.get("sandbox_mode"),
-            "reasoning_effort": details.get("reasoning_effort"),
-            "exit_code": details.get("exit_code"),
-            "stdout_excerpt": details.get("stdout_excerpt"),
-            "stderr_excerpt": details.get("stderr_excerpt"),
+        runner_readiness = bootstrap.get("runner_readiness") if isinstance(bootstrap.get("runner_readiness"), dict) else {}
+        runner_readiness[normalized_runner] = {
+            "ready": bool(result.get("ok")),
+            "last_checked_at": details.get("checked_at") or utc_now(),
+            "last_result": {
+                "ok": bool(result.get("ok")),
+                "summary": result.get("summary"),
+                "warnings": list(result.get("warnings") or []),
+                "errors": list(result.get("errors") or []),
+                "guidance": list(result.get("guidance") or []),
+                "binary": details.get("binary"),
+                "resolved_binary": details.get("resolved_binary"),
+                "model": details.get("model"),
+                "requested_model": details.get("requested_model"),
+                "effective_model": details.get("effective_model"),
+                "exit_code": details.get("exit_code"),
+                "stdout_excerpt": details.get("stdout_excerpt"),
+                "stderr_excerpt": details.get("stderr_excerpt"),
+                "profile": details.get("profile"),
+                "permission_mode": details.get("permission_mode"),
+                "variant": details.get("variant"),
+            },
         }
+        bootstrap["runner_readiness"] = runner_readiness
+        if normalized_runner == "codex":
+            codex_state = runner_readiness["codex"]
+            bootstrap["codex_ready"] = bool(codex_state.get("ready"))
+            bootstrap["codex_last_checked_at"] = codex_state.get("last_checked_at")
+            bootstrap["codex_last_result"] = codex_state.get("last_result")
         config["bootstrap"] = bootstrap
         self.save_named_payload("config", config)
-        if bool(result.get("ok")) and bool(details.get("model_fallback_used")):
+        if normalized_runner == "codex" and bool(result.get("ok")) and bool(details.get("model_fallback_used")):
             self._persist_codex_model_inherit(details.get("requested_model"))
 
+    def _persist_codex_bootstrap_result(self, result: dict) -> None:
+        self._persist_runner_bootstrap_result("codex", result)
+
+    @staticmethod
+    def _copy_runner_file_if_exists(source: Path, target: Path) -> None:
+        if not source.exists() or not source.is_file():
+            return
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source, target)
+
+    @staticmethod
+    def _claude_auth_runner_env(env: dict[str, str]) -> dict[str, str]:
+        resolved = dict(env)
+        auth_token = str(resolved.get("ANTHROPIC_AUTH_TOKEN") or "").strip()
+        api_key = str(resolved.get("ANTHROPIC_API_KEY") or "").strip()
+        if auth_token and not api_key:
+            resolved["ANTHROPIC_API_KEY"] = auth_token
+        return resolved
+
+    def _runner_missing_binary_guidance(self, runner_name: str, config: dict) -> list[str]:
+        normalized_runner = str(runner_name or "").strip().lower()
+        binary = str(config.get("binary") or normalized_runner).strip() or normalized_runner
+        if normalized_runner == "codex":
+            return self._codex_missing_binary_guidance(config)
+        if normalized_runner == "claude":
+            return [
+                f"Install Claude Code and make sure `{binary} --version` works in the current shell.",
+                "If Claude Code is already installed elsewhere, set `runners.claude.binary` to the absolute path.",
+            ]
+        if normalized_runner == "opencode":
+            return [
+                f"Install OpenCode and make sure `{binary} --version` works in the current shell.",
+                "If OpenCode is already installed elsewhere, set `runners.opencode.binary` to the absolute path.",
+            ]
+        if normalized_runner == "kimi":
+            return [
+                f"Install Kimi Code and make sure `{binary} --version` works in the current shell.",
+                "Run `kimi login` (or just `kimi`) once to complete the first-run login flow.",
+                "If Kimi Code uses a custom home, point `runners.kimi.config_dir` at the correct `~/.kimi`-style directory that contains `config.toml` and `mcp.json`.",
+            ]
+        return [f"Install runner `{normalized_runner}` and ensure `{binary}` is on PATH."]
+
+    def _probe_claude_runner(self, config: dict) -> dict:
+        checked_at = utc_now()
+        binary = str(config.get("binary") or "claude").strip() or "claude"
+        resolved_binary = resolve_runner_binary(binary, runner_name="claude")
+        requested_model = str(config.get("model") or "inherit").strip() or "inherit"
+        permission_mode = str(config.get("permission_mode") or "bypassPermissions").strip() or "bypassPermissions"
+        details: dict[str, object] = {
+            "binary": binary,
+            "resolved_binary": resolved_binary,
+            "config_dir": str(config.get("config_dir") or "~/.claude"),
+            "model": requested_model,
+            "requested_model": requested_model,
+            "effective_model": requested_model,
+            "permission_mode": permission_mode,
+            "checked_at": checked_at,
+        }
+        if not resolved_binary:
+            return {
+                "ok": False,
+                "summary": "Claude Code startup probe failed before execution.",
+                "warnings": [],
+                "errors": [f"Claude Code binary `{binary}` is not available."],
+                "details": details,
+                "guidance": self._runner_missing_binary_guidance("claude", config),
+            }
+        env = ensure_utf8_subprocess_env(os.environ.copy())
+        env.update(self._claude_auth_runner_env(self._codex_runner_env(config)))
+        temp_home_handle = tempfile.TemporaryDirectory()
+        try:
+            temp_home = Path(temp_home_handle.name)
+            source_home = Path(str(config.get("config_dir") or Path.home() / ".claude")).expanduser()
+            for filename in (".credentials.json", "settings.json", "settings.local.json"):
+                self._copy_runner_file_if_exists(source_home / filename, temp_home / filename)
+            env["CLAUDE_CONFIG_DIR"] = str(temp_home)
+            command = [
+                resolved_binary,
+                "-p",
+                "--input-format",
+                "text",
+                "--output-format",
+                "json",
+                "--add-dir",
+                str(repo_root()),
+                "--no-session-persistence",
+                "--permission-mode",
+                permission_mode,
+            ]
+            if requested_model.lower() not in {"", "inherit", "default", "claude-default"}:
+                command.extend(["--model", requested_model])
+            command.extend(["--tools", ""])
+            result = subprocess.run(
+                command,
+                input="Reply with exactly HELLO.",
+                cwd=str(repo_root()),
+                env=env,
+                capture_output=True,
+                timeout=90,
+                check=False,
+                **utf8_text_subprocess_kwargs(),
+            )
+        except subprocess.TimeoutExpired as exc:
+            details.update({
+                "exit_code": None,
+                "stdout_excerpt": self._compact_probe_text(exc.stdout or ""),
+                "stderr_excerpt": self._compact_probe_text(exc.stderr or ""),
+            })
+            return {
+                "ok": False,
+                "summary": "Claude Code startup probe timed out.",
+                "warnings": [],
+                "errors": ["Claude Code did not answer the startup probe within 90 seconds."],
+                "details": details,
+                "guidance": [
+                    "Run a small headless Claude Code request manually and confirm it can answer before starting DeepScientist.",
+                ],
+            }
+        finally:
+            temp_home_handle.cleanup()
+        stdout_text = (result.stdout or "").strip()
+        stderr_text = (result.stderr or "").strip()
+        ok = result.returncode == 0 and "HELLO" in f"{stdout_text}\n{stderr_text}".upper()
+        details.update({
+            "exit_code": result.returncode,
+            "stdout_excerpt": self._compact_probe_text(stdout_text),
+            "stderr_excerpt": self._compact_probe_text(stderr_text),
+            "probe_command": command,
+        })
+        return {
+            "ok": ok,
+            "summary": "Claude Code startup probe completed." if ok else "Claude Code startup probe failed.",
+            "warnings": ["Claude Code returned stderr during the startup probe."] if stderr_text else [],
+            "errors": [] if ok else ["Claude Code did not complete the startup hello probe successfully."],
+            "details": details,
+            "guidance": [] if ok else [
+                "Run `claude -p \"Reply with exactly HELLO.\" --output-format json --tools \"\"` manually and confirm it returns `HELLO`.",
+                "If Claude Code uses a custom account or credential path, point `runners.claude.config_dir` at the correct home.",
+            ],
+        }
+
+    def _probe_opencode_runner(self, config: dict) -> dict:
+        checked_at = utc_now()
+        binary = str(config.get("binary") or "opencode").strip() or "opencode"
+        resolved_binary = resolve_runner_binary(binary, runner_name="opencode")
+        requested_model = str(config.get("model") or "inherit").strip() or "inherit"
+        variant = str(config.get("variant") or "").strip() or None
+        permission_mode = str(config.get("permission_mode") or "allow").strip().lower() or "allow"
+        details: dict[str, object] = {
+            "binary": binary,
+            "resolved_binary": resolved_binary,
+            "config_dir": str(config.get("config_dir") or "~/.config/opencode"),
+            "model": requested_model,
+            "requested_model": requested_model,
+            "effective_model": requested_model,
+            "variant": variant,
+            "permission_mode": permission_mode,
+            "checked_at": checked_at,
+        }
+        if not resolved_binary:
+            return {
+                "ok": False,
+                "summary": "OpenCode startup probe failed before execution.",
+                "warnings": [],
+                "errors": [f"OpenCode binary `{binary}` is not available."],
+                "details": details,
+                "guidance": self._runner_missing_binary_guidance("opencode", config),
+            }
+        env = ensure_utf8_subprocess_env(os.environ.copy())
+        env.update(self._codex_runner_env(config))
+        temp_home_handle = tempfile.TemporaryDirectory()
+        try:
+            temp_home = Path(temp_home_handle.name)
+            config_root = temp_home / ".config" / "opencode"
+            config_root.mkdir(parents=True, exist_ok=True)
+            source_root = Path(str(config.get("config_dir") or Path.home() / ".config" / "opencode")).expanduser()
+            self._copy_runner_file_if_exists(source_root / "opencode.json", config_root / "opencode.json")
+            env["HOME"] = str(temp_home)
+            env["XDG_CONFIG_HOME"] = str(temp_home / ".config")
+            command = [
+                resolved_binary,
+                "run",
+                "--format",
+                "json",
+                "--pure",
+                "--dir",
+                str(repo_root()),
+            ]
+            if requested_model.lower() not in {"", "inherit", "default", "opencode-default"}:
+                command.extend(["--model", requested_model])
+            if variant:
+                command.extend(["--variant", variant])
+            command.append("Reply with exactly HELLO")
+            result = subprocess.run(
+                command,
+                cwd=str(repo_root()),
+                env=env,
+                capture_output=True,
+                timeout=90,
+                check=False,
+                **utf8_text_subprocess_kwargs(),
+            )
+        except subprocess.TimeoutExpired as exc:
+            details.update({
+                "exit_code": None,
+                "stdout_excerpt": self._compact_probe_text(exc.stdout or ""),
+                "stderr_excerpt": self._compact_probe_text(exc.stderr or ""),
+            })
+            return {
+                "ok": False,
+                "summary": "OpenCode startup probe timed out.",
+                "warnings": [],
+                "errors": ["OpenCode did not answer the startup probe within 90 seconds."],
+                "details": details,
+                "guidance": [
+                    "Run a small `opencode run --format json` request manually and confirm it can answer before starting DeepScientist.",
+                ],
+            }
+        finally:
+            temp_home_handle.cleanup()
+        stdout_text = (result.stdout or "").strip()
+        stderr_text = (result.stderr or "").strip()
+        ok = result.returncode == 0 and "HELLO" in f"{stdout_text}\n{stderr_text}".upper()
+        details.update({
+            "exit_code": result.returncode,
+            "stdout_excerpt": self._compact_probe_text(stdout_text),
+            "stderr_excerpt": self._compact_probe_text(stderr_text),
+            "probe_command": command,
+        })
+        return {
+            "ok": ok,
+            "summary": "OpenCode startup probe completed." if ok else "OpenCode startup probe failed.",
+            "warnings": ["OpenCode returned stderr during the startup probe."] if stderr_text else [],
+            "errors": [] if ok else ["OpenCode did not complete the startup hello probe successfully."],
+            "details": details,
+            "guidance": [] if ok else [
+                "Run `opencode run --format json \"Reply with exactly HELLO\"` manually and confirm it succeeds.",
+                "If OpenCode uses a custom config root, point `runners.opencode.config_dir` at the correct directory.",
+            ],
+        }
+
+    def _probe_kimi_runner(self, config: dict) -> dict:
+        checked_at = utc_now()
+        binary = str(config.get("binary") or "kimi").strip() or "kimi"
+        resolved_binary = resolve_runner_binary(binary, runner_name="kimi")
+        requested_model = str(config.get("model") or "inherit").strip() or "inherit"
+        agent_name = str(config.get("agent") or "").strip() or None
+        yolo_enabled = bool(config.get("yolo", True))
+        thinking_enabled = bool(config.get("thinking", False))
+        details: dict[str, object] = {
+            "binary": binary,
+            "resolved_binary": resolved_binary,
+            "config_dir": str(config.get("config_dir") or "~/.kimi"),
+            "model": requested_model,
+            "requested_model": requested_model,
+            "effective_model": requested_model,
+            "agent": agent_name,
+            "thinking": thinking_enabled,
+            "yolo": yolo_enabled,
+            "checked_at": checked_at,
+        }
+        if not resolved_binary:
+            return {
+                "ok": False,
+                "summary": "Kimi Code startup probe failed before execution.",
+                "warnings": [],
+                "errors": [f"Kimi Code binary `{binary}` is not available."],
+                "details": details,
+                "guidance": self._runner_missing_binary_guidance("kimi", config),
+            }
+        env = ensure_utf8_subprocess_env(os.environ.copy())
+        env.update(self._codex_runner_env(config))
+        temp_home_handle = tempfile.TemporaryDirectory()
+        try:
+            temp_home = Path(temp_home_handle.name)
+            kimi_home = materialize_kimi_runtime_home(
+                source_home=Path(str(config.get("config_dir") or Path.home() / ".kimi")).expanduser(),
+                target_home=temp_home,
+            )
+            mcp_config_path = kimi_home / "mcp.json"
+            write_json(mcp_config_path, {"mcpServers": {}})
+            env["HOME"] = str(temp_home)
+            env["USERPROFILE"] = str(temp_home)
+            command = [
+                resolved_binary,
+                "--print",
+                "--input-format",
+                "text",
+                "--output-format",
+                "stream-json",
+                "--work-dir",
+                str(repo_root()),
+                "--mcp-config-file",
+                str(mcp_config_path),
+            ]
+            if yolo_enabled:
+                command.append("--yolo")
+            if requested_model.lower() not in {"", "inherit", "default", "kimi-default"}:
+                command.extend(["--model", requested_model])
+            if agent_name:
+                command.extend(["--agent", agent_name])
+            if thinking_enabled:
+                command.append("--thinking")
+            result = subprocess.run(
+                command,
+                input="Reply with exactly HELLO.",
+                cwd=str(repo_root()),
+                env=env,
+                capture_output=True,
+                timeout=90,
+                check=False,
+                **utf8_text_subprocess_kwargs(),
+            )
+        except subprocess.TimeoutExpired as exc:
+            details.update(
+                {
+                    "exit_code": None,
+                    "stdout_excerpt": self._compact_probe_text(exc.stdout or ""),
+                    "stderr_excerpt": self._compact_probe_text(exc.stderr or ""),
+                }
+            )
+            return {
+                "ok": False,
+                "summary": "Kimi Code startup probe timed out.",
+                "warnings": [],
+                "errors": ["Kimi Code did not answer the startup probe within 90 seconds."],
+                "details": details,
+                "guidance": [
+                    "Run a small `kimi --print --output-format stream-json` request manually and confirm it can answer before starting DeepScientist.",
+                ],
+            }
+        finally:
+            temp_home_handle.cleanup()
+        stdout_text = (result.stdout or "").strip()
+        stderr_text = (result.stderr or "").strip()
+        ok = result.returncode == 0 and "HELLO" in f"{stdout_text}\n{stderr_text}".upper()
+        details.update(
+            {
+                "exit_code": result.returncode,
+                "stdout_excerpt": self._compact_probe_text(stdout_text),
+                "stderr_excerpt": self._compact_probe_text(stderr_text),
+                "probe_command": command,
+            }
+        )
+        return {
+            "ok": ok,
+            "summary": "Kimi Code startup probe completed." if ok else "Kimi Code startup probe failed.",
+            "warnings": ["Kimi Code returned stderr during the startup probe."] if stderr_text else [],
+            "errors": [] if ok else ["Kimi Code did not complete the startup hello probe successfully."],
+            "details": details,
+            "guidance": [] if ok else [
+                "Run `kimi --print --input-format text --output-format stream-json --yolo` manually and confirm it returns `HELLO`.",
+                "Run `kimi login` first if this machine has not completed the Kimi Code login flow yet.",
+                "If Kimi Code uses a custom home, point `runners.kimi.config_dir` at the correct `~/.kimi`-style directory.",
+            ],
+        }
+
     @staticmethod
     def _compact_probe_text(value: str, *, limit: int = 1200) -> str:
         text = str(value or "").strip()
@@ -1864,11 +2679,31 @@ Use **Test** when the file exposes runtime dependencies.
         defaults = default_payload(name, self.home)
         if name == "runners":
             normalized = self._deep_merge(defaults, prepared)
+            runtime_enabled_runners = self._runtime_enabled_runner_names()
             codex = normalized.get("codex")
-            if isinstance(codex, dict) and self._looks_like_legacy_codex_retry_profile(codex):
-                codex["retry_initial_backoff_sec"] = 10.0
-                codex["retry_backoff_multiplier"] = 6.0
-                codex["retry_max_backoff_sec"] = 1800.0
+            if isinstance(codex, dict):
+                if self._looks_like_legacy_codex_retry_profile(codex):
+                    codex["retry_initial_backoff_sec"] = 10.0
+                    codex["retry_backoff_multiplier"] = 6.0
+                    codex["retry_max_backoff_sec"] = 1800.0
+                if self._looks_like_preupgrade_codex_retry_attempt_profile(codex):
+                    codex["retry_max_attempts"] = 7
+            claude = normalized.get("claude")
+            if isinstance(claude, dict):
+                legacy_approval_policy = str(claude.get("approval_policy") or "").strip().lower()
+                if legacy_approval_policy and not str(claude.get("permission_mode") or "").strip():
+                    if legacy_approval_policy == "never":
+                        claude["permission_mode"] = "bypassPermissions"
+                    elif legacy_approval_policy in {"on-request", "default"}:
+                        claude["permission_mode"] = "default"
+                if "approval_policy" in claude:
+                    claude.pop("approval_policy", None)
+                if "sandbox_mode" in claude:
+                    claude.pop("sandbox_mode", None)
+            for runner_name in runtime_enabled_runners:
+                runner_config = normalized.get(runner_name)
+                if isinstance(runner_config, dict):
+                    runner_config["enabled"] = True
             return normalized
         if name == "connectors":
             normalized = deepcopy(defaults)
@@ -1913,9 +2748,44 @@ Use **Test** when the file exposes runtime dependencies.
             return normalized
         return self._deep_merge(defaults, prepared)
 
+    @staticmethod
+    def _normalize_runtime_runner_name(value: object) -> str:
+        normalized = str(value or "").strip().lower().replace("_", "-")
+        if normalized in {"claude-code", "claudecode"}:
+            return "claude"
+        if normalized in {"kimi-code", "kimicode"}:
+            return "kimi"
+        if normalized in {"open-code", "open code", "opencode-ai", "opencodeai"}:
+            return "opencode"
+        return normalized.replace("-", "")
+
+    @classmethod
+    def _runtime_enabled_runner_names(cls) -> set[str]:
+        names: set[str] = set()
+        raw_values = [
+            os.environ.get("DEEPSCIENTIST_DEFAULT_RUNNER"),
+            os.environ.get("DS_DEFAULT_RUNNER"),
+            os.environ.get("DEEPSCIENTIST_ENABLE_RUNNER"),
+            os.environ.get("DS_ENABLE_RUNNER"),
+            os.environ.get("DEEPSCIENTIST_ENABLE_RUNNERS"),
+            os.environ.get("DS_ENABLE_RUNNERS"),
+        ]
+        for raw_value in raw_values:
+            for item in str(raw_value or "").replace(";", ",").split(","):
+                normalized = cls._normalize_runtime_runner_name(item)
+                if normalized:
+                    names.add(normalized)
+        return names
+
     def _normalize_config_payload(self, payload: dict) -> dict:
         defaults = default_payload("config", self.home)
         normalized = self._deep_merge(defaults, payload)
+        default_runner_override = str(
+            os.environ.get("DEEPSCIENTIST_DEFAULT_RUNNER") or os.environ.get("DS_DEFAULT_RUNNER") or ""
+        ).strip().lower()
+        default_runner_override = self._normalize_runtime_runner_name(default_runner_override)
+        if default_runner_override:
+            normalized["default_runner"] = default_runner_override
         bootstrap = normalized.get("bootstrap") if isinstance(normalized.get("bootstrap"), dict) else {}
         raw_bootstrap = payload.get("bootstrap") if isinstance(payload.get("bootstrap"), dict) else {}
         connectors = normalized.get("connectors") if isinstance(normalized.get("connectors"), dict) else {}
@@ -1942,6 +2812,25 @@ Use **Test** when the file exposes runtime dependencies.
         bootstrap["locale_initialized_from_browser"] = locale_initialized_from_browser
         bootstrap["locale_initialized_at"] = bootstrap.get("locale_initialized_at")
         bootstrap["locale_initialized_browser_locale"] = bootstrap.get("locale_initialized_browser_locale")
+        runner_readiness = bootstrap.get("runner_readiness") if isinstance(bootstrap.get("runner_readiness"), dict) else {}
+        normalized_runner_readiness: dict[str, dict[str, Any]] = {}
+        for runner_name in list_builtin_runner_names():
+            state = runner_readiness.get(runner_name) if isinstance(runner_readiness.get(runner_name), dict) else {}
+            if runner_name == "codex" and not state:
+                state = {
+                    "ready": bool(bootstrap.get("codex_ready", False)),
+                    "last_checked_at": bootstrap.get("codex_last_checked_at"),
+                    "last_result": bootstrap.get("codex_last_result") if isinstance(bootstrap.get("codex_last_result"), dict) else {},
+                }
+            normalized_runner_readiness[runner_name] = {
+                "ready": bool(state.get("ready", False)),
+                "last_checked_at": state.get("last_checked_at"),
+                "last_result": state.get("last_result") if isinstance(state.get("last_result"), dict) else {},
+            }
+        bootstrap["runner_readiness"] = normalized_runner_readiness
+        bootstrap["codex_ready"] = bool(normalized_runner_readiness.get("codex", {}).get("ready", False))
+        bootstrap["codex_last_checked_at"] = normalized_runner_readiness.get("codex", {}).get("last_checked_at")
+        bootstrap["codex_last_result"] = normalized_runner_readiness.get("codex", {}).get("last_result") if isinstance(normalized_runner_readiness.get("codex", {}).get("last_result"), dict) else {}
         normalized["bootstrap"] = bootstrap
         raw_system_enabled = raw_connectors.get("system_enabled") if isinstance(raw_connectors.get("system_enabled"), dict) else {}
         default_system_enabled = (
@@ -1962,6 +2851,85 @@ Use **Test** when the file exposes runtime dependencies.
             for name in SYSTEM_CONNECTOR_NAMES
         }
         normalized["connectors"] = connectors
+        hardware = normalized.get("hardware") if isinstance(normalized.get("hardware"), dict) else {}
+        raw_hardware = payload.get("hardware") if isinstance(payload.get("hardware"), dict) else {}
+        gpu_selection_mode = str(raw_hardware.get("gpu_selection_mode") or hardware.get("gpu_selection_mode") or "all").strip().lower()
+        if gpu_selection_mode not in {"all", "selected"}:
+            gpu_selection_mode = "all"
+        raw_selected_gpu_ids = raw_hardware.get("selected_gpu_ids", hardware.get("selected_gpu_ids", []))
+        selected_gpu_ids: list[str] = []
+        if isinstance(raw_selected_gpu_ids, list):
+            for item in raw_selected_gpu_ids:
+                normalized_id = str(item or "").strip()
+                if normalized_id and normalized_id not in selected_gpu_ids:
+                    selected_gpu_ids.append(normalized_id)
+        elif isinstance(raw_selected_gpu_ids, str):
+            for item in raw_selected_gpu_ids.split(","):
+                normalized_id = item.strip()
+                if normalized_id and normalized_id not in selected_gpu_ids:
+                    selected_gpu_ids.append(normalized_id)
+        hardware["gpu_selection_mode"] = gpu_selection_mode
+        hardware["selected_gpu_ids"] = selected_gpu_ids
+        hardware["include_system_hardware_in_prompt"] = self._coerce_bool(
+            raw_hardware.get(
+                "include_system_hardware_in_prompt",
+                hardware.get("include_system_hardware_in_prompt", True),
+            ),
+            default=True,
+        )
+        normalized["hardware"] = hardware
+        memory = normalized.get("memory") if isinstance(normalized.get("memory"), dict) else {}
+        raw_memory = payload.get("memory") if isinstance(payload.get("memory"), dict) else {}
+        read_visibility_mode = str(
+            raw_memory.get("read_visibility_mode", memory.get("read_visibility_mode", "independent")) or "independent"
+        ).strip().lower()
+        if read_visibility_mode not in {"independent", "shared_across_quests"}:
+            read_visibility_mode = "independent"
+        memory["read_visibility_mode"] = read_visibility_mode
+        normalized["memory"] = memory
+        literature = normalized.get("literature") if isinstance(normalized.get("literature"), dict) else {}
+        raw_literature = payload.get("literature") if isinstance(payload.get("literature"), dict) else {}
+        default_literature = defaults.get("literature") if isinstance(defaults.get("literature"), dict) else {}
+        deepxiv_defaults = default_literature.get("deepxiv") if isinstance(default_literature.get("deepxiv"), dict) else {}
+        deepxiv = literature.get("deepxiv") if isinstance(literature.get("deepxiv"), dict) else {}
+        raw_deepxiv = raw_literature.get("deepxiv") if isinstance(raw_literature.get("deepxiv"), dict) else {}
+        deepxiv["enabled"] = self._coerce_bool(
+            raw_deepxiv.get("enabled", deepxiv.get("enabled", deepxiv_defaults.get("enabled", False))),
+            default=bool(deepxiv_defaults.get("enabled", False)),
+        )
+        deepxiv["base_url"] = str(
+            raw_deepxiv.get("base_url", deepxiv.get("base_url", deepxiv_defaults.get("base_url", "https://data.rag.ac.cn"))) or ""
+        ).strip() or str(deepxiv_defaults.get("base_url") or "https://data.rag.ac.cn")
+        deepxiv["token"] = str(raw_deepxiv.get("token", deepxiv.get("token", "")) or "").strip() or None
+        deepxiv["token_env"] = str(
+            raw_deepxiv.get("token_env", deepxiv.get("token_env", deepxiv_defaults.get("token_env", "DEEPXIV_TOKEN"))) or ""
+        ).strip() or None
+        try:
+            raw_result_size = raw_deepxiv.get(
+                "default_result_size",
+                deepxiv.get("default_result_size", deepxiv_defaults.get("default_result_size", 10)),
+            )
+            deepxiv["default_result_size"] = max(1, int(raw_result_size))
+        except (TypeError, ValueError):
+            deepxiv["default_result_size"] = int(deepxiv_defaults.get("default_result_size", 10) or 10)
+        try:
+            raw_preview_characters = raw_deepxiv.get(
+                "preview_characters",
+                deepxiv.get("preview_characters", deepxiv_defaults.get("preview_characters", 1200)),
+            )
+            deepxiv["preview_characters"] = max(200, int(raw_preview_characters))
+        except (TypeError, ValueError):
+            deepxiv["preview_characters"] = int(deepxiv_defaults.get("preview_characters", 1200) or 1200)
+        try:
+            raw_timeout = raw_deepxiv.get(
+                "request_timeout_seconds",
+                deepxiv.get("request_timeout_seconds", deepxiv_defaults.get("request_timeout_seconds", 20)),
+            )
+            deepxiv["request_timeout_seconds"] = max(3, int(raw_timeout))
+        except (TypeError, ValueError):
+            deepxiv["request_timeout_seconds"] = int(deepxiv_defaults.get("request_timeout_seconds", 20) or 20)
+        literature["deepxiv"] = deepxiv
+        normalized["literature"] = literature
         return normalized
 
     @staticmethod
@@ -1974,6 +2942,22 @@ Use **Test** when the file exposes runtime dependencies.
             return False
         return abs(initial - 1.0) < 1e-9 and abs(multiplier - 2.0) < 1e-9 and abs(max_backoff - 8.0) < 1e-9
 
+    @staticmethod
+    def _looks_like_preupgrade_codex_retry_attempt_profile(payload: dict) -> bool:
+        try:
+            max_attempts = int(payload.get("retry_max_attempts"))
+            initial = float(payload.get("retry_initial_backoff_sec"))
+            multiplier = float(payload.get("retry_backoff_multiplier"))
+            max_backoff = float(payload.get("retry_max_backoff_sec"))
+        except (TypeError, ValueError):
+            return False
+        return (
+            max_attempts == 5
+            and abs(initial - 10.0) < 1e-9
+            and abs(multiplier - 6.0) < 1e-9
+            and abs(max_backoff - 1800.0) < 1e-9
+        )
+
     @staticmethod
     def _coerce_bool(value: object, *, default: bool = False) -> bool:
         if value is None: