@researai/deepscientist 1.5.17 → 1.6.0

package/src/deepscientist/diagnostics/runner_failures.py

@@ -26,6 +26,46 @@ _MODEL_UNAVAILABLE_MARKERS = (
     "unrecognized model",
 )
 
+_CODEX_PROVIDER_ACCOUNT_ERROR_MARKERS = (
+    "account balance is negative",
+    "please recharge",
+    "insufficient quota",
+    "quota exceeded",
+    "billing hard limit",
+    "billing limit",
+    "payment required",
+    "invalid api key",
+    "invalid_api_key",
+    "incorrect api key",
+    "api key is invalid",
+    "unauthorized",
+)
+
+_CODEX_PROVIDER_ACCOUNT_STATUS_MARKERS = (
+    "401 unauthorized",
+    "402 payment required",
+    "403 forbidden",
+)
+
+_CODEX_UPSTREAM_ERROR_MARKERS = (
+    "rate limit",
+    "too many requests",
+    "service unavailable",
+    "bad gateway",
+    "gateway timeout",
+    "internal server error",
+    "temporarily unavailable",
+    "server overloaded",
+)
+
+_CODEX_UPSTREAM_STATUS_MARKERS = (
+    "429 too many requests",
+    "500 internal server error",
+    "502 bad gateway",
+    "503 service unavailable",
+    "504 gateway timeout",
+)
+
 
 def _build_haystack(*values: object) -> str:
     return "\n".join(str(value or "") for value in values if str(value or "").strip())
@@ -46,6 +86,52 @@ def diagnose_runner_failure(
     lower = haystack.lower()
     normalized_runner = str(runner_name or "").strip().lower()
 
+    if normalized_runner == "codex" and (
+        any(marker in lower for marker in _CODEX_PROVIDER_ACCOUNT_ERROR_MARKERS)
+        or (
+            ("unexpected status" in lower or "http_code" in lower or "status" in lower)
+            and any(marker in lower for marker in _CODEX_PROVIDER_ACCOUNT_STATUS_MARKERS)
+        )
+    ):
+        return FailureDiagnosis(
+            code="codex_provider_account_error",
+            problem="The configured Codex provider account cannot serve the request.",
+            why=(
+                "The provider reported an account, billing, quota, or credential blocker. "
+                "Repeating the same quest turn will keep failing until the provider account state is corrected."
+            ),
+            guidance=(
+                "Check the configured provider account, quota, billing status, credentials, and API-key scope.",
+                "Verify the same Codex profile works outside DeepScientist before resuming the quest.",
+                "Do not relaunch the same quest repeatedly until the provider account state is healthy.",
+            ),
+            retriable=False,
+            matched_text="codex provider account error",
+        )
+
+    if normalized_runner == "codex" and (
+        any(marker in lower for marker in _CODEX_UPSTREAM_ERROR_MARKERS)
+        or (
+            ("unexpected status" in lower or "http_code" in lower or "status" in lower)
+            and any(marker in lower for marker in _CODEX_UPSTREAM_STATUS_MARKERS)
+        )
+    ):
+        return FailureDiagnosis(
+            code="codex_upstream_provider_error",
+            problem="The configured Codex upstream provider rejected or could not serve the request.",
+            why=(
+                "This is an external provider/API service condition. DeepScientist can retry with backoff, "
+                "but it cannot repair upstream provider availability from inside the quest runtime."
+            ),
+            guidance=(
+                "Check the configured provider service health, rate limits, and API status.",
+                "Verify the same Codex profile works outside DeepScientist before resuming the quest.",
+                "Do not repeatedly relaunch the same quest if the provider continues returning the same upstream error.",
+            ),
+            retriable=True,
+            matched_text="codex upstream provider error",
+        )
+
     if (
         "tool call result does not follow tool call (2013)" in lower
         or "tool result's tool id" in lower
@@ -88,6 +174,41 @@ def diagnose_runner_failure(
             matched_text="tool-call arguments",
         )
 
+    if "argument list too long" in lower or "[errno 7]" in lower:
+        return FailureDiagnosis(
+            code="runner_argument_list_too_long",
+            problem="The runner command exceeded the OS argument-length limit.",
+            why=(
+                "This usually happens when a runner needs to receive a very large prompt through argv "
+                "instead of stdin or a file-backed prompt path."
+            ),
+            guidance=(
+                "Retry with a shorter fallback prompt that references the quest brief and saved prompt files.",
+                "Prefer stdin-capable runners such as Codex or Claude for very large turn prompts.",
+                "If the problem persists, inspect `.ds/runs/<run_id>/prompt.md` and reduce duplicated context.",
+            ),
+            retriable=False,
+            matched_text="argument list too long",
+        )
+
+    if "codec can't encode character" in lower and ("gbk" in lower or "cp936" in lower):
+        return FailureDiagnosis(
+            code="windows_gbk_prompt_encoding_error",
+            problem="A Windows GBK code-page path rejected a Unicode character in the runner payload.",
+            why=(
+                "A non-UTF-8 Windows encoding path tried to encode the runner prompt or related text with "
+                "GBK/CP936 and hit a character that code page cannot represent, such as bullets, emoji, "
+                "or kaomoji symbols."
+            ),
+            guidance=(
+                "Update to a DeepScientist build that sanitizes non-GBK prompt characters before Codex on Windows.",
+                "If you are already on the latest build, remove emoji or decorative symbols such as `•` from custom prompts, notes, or connector-facing text.",
+                "Prefer a UTF-8 terminal (`chcp 65001`) or the WSL2 deployment path when possible.",
+            ),
+            retriable=False,
+            matched_text="gbk codec can't encode character",
+        )
+
     if "missing environment variable" in lower:
         return FailureDiagnosis(
             code="provider_env_missing",
@@ -127,4 +248,30 @@ def diagnose_runner_failure(
             matched_text="invalid params",
         )
 
+    if normalized_runner == "codex" and (
+        "unknown file extension" in lower
+        or ("file extension" in lower and ".png" in lower)
+        or ("file extension" in lower and ".jpg" in lower)
+        or ("file extension" in lower and ".jpeg" in lower)
+        or ("file extension" in lower and ".gif" in lower)
+        or ("file extension" in lower and ".webp" in lower)
+        or ("file extension" in lower and ".bmp" in lower)
+        or ("file extension" in lower and ".mp4" in lower)
+    ):
+        return FailureDiagnosis(
+            code="runner_binary_attachment_path_unsupported",
+            problem="Codex rejected a binary attachment path from the prompt.",
+            why=(
+                "The request exposed an image, video, or other binary file path that the Codex CLI tried to treat "
+                "as an inline readable input, but that extension is not supported on stdin-driven prompt parsing."
+            ),
+            guidance=(
+                "Prefer OCR text, extracted text, or archive manifests over raw binary attachment paths in the runner prompt.",
+                "If a milestone needs binary delivery, keep the binary path inside the tool call payload instead of embedding it directly in prompt guidance.",
+                "Do not keep retrying the same turn until the prompt or attachment summary no longer exposes the unsupported binary path.",
+            ),
+            retriable=False,
+            matched_text="unknown file extension",
+        )
+
     return None

package/src/deepscientist/doctor.py

@@ -2,13 +2,14 @@ from __future__ import annotations
 
 from datetime import UTC, datetime, timedelta
 import os
+import shlex
 import socket
 import subprocess
 import sys
 import tempfile
 from shutil import which
 from pathlib import Path
-from typing import Any
+from typing import Any, Callable
 from urllib.error import URLError
 from urllib.request import Request, urlopen
 
@@ -16,8 +17,9 @@ from .bash_exec.shells import build_exec_shell_launch, build_terminal_shell_laun
 from .config import ConfigManager
 from .diagnostics import diagnose_runner_failure
 from .home import ensure_home_layout
+from .runners.metadata import list_builtin_runner_names
 from .runtime_tools import RuntimeToolService
-from .shared import read_json, read_jsonl_tail, resolve_runner_binary, utc_now
+from .shared import read_json, read_jsonl_tail, resolve_runner_binary, utc_now, utf8_text_subprocess_kwargs
 
 
 _RUNTIME_FAILURE_LOOKBACK = timedelta(hours=24)
@@ -71,6 +73,40 @@ def _make_check(
     }
 
 
+def _probe_detail_subset(details: dict[str, Any], *, resolved_binary: str) -> dict[str, Any]:
+    keys = (
+        "profile",
+        "model",
+        "requested_model",
+        "effective_model",
+        "approval_policy",
+        "sandbox_mode",
+        "reasoning_effort",
+        "requested_reasoning_effort",
+        "codex_cli_version",
+        "provider_env_key",
+        "provider_env_missing",
+        "provider_wire_api",
+        "model_fallback_attempted",
+        "model_fallback_used",
+        "exit_code",
+        "stdout_excerpt",
+        "stderr_excerpt",
+        "probe_command",
+        "initial_exit_code",
+        "initial_stdout_excerpt",
+        "initial_stderr_excerpt",
+        "fallback_exit_code",
+        "fallback_stdout_excerpt",
+        "fallback_stderr_excerpt",
+    )
+    rendered: dict[str, Any] = {"resolved_binary": resolved_binary}
+    for key in keys:
+        if key in details:
+            rendered[key] = details.get(key)
+    return rendered
+
+
 def _check_python_runtime() -> dict[str, Any]:
     try:
         import _cffi_backend  # noqa: F401
@@ -172,7 +208,7 @@ def _check_uv(home: Path) -> dict[str, Any]:
             [resolved, "--version"],
             check=False,
             capture_output=True,
-            text=True,
+            **utf8_text_subprocess_kwargs(),
         )
         if result.returncode == 0:
             version = (result.stdout or result.stderr or "").strip()
@@ -230,100 +266,113 @@ def _check_config_validation(config_manager: ConfigManager) -> dict[str, Any]:
 
 def _check_runner_support(config_manager: ConfigManager) -> dict[str, Any]:
     config_payload = config_manager.load_named_normalized("config")
-    runners_payload = config_manager.load_named_normalized("runners")
+    runners_payload = config_manager.load_runners_config()
 
     default_runner = str(config_payload.get("default_runner") or "codex").strip().lower() or "codex"
-    codex_cfg = runners_payload.get("codex") if isinstance(runners_payload.get("codex"), dict) else {}
-    claude_cfg = runners_payload.get("claude") if isinstance(runners_payload.get("claude"), dict) else {}
+    enabled_runners = sorted(
+        name for name, value in runners_payload.items() if isinstance(value, dict) and bool(value.get("enabled", False))
+    )
 
     errors: list[str] = []
     warnings: list[str] = []
     guidance: list[str] = []
 
-    if default_runner != "codex":
-        errors.append("Current open-source release supports `codex` as the runnable default runner.")
-        guidance.append("Set `default_runner: codex` in `~/DeepScientist/config/config.yaml`.")
-    if not bool(codex_cfg.get("enabled", False)):
-        errors.append("`runners.codex.enabled` must stay `true` in the current release.")
-        guidance.append("Set `runners.codex.enabled: true` in `~/DeepScientist/config/runners.yaml`.")
-    if bool(claude_cfg.get("enabled", False)):
-        errors.append("`claude` is still TODO in the current release and should stay disabled.")
-        guidance.append("Set `runners.claude.enabled: false` in `~/DeepScientist/config/runners.yaml`.")
-    else:
-        warnings.append("`claude` remains a TODO/reserved runner slot and is not runnable yet.")
+    if not enabled_runners:
+        errors.append("At least one runner must be enabled.")
+        guidance.append("Enable one of `codex`, `claude`, `kimi`, or `opencode` in `~/DeepScientist/config/runners.yaml`.")
+    if default_runner not in runners_payload:
+        errors.append(f"Configured default runner `{default_runner}` does not exist in `runners.yaml`.")
+    elif default_runner not in enabled_runners:
+        errors.append(f"Configured default runner `{default_runner}` is currently disabled.")
+        guidance.append(
+            f"Set `runners.{default_runner}.enabled: true`, or switch `default_runner` to one of: {', '.join(enabled_runners) or 'none'}."
+        )
+    if len(enabled_runners) > 1:
+        warnings.append(f"Multiple runners are enabled: {', '.join(enabled_runners)}.")
 
     return _make_check(
         check_id="runner_support",
         label="Supported runners",
         ok=len(errors) == 0,
-        summary="Runner policy matches the current release surface." if len(errors) == 0 else "Runner policy needs adjustment.",
+        summary="Runner policy is internally consistent." if len(errors) == 0 else "Runner policy needs adjustment.",
         warnings=warnings,
         errors=errors,
         guidance=guidance,
-        details={"default_runner": default_runner},
+        details={"default_runner": default_runner, "enabled_runners": enabled_runners},
     )
 
 
-def _check_codex(config_manager: ConfigManager) -> dict[str, Any]:
-    runners_payload = config_manager.load_named_normalized("runners")
-    codex_cfg = runners_payload.get("codex") if isinstance(runners_payload.get("codex"), dict) else {}
-    binary = str(codex_cfg.get("binary") or "codex").strip() or "codex"
-    resolved_binary = resolve_runner_binary(binary, runner_name="codex")
+def _check_runner(config_manager: ConfigManager, runner_name: str) -> dict[str, Any]:
+    normalized_runner = str(runner_name or "codex").strip().lower() or "codex"
+    runners_payload = config_manager.load_runners_config()
+    runner_cfg = runners_payload.get(normalized_runner) if isinstance(runners_payload.get(normalized_runner), dict) else {}
+    binary = str(runner_cfg.get("binary") or normalized_runner).strip() or normalized_runner
+    resolved_binary = resolve_runner_binary(binary, runner_name=normalized_runner)
+    label = {
+        "codex": "Codex CLI",
+        "claude": "Claude Code CLI",
+        "kimi": "Kimi Code CLI",
+        "opencode": "OpenCode CLI",
+    }.get(normalized_runner, normalized_runner)
 
     if not resolved_binary:
+        guidance = config_manager._runner_missing_binary_guidance(normalized_runner, runner_cfg)
         return _make_check(
-            check_id="codex",
-            label="Codex CLI",
+            check_id=normalized_runner,
+            label=label,
             ok=False,
-            summary="Codex CLI is not available to DeepScientist.",
+            summary=f"{label} is not available to DeepScientist.",
             errors=[f"Runner binary `{binary}` could not be resolved."],
-            guidance=config_manager._codex_missing_binary_guidance(codex_cfg),
+            guidance=guidance,
             details={"binary": binary},
         )
 
-    probe = config_manager.probe_codex_bootstrap(persist=False, payload=runners_payload)
+    probe = (
+        config_manager.probe_codex_bootstrap(persist=False, payload=runners_payload)
+        if normalized_runner == "codex"
+        else config_manager.probe_runner_bootstrap(normalized_runner, persist=False, payload=runners_payload)
+    )
     probe_errors = [str(value) for value in probe.get("errors") or []]
     probe_warnings = [str(value) for value in probe.get("warnings") or []]
     probe_guidance = [str(value) for value in probe.get("guidance") or []]
-    summary = str(probe.get("summary") or "Codex startup probe completed.")
+    summary = str(probe.get("summary") or f"{label} startup probe completed.")
     probe_details = probe.get("details") if isinstance(probe.get("details"), dict) else {}
-    diagnosis = diagnose_runner_failure(
-        runner_name="codex",
-        summary="\n".join([summary, *probe_errors]),
-        stderr_text=str(probe_details.get("stderr_excerpt") or ""),
-        output_text=str(probe_details.get("stdout_excerpt") or ""),
-    )
+    diagnosis = None
+    if normalized_runner == "codex":
+        diagnosis = diagnose_runner_failure(
+            runner_name="codex",
+            summary="\n".join([summary, *probe_errors]),
+            stderr_text=str(probe_details.get("stderr_excerpt") or ""),
+            output_text=str(probe_details.get("stdout_excerpt") or ""),
+        )
     if probe.get("ok"):
         return _make_check(
-            check_id="codex",
-            label="Codex CLI",
+            check_id=normalized_runner,
+            label=label,
             ok=True,
             summary=summary,
             warnings=probe_warnings,
             details={"resolved_binary": resolved_binary},
         )
-    if not probe_guidance:
-        probe_guidance = [
-            "Run `codex login` (or just `codex`) manually once and complete login, then retry `ds doctor`.",
-        ]
     return _make_check(
-        check_id="codex",
-        label="Codex CLI",
+        check_id=normalized_runner,
+        label=label,
         ok=False,
         summary=diagnosis.problem if diagnosis is not None else summary,
         warnings=probe_warnings,
-        errors=probe_errors or ["Codex startup probe did not succeed."],
+        errors=probe_errors or [f"{label} startup probe did not succeed."],
         guidance=probe_guidance,
-        details={"resolved_binary": resolved_binary},
+        details=_probe_detail_subset(probe_details, resolved_binary=resolved_binary),
         problem=diagnosis.problem if diagnosis is not None else None,
         why=diagnosis.why if diagnosis is not None else None,
         fix=list(diagnosis.guidance) if diagnosis is not None else None,
-        evidence=(
-            [f"matched: {diagnosis.matched_text}"] if diagnosis is not None and diagnosis.matched_text else None
-        ),
+        evidence=([f"matched: {diagnosis.matched_text}"] if diagnosis is not None and diagnosis.matched_text else None),
     )
 
 
+def _check_codex(config_manager: ConfigManager) -> dict[str, Any]:
+    return _check_runner(config_manager, "codex")
+
 def _parse_timestamp(value: object) -> datetime | None:
     normalized = str(value or "").strip()
     if not normalized:
@@ -635,9 +684,11 @@ def _check_ui_port(home: Path, config_manager: ConfigManager) -> dict[str, Any]:
             summary="The configured port is already used by another DeepScientist home.",
             errors=[f"{browser_url} is already serving a daemon for `{daemon_home}`."],
             guidance=[
-                "Stop the other daemon first or change `ui.port` in `~/DeepScientist/config/config.yaml`.",
+                f"If you intended to use that running instance, run `ds --home {daemon_home} doctor` and open {browser_url}.",
+                f"If it is stale, stop it with `ds --home {daemon_home} --stop`.",
+                "Otherwise change `ui.port` in this home config or start this home with a different port, for example `ds --port 21000`.",
             ],
-            details={"browser_url": browser_url, "host": host, "port": port},
+            details={"browser_url": browser_url, "host": host, "port": port, "daemon_home": daemon_home},
         )
 
     bindable, bind_error = _port_is_bindable(host, port)
@@ -663,7 +714,16 @@ def _check_ui_port(home: Path, config_manager: ConfigManager) -> dict[str, Any]:
     )
 
 
-def run_doctor(home: Path, *, repo_root: Path) -> dict[str, Any]:
+DoctorProgressCallback = Callable[[dict[str, Any]], None]
+
+
+def run_doctor(
+    home: Path,
+    *,
+    repo_root: Path,
+    runner_names: list[str] | None = None,
+    on_check: DoctorProgressCallback | None = None,
+) -> dict[str, Any]:
     ensure_home_layout(home)
     config_manager = ConfigManager(home)
     config_manager.ensure_files()
@@ -673,20 +733,51 @@ def run_doctor(home: Path, *, repo_root: Path) -> dict[str, Any]:
     port = int(ui_payload.get("port") or 20999)
     browser_url = _browser_ui_url(host, port)
 
-    checks = [
-        _check_python_runtime(),
-        _check_home_writable(home),
-        _check_uv(home),
-        _check_shell_backend(),
-        _check_git(config_manager),
-        _check_config_validation(config_manager),
-        _check_runner_support(config_manager),
-        _check_codex(config_manager),
-        _check_recent_runtime_failures(home),
-        _check_latex_runtime(home),
-        _check_bundles(repo_root),
-        _check_ui_port(home, config_manager),
+    check_factories: list[tuple[str, Callable[[], dict[str, Any]]]] = [
+        ("python_runtime", _check_python_runtime),
+        ("home_writable", lambda: _check_home_writable(home)),
+        ("uv", lambda: _check_uv(home)),
+        ("shell_backend", _check_shell_backend),
+        ("git", lambda: _check_git(config_manager)),
+        ("config_validation", lambda: _check_config_validation(config_manager)),
+        ("runner_support", lambda: _check_runner_support(config_manager)),
     ]
+    runners_payload = config_manager.load_runners_config()
+    default_runner = str(config_payload.get("default_runner") or "codex").strip().lower() or "codex"
+    runner_targets: list[str] = []
+    explicit_runner_names = _normalize_doctor_runner_targets(runner_names)
+    if explicit_runner_names:
+        candidate_runner_names = explicit_runner_names
+    else:
+        candidate_runner_names = [
+            default_runner,
+            *sorted(name for name, value in runners_payload.items() if isinstance(value, dict) and bool(value.get("enabled", False))),
+        ]
+    for candidate in candidate_runner_names:
+        normalized_candidate = str(candidate or "").strip().lower()
+        if normalized_candidate and normalized_candidate not in runner_targets:
+            runner_targets.append(normalized_candidate)
+    check_factories.extend((runner_name, (lambda runner_name=runner_name: _check_runner(config_manager, runner_name))) for runner_name in runner_targets)
+    check_factories.extend([
+        ("recent_runtime_failures", lambda: _check_recent_runtime_failures(home)),
+        ("latex_runtime", lambda: _check_latex_runtime(home)),
+        ("bundles", lambda: _check_bundles(repo_root)),
+        ("ui_port", lambda: _check_ui_port(home, config_manager)),
+    ])
+    checks: list[dict[str, Any]] = []
+    total_checks = len(check_factories)
+    for index, (check_id, factory) in enumerate(check_factories, start=1):
+        check = factory()
+        checks.append(check)
+        if on_check is not None:
+            on_check(
+                {
+                    "check_id": check_id,
+                    "index": index,
+                    "total": total_checks,
+                    "check": check,
+                }
+            )
 
     return {
         "ok": all(item["ok"] for item in checks),
@@ -697,6 +788,31 @@ def run_doctor(home: Path, *, repo_root: Path) -> dict[str, Any]:
     }
 
 
+def _normalize_doctor_runner_targets(runner_names: list[str] | None) -> list[str]:
+    targets: list[str] = []
+    seen: set[str] = set()
+    for raw_value in runner_names or []:
+        for item in str(raw_value or "").replace(";", ",").split(","):
+            normalized = item.strip().lower().replace("_", "-")
+            if normalized in {"all", "*"}:
+                candidates = list(list_builtin_runner_names())
+            else:
+                if normalized in {"claude-code", "claudecode"}:
+                    normalized = "claude"
+                elif normalized in {"kimi-code", "kimicode"}:
+                    normalized = "kimi"
+                elif normalized in {"open-code", "open code", "opencode-ai", "opencodeai"}:
+                    normalized = "opencode"
+                else:
+                    normalized = normalized.replace("-", "")
+                candidates = [normalized] if normalized else []
+            for candidate in candidates:
+                if candidate and candidate not in seen:
+                    seen.add(candidate)
+                    targets.append(candidate)
+    return targets
+
+
 def render_doctor_report(report: dict[str, Any]) -> str:
     lines = [
         "DeepScientist doctor",
@@ -732,6 +848,34 @@ def render_doctor_report(report: dict[str, Any]) -> str:
             resolved_binary = str(details.get("resolved_binary") or "").strip()
             if resolved_binary:
                 lines.append(f"  resolved binary: {resolved_binary}")
+            exit_code = details.get("exit_code")
+            if exit_code is not None:
+                lines.append(f"  exit code: {exit_code}")
+            codex_cli_version = str(details.get("codex_cli_version") or "").strip()
+            if codex_cli_version:
+                lines.append(f"  codex cli version: {codex_cli_version}")
+            profile = str(details.get("profile") or "").strip()
+            if profile:
+                lines.append(f"  profile: {profile}")
+            effective_model = str(details.get("effective_model") or details.get("model") or "").strip()
+            if effective_model:
+                lines.append(f"  effective model: {effective_model}")
+            provider_wire_api = str(details.get("provider_wire_api") or "").strip()
+            if provider_wire_api:
+                lines.append(f"  provider wire api: {provider_wire_api}")
+            if details.get("provider_env_missing"):
+                provider_env_key = str(details.get("provider_env_key") or "").strip()
+                if provider_env_key:
+                    lines.append(f"  missing provider env: {provider_env_key}")
+            probe_command = details.get("probe_command")
+            if isinstance(probe_command, list) and probe_command:
+                lines.append(f"  probe command: {shlex.join(str(part) for part in probe_command)}")
+            stdout_excerpt = str(details.get("stdout_excerpt") or "").strip()
+            if stdout_excerpt:
+                lines.append(f"  stdout excerpt: {stdout_excerpt}")
+            stderr_excerpt = str(details.get("stderr_excerpt") or "").strip()
+            if stderr_excerpt:
+                lines.append(f"  stderr excerpt: {stderr_excerpt}")
             latex_pdflatex_path = str(details.get("latex_pdflatex_path") or "").strip()
             if latex_pdflatex_path:
                 lines.append(f"  pdflatex: {latex_pdflatex_path}")
@@ -741,6 +885,9 @@ def render_doctor_report(report: dict[str, Any]) -> str:
             browser_url = str(details.get("browser_url") or "").strip()
             if browser_url:
                 lines.append(f"  url: {browser_url}")
+            daemon_home = str(details.get("daemon_home") or "").strip()
+            if daemon_home:
+                lines.append(f"  daemon home: {daemon_home}")
         lines.append("")
 
     guidance: list[str] = []