@researai/deepscientist 1.5.16 → 1.6.0

package/src/deepscientist/doctor.py

@@ -1,21 +1,28 @@
 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
 
 from .bash_exec.shells import build_exec_shell_launch, build_terminal_shell_launch
 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 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)
 
 
 def _browser_ui_url(host: str, port: int) -> str:
@@ -42,6 +49,10 @@ def _make_check(
     errors: list[str] | None = None,
     guidance: list[str] | None = None,
     details: dict[str, Any] | None = None,
+    problem: str | None = None,
+    why: str | None = None,
+    fix: list[str] | None = None,
+    evidence: list[str] | None = None,
 ) -> dict[str, Any]:
     normalized_warnings = list(warnings or [])
     normalized_errors = list(errors or [])
@@ -55,9 +66,47 @@ def _make_check(
         "errors": normalized_errors,
         "guidance": list(guidance or []),
         "details": dict(details or {}),
+        "problem": str(problem or "").strip() or None,
+        "why": str(why or "").strip() or None,
+        "fix": [str(line) for line in (fix or []) if str(line).strip()],
+        "evidence": [str(line) for line in (evidence or []) if str(line).strip()],
     }
 
 
+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
@@ -159,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()
@@ -217,84 +266,275 @@ 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 = 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 `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=summary,
+        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),
+    )
+
+
+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:
+        return None
+    candidate = normalized.replace("Z", "+00:00")
+    try:
+        parsed = datetime.fromisoformat(candidate)
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=UTC)
+    return parsed.astimezone(UTC)
+
+
+def _read_runtime_failure_record(home: Path) -> dict[str, Any] | None:
+    quests_root = home / "quests"
+    if not quests_root.exists():
+        return None
+
+    latest: dict[str, Any] | None = None
+    latest_at: datetime | None = None
+    cutoff = datetime.now(UTC) - _RUNTIME_FAILURE_LOOKBACK
+    interesting_types = {
+        "runner.turn_error",
+        "runner.turn_retry_exhausted",
+        "quest.runtime_auto_resume_suppressed",
+    }
+
+    for quest_root in sorted(quests_root.glob("*/")):
+        events = read_jsonl_tail(quest_root / ".ds" / "events.jsonl", 300)
+        for event in reversed(events):
+            event_type = str(event.get("type") or "").strip()
+            if event_type not in interesting_types:
+                continue
+            created_at = _parse_timestamp(event.get("created_at"))
+            if created_at is None or created_at < cutoff:
+                continue
+            run_id = str(event.get("run_id") or "").strip() or None
+            stderr_text = ""
+            output_text = ""
+            if run_id:
+                run_root = quest_root / ".ds" / "runs" / run_id
+                result_payload = read_json(run_root / "result.json", {})
+                if isinstance(result_payload, dict):
+                    stderr_text = str(result_payload.get("stderr_text") or "").strip()
+                    output_text = str(result_payload.get("output_text") or "").strip()
+                stderr_path = run_root / "stderr.txt"
+                if not stderr_text and stderr_path.exists():
+                    try:
+                        stderr_text = stderr_path.read_text(encoding="utf-8")
+                    except OSError:
+                        stderr_text = ""
+            candidate = {
+                "quest_id": quest_root.name,
+                "run_id": run_id,
+                "event_type": event_type,
+                "summary": str(event.get("summary") or "").strip(),
+                "created_at": created_at.isoformat(),
+                "stderr_text": stderr_text,
+                "output_text": output_text,
+                "recent_attempts": event.get("recent_attempts"),
+            }
+            if latest_at is None or created_at > latest_at:
+                latest = candidate
+                latest_at = created_at
+            break
+    return latest
+
+
+def _check_recent_runtime_failures(home: Path) -> dict[str, Any]:
+    record = _read_runtime_failure_record(home)
+    if record is None:
+        return _make_check(
+            check_id="recent_runtime_failures",
+            label="Recent runtime failures",
+            ok=True,
+            summary="No recent quest runtime failures were found.",
+        )
+
+    event_type = str(record.get("event_type") or "").strip()
+    quest_id = str(record.get("quest_id") or "").strip() or None
+    run_id = str(record.get("run_id") or "").strip() or None
+    summary = str(record.get("summary") or "").strip()
+    details = {
+        "quest_id": quest_id,
+        "run_id": run_id,
+        "event_type": event_type,
+        "observed_at": record.get("created_at"),
+    }
+
+    if event_type == "quest.runtime_auto_resume_suppressed":
+        recent_attempts = int(record.get("recent_attempts") or 0)
+        return _make_check(
+            check_id="recent_runtime_failures",
+            label="Recent runtime failures",
+            ok=True,
+            summary="DeepScientist recently suppressed auto-resume to avoid a crash loop.",
+            warnings=["Automatic continuation was paused after repeated recovery attempts in a short window."],
+            guidance=[
+                "Inspect the most recent failing runner path before using `/resume` again.",
+                "If the failure was a provider-side 400/protocol error, fix that request path first instead of retrying immediately.",
+            ],
+            details=details,
+            problem="Automatic crash recovery was suppressed.",
+            why="The same quest hit repeated recovery attempts in a short window, so DeepScientist parked it instead of looping forever.",
+            fix=[
+                "Open the latest failing quest logs and identify the deterministic runner/provider error.",
+                "Resume manually only after the underlying runner or provider issue is corrected.",
+            ],
+            evidence=[
+                *( [f"quest: {quest_id}"] if quest_id else [] ),
+                f"recent recovery attempts: {recent_attempts}",
+            ],
+        )
+
+    diagnosis = diagnose_runner_failure(
+        runner_name="codex",
+        summary=summary,
+        stderr_text=str(record.get("stderr_text") or ""),
+        output_text=str(record.get("output_text") or ""),
+    )
+    if diagnosis is None:
+        return _make_check(
+            check_id="recent_runtime_failures",
+            label="Recent runtime failures",
+            ok=True,
+            summary="A recent quest runtime failure was found.",
+            warnings=[summary or "The latest quest run failed, but doctor could not classify it precisely yet."],
+            guidance=[
+                "Open the latest run stderr and events journal for the failing quest.",
+                "If the same failure repeats, capture the run_id and provider response text before retrying again.",
+            ],
+            details=details,
+            problem="A recent quest run failed.",
+            why="Doctor found a recent runtime failure event but could not match it to a known deterministic error pattern.",
+            fix=[
+                "Inspect the failing run's stderr and provider response text.",
+                "If the error is deterministic, avoid burning the retry budget until the request shape or config is fixed.",
+            ],
+            evidence=[
+                *( [f"quest: {quest_id}"] if quest_id else [] ),
+                *( [f"run: {run_id}"] if run_id else [] ),
+                *( [f"summary: {summary}"] if summary else [] ),
+            ],
+        )
+
+    return _make_check(
+        check_id="recent_runtime_failures",
+        label="Recent runtime failures",
+        ok=True,
+        summary=diagnosis.problem,
+        warnings=[summary] if summary and summary != diagnosis.problem else [],
+        guidance=list(diagnosis.guidance),
+        details=details,
+        problem=diagnosis.problem,
+        why=diagnosis.why,
+        fix=list(diagnosis.guidance),
+        evidence=[
+            *( [f"quest: {quest_id}"] if quest_id else [] ),
+            *( [f"run: {run_id}"] if run_id else [] ),
+            *( [f"matched: {diagnosis.matched_text}"] if diagnosis.matched_text else [] ),
+        ],
     )
 
 
@@ -444,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)
@@ -472,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()
@@ -482,19 +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_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),
@@ -505,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",
@@ -519,6 +827,18 @@ def render_doctor_report(report: dict[str, Any]) -> str:
         status = str(item.get("status") or "ok").upper()
         icon = {"OK": "[ok]", "WARN": "[warn]", "ERROR": "[fail]"}.get(status, "[info]")
         lines.append(f"{icon} {item.get('label')}: {item.get('summary')}")
+        problem = str(item.get("problem") or "").strip()
+        why = str(item.get("why") or "").strip()
+        fix_lines = [str(line) for line in item.get("fix") or [] if str(line).strip()]
+        evidence_lines = [str(line) for line in item.get("evidence") or [] if str(line).strip()]
+        if problem:
+            lines.append(f"  problem: {problem}")
+        if why:
+            lines.append(f"  why: {why}")
+        for line in fix_lines:
+            lines.append(f"  fix: {line}")
+        for line in evidence_lines:
+            lines.append(f"  evidence: {line}")
         for warning in item.get("warnings") or []:
             lines.append(f"  warning: {warning}")
         for error in item.get("errors") or []:
@@ -528,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}")
@@ -537,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] = []