@researai/deepscientist 1.5.12 → 1.5.14

package/docs/zh/15_CODEX_PROVIDER_SETUP.md

@@ -25,12 +25,19 @@ ds
 
 ### 2. 临时使用 provider profile
 
-如果你已经有一个可用的 Codex profile，例如 `minimax`、`glm`、`ark`、`bailian`，最简单的方式就是直接在启动 `ds` 时透传它。
+如果你已经有一个可用的 Codex profile，例如 `m27`、`glm`、`ark`、`bailian`，最简单的方式就是直接在启动 `ds` 时透传它。
 
 ```bash
-codex --profile minimax
-ds doctor --codex-profile minimax
-ds --codex-profile minimax
+codex --profile m27
+ds doctor --codex-profile m27
+ds --codex-profile m27
+```
+
+如果你这一轮要强制指定某一个 Codex 可执行文件，也可以这样：
+
+```bash
+ds doctor --codex /absolute/path/to/codex --codex-profile m27
+ds --codex /absolute/path/to/codex --codex-profile m27
 ```
 
 这是最简单的路径。只是临时试用某个 provider 时，不需要先改 `runners.yaml`。
@@ -62,7 +69,7 @@ codex:
 | Provider | 官方文档 | 是否需要 Codex 登录 | DeepScientist 应该怎么用 |
 |---|---|---|---|
 | OpenAI | 正常 Codex 配置即可 | 是 | 不需要 profile，直接 `ds` |
-| MiniMax | [MiniMax Codex CLI](https://platform.minimaxi.com/docs/coding-plan/codex-cli) | 否 | 使用你自己的 Codex profile，例如 `ds --codex-profile minimax` |
+| MiniMax | [MiniMax Codex CLI](https://platform.minimaxi.com/docs/coding-plan/codex-cli) | 否 | 使用你自己的 Codex profile，例如 `ds --codex-profile m27` |
 | GLM | [GLM Coding Plan：其他工具](https://docs.bigmodel.cn/cn/coding-plan/tool/others) | 否 | 使用一个指向 GLM coding endpoint 的 Codex profile |
 | 火山方舟 | [Ark Coding Plan 总览](https://www.volcengine.com/docs/82379/1925114?lang=zh) | 否 | 使用一个指向 Ark coding endpoint 的 Codex profile |
 | 阿里百炼 | [百炼 Coding Plan：其他工具](https://help.aliyun.com/zh/model-studio/other-tools-coding-plan) | 否 | 使用一个指向 Bailian coding endpoint 的 Codex profile |
@@ -100,15 +107,65 @@ MiniMax 是最典型的 profile 模式。它的官方 Codex CLI 文档直接给
 
 - <https://platform.minimaxi.com/docs/coding-plan/codex-cli>
 
+### 已验证的兼容性说明
+
+按 2026-03-25 对 MiniMax 官方 Codex CLI 页面和本地兼容性测试的核对结果：
+
+- MiniMax 官方 Codex CLI 页面当前建议使用 `@openai/codex@0.57.0`
+- MiniMax 当前应使用的 Coding Plan endpoint 是 `https://api.minimaxi.com/v1`
+- MiniMax 官方页面示例 profile 名是 `m21`，但 profile 名本身只是本地别名；本仓库统一用 `m27` 作为示例名
+- MiniMax 官方页面当前给出的 `codex-MiniMax-*` 模型名，在本地使用你提供的 key 实测并不能稳定通过 Codex CLI
+- 本地实测能稳定跑通的组合是 `MiniMax-M2.7` + `m27` + `model: inherit` + Codex CLI `0.57.0`
+- 当前最新版 `@openai/codex` 和 MiniMax 官方文档并不能稳定直接对齐
+
+如果你现在要走最稳的 DeepScientist + MiniMax 路径，建议直接使用 Codex CLI `0.57.0`。
+
 ### 需要准备什么
 
-- 已安装 Codex CLI
+- 已安装 Codex CLI `0.57.0`
+- 已创建 MiniMax `Coding Plan Key`
 - 在启动 Codex 和 DeepScientist 的 shell 中可见的 `MINIMAX_API_KEY`
+- 当前 shell 已清理 `OPENAI_API_KEY` 和 `OPENAI_BASE_URL`
 - `~/.codex/config.toml` 中已经配置好的 Codex profile
 
+### 安装 Codex CLI `0.57.0`
+
+最直接的方式是把全局 Codex 安装固定到 `0.57.0`：
+
+```bash
+npm install -g @openai/codex@0.57.0
+codex --version
+```
+
+预期输出：
+
+```text
+codex-cli 0.57.0
+```
+
+如果你还想保留另一个 Codex 版本，也可以单独写一个 wrapper 脚本，再把 `runners.codex.binary` 指向那个绝对路径。
+
 ### Codex 侧配置
 
-MiniMax 官方页面给了真实的 Codex custom provider 示例。profile 名称由你自己决定。下面用 `minimax` 作为示例；如果你已经配置成 `m27`，就继续使用 `m27`。
+请使用 `https://api.minimaxi.com/v1`，不要用 `https://api.minimax.io/v1`。
+
+MiniMax 官方文档要求在配置前先清理 OpenAI 环境变量：
+
+```bash
+unset OPENAI_API_KEY
+unset OPENAI_BASE_URL
+export MINIMAX_API_KEY="..."
+```
+
+MiniMax 官方页面示例 profile 名是 `m21`。由于 profile 名只是本地别名，本仓库统一改写成 `m27`。
+
+先说明差异：
+
+- 官方页面当前展示的是 `codex-MiniMax-M2.5`
+- 但本地实测里，直接请求 MiniMax API 能稳定跑通的是 `MiniMax-M2.7`
+- 同一把 key 下，`codex-MiniMax-M2.5` / `codex-MiniMax-M2.7` 通过 Codex CLI 都会失败
+
+因此，下面给的是当前 DeepScientist 推荐的可运行配置：
 
 ```toml
 [model_providers.minimax]
@@ -121,23 +178,50 @@ request_max_retries = 4
 stream_max_retries = 10
 stream_idle_timeout_ms = 300000
 
-[profiles.minimax]
-model = "codex-MiniMax-M2.5"
+[profiles.m27]
+model = "MiniMax-M2.7"
+model_provider = "minimax"
+```
+
+DeepScientist 现在对它的支持方式是：
+
+- 如果你使用的是这类 profile-only MiniMax 配置，再配合 Codex CLI `0.57.0`，DeepScientist 会在自己的 probe / 运行时临时 `.codex/config.toml` 里，把所选 profile 的 `model_provider` 和 `model` 自动提升到顶层
+- 这意味着即使终端里原样执行 `codex --profile m27` 还会失败，DeepScientist 也可以先兼容跑起来
+
+如果你还希望终端里的 `codex --profile <name>` 也直接可用，请使用显式顶层兼容写法：
+
+```toml
+model = "MiniMax-M2.7"
+model_provider = "minimax"
+approval_policy = "never"
+sandbox_mode = "workspace-write"
+
+[model_providers.minimax]
+name = "MiniMax Chat Completions API"
+base_url = "https://api.minimaxi.com/v1"
+env_key = "MINIMAX_API_KEY"
+wire_api = "chat"
+requires_openai_auth = false
+request_max_retries = 4
+stream_max_retries = 10
+stream_idle_timeout_ms = 300000
+
+[profiles.m27]
+model = "MiniMax-M2.7"
 model_provider = "minimax"
 ```
 
 然后执行：
 
 ```bash
-export MINIMAX_API_KEY="..."
-codex --profile minimax
+codex --profile m27
 ```
 
 ### DeepScientist 命令
 
 ```bash
-ds doctor --codex-profile minimax
-ds --codex-profile minimax
+ds doctor --codex-profile m27
+ds --codex-profile m27
 ```
 
 ### 持久化 runner 配置
@@ -145,12 +229,26 @@ ds --codex-profile minimax
 ```yaml
 codex:
   enabled: true
-  binary: codex
+  binary: /tmp/codex057-wrapper
   config_dir: ~/.codex
-  profile: minimax
+  profile: m27
   model: inherit
+  model_reasoning_effort: high
 ```
 
+如果你已经把全局 `codex` 固定到 `0.57.0`，也可以把 `binary` 写回 `codex`。这里写绝对路径只是为了明确避免误用系统里其他版本的 Codex。
+
+如果你不想把这个路径持久化写进 `runners.yaml`，也可以保留 `binary: codex`，然后在启动时临时加：
+
+```bash
+ds --codex /absolute/path/to/codex --codex-profile m27
+```
+
+DeepScientist 现在会为 MiniMax 的 `0.57.0` 路径额外做两层兼容：
+
+- 当检测到旧版 Codex CLI 不支持 `xhigh` 时，自动把 `xhigh` 降级成 `high`
+- 当检测到 MiniMax 使用 profile-only 的 `model_provider` / `model` 配置形态时，在临时 DeepScientist Codex home 里自动补齐顶层字段
+
 ## GLM
 
 GLM 的官方文档把 Coding Plan 描述成 OpenAI-compatible 的 coding endpoint，而不是单独的 Codex 登录流程。

package/docs/zh/README.md

@@ -76,6 +76,8 @@ DeepScientist 灵活且易于使用，支持：
 
 - [00 快速开始](./00_QUICK_START.md)
   从安装、启动，到创建第一个项目，先看这一篇。
+- [05 TUI 端到端指南](./05_TUI_GUIDE.md)
+  如果你主要在服务器或终端里工作，这篇会带你从 `ds --tui` 一路走到 quest、connector 和跨端协作跑通。
 - [15 Codex Provider 配置](./15_CODEX_PROVIDER_SETUP.md)
   如果你准备通过 MiniMax、GLM、火山方舟、阿里百炼或其他 Codex profile 来运行 DeepScientist，先看这一篇。
 - [12 引导式工作流教程](./12_GUIDED_WORKFLOW_TOUR.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@researai/deepscientist",
-  "version": "1.5.12",
+  "version": "1.5.14",
   "description": "DeepScientist is not just a fully open-source autonomous scientific discovery system. It is also a research map that keeps growing from every round.",
   "license": "Apache-2.0",
   "files": [
@@ -38,6 +38,7 @@
     "@openai/codex": "^0.114.0",
     "ink": "npm:@jrichman/ink@6.4.6",
     "ink-gradient": "^3.0.0",
+    "qrcode": "^1.5.4",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
     "string-width": "^8.1.0"

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "deepscientist"
-version = "1.5.12"
+version = "1.5.14"
 description = "DeepScientist Core skeleton"
 readme = "README.md"
 requires-python = ">=3.11"

package/src/deepscientist/__init__.py

@@ -5,4 +5,4 @@ __all__ = ["__version__"]
 try:
     __version__ = _package_version("deepscientist")
 except PackageNotFoundError:  # pragma: no cover - source checkout fallback
-    __version__ = "1.5.12"
+    __version__ = "1.5.14"

package/src/deepscientist/artifact/service.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import re
 import shutil
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from typing import Any
 
 from ..arxiv_library import ArxivLibraryService
@@ -693,6 +693,29 @@ class ArtifactService:
         except ValueError:
             return str(path)
 
+    def _paper_bundle_relative_path(
+        self,
+        quest_root: Path,
+        path: Path | None,
+        *,
+        workspace_root: Path | None = None,
+    ) -> str | None:
+        if path is None:
+            return None
+        resolved = path.resolve()
+        roots = [self._workspace_root_for(quest_root, workspace_root), quest_root]
+        seen: set[str] = set()
+        for root in roots:
+            key = str(root.resolve())
+            if key in seen:
+                continue
+            seen.add(key)
+            try:
+                return resolved.relative_to(root.resolve()).as_posix()
+            except ValueError:
+                continue
+        return str(path)
+
     @staticmethod
     def _branch_kind_from_name(branch_name: str | None) -> str:
         normalized = str(branch_name or "").strip()
@@ -1289,6 +1312,100 @@ class ArtifactService:
     def _paper_baseline_inventory_path(self, quest_root: Path, *, workspace_root: Path | None = None) -> Path:
         return self._paper_root(quest_root, workspace_root=workspace_root, create=True) / "baseline_inventory.json"
 
+    def _paper_bundle_path_candidates(
+        self,
+        quest_root: Path,
+        raw_path: object,
+        *,
+        workspace_root: Path | None = None,
+    ) -> list[Path]:
+        text = str(raw_path or "").strip()
+        if not text:
+            return []
+        candidate = Path(text).expanduser()
+        roots = [self._workspace_root_for(quest_root, workspace_root), quest_root]
+        resolved: list[Path] = []
+        if candidate.is_absolute():
+            try:
+                resolved.append(candidate.resolve())
+            except OSError:
+                return []
+        else:
+            for root in roots:
+                try:
+                    resolved.append((root / candidate).resolve())
+                except OSError:
+                    continue
+        deduped: list[Path] = []
+        seen: set[str] = set()
+        for item in resolved:
+            key = str(item)
+            if key in seen:
+                continue
+            seen.add(key)
+            deduped.append(item)
+        return deduped
+
+    def _paper_bundle_compile_report(
+        self,
+        quest_root: Path,
+        *,
+        workspace_root: Path | None = None,
+        compile_report_path: object = None,
+    ) -> dict[str, Any]:
+        for candidate in self._paper_bundle_path_candidates(
+            quest_root,
+            compile_report_path,
+            workspace_root=workspace_root,
+        ):
+            if not candidate.exists() or not candidate.is_file():
+                continue
+            payload = read_json(candidate, {})
+            if isinstance(payload, dict):
+                return payload
+        return {}
+
+    def _normalize_paper_bundle_latex_root_path(
+        self,
+        quest_root: Path,
+        *,
+        workspace_root: Path | None = None,
+        latex_root_path: object = None,
+        compile_report_path: object = None,
+    ) -> str | None:
+        compile_report = self._paper_bundle_compile_report(
+            quest_root,
+            workspace_root=workspace_root,
+            compile_report_path=compile_report_path,
+        )
+        for raw in (
+            latex_root_path,
+            compile_report.get("latex_root_path"),
+            compile_report.get("main_file_path"),
+        ):
+            text = str(raw or "").strip()
+            if not text:
+                continue
+            for candidate in self._paper_bundle_path_candidates(
+                quest_root,
+                text,
+                workspace_root=workspace_root,
+            ):
+                if candidate.exists() and candidate.is_dir():
+                    return self._paper_bundle_relative_path(quest_root, candidate, workspace_root=workspace_root) or text
+                if candidate.suffix.lower() == ".tex":
+                    return self._paper_bundle_relative_path(
+                        quest_root,
+                        candidate.parent,
+                        workspace_root=workspace_root,
+                    ) or PurePosixPath(text).parent.as_posix()
+            if Path(text).suffix.lower() == ".tex":
+                parent = PurePosixPath(text).parent.as_posix()
+                if parent not in {"", "."}:
+                    return parent
+            return text
+        return None
+
     def _open_source_root(
         self,
         quest_root: Path,
@@ -5696,6 +5813,12 @@ class ArtifactService:
         default_compile_report_path = (
             self._workspace_relative(quest_root, paper_root / "build" / "compile_report.json") or "paper/build/compile_report.json"
         )
+        normalized_latex_root_path = self._normalize_paper_bundle_latex_root_path(
+            quest_root,
+            workspace_root=workspace_root,
+            latex_root_path=latex_root_path,
+            compile_report_path=compile_report_path or default_compile_report_path,
+        )
         manifest = {
             "schema_version": 1,
             "title": str(
@@ -5717,7 +5840,7 @@ class ArtifactService:
             "claim_evidence_map_path": str(claim_evidence_map_path or default_claim_map_path).strip() or None,
             "compile_report_path": str(compile_report_path or default_compile_report_path).strip() or None,
             "pdf_path": str(pdf_path or "").strip() or None,
-            "latex_root_path": str(latex_root_path or "").strip() or None,
+            "latex_root_path": normalized_latex_root_path,
             "baseline_inventory_path": paper_inventory_rel,
             "open_source_manifest_path": self._workspace_relative(
                 quest_root,

package/src/deepscientist/cli.py

@@ -39,6 +39,7 @@ def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(prog="ds", description="DeepScientist Core skeleton")
     parser.add_argument("--home", default=None, help="Override DeepScientist home")
     parser.add_argument("--proxy", default=None, help="Explicit outbound HTTP/WS proxy, for example `http://127.0.0.1:7890`.")
+    parser.add_argument("--codex", default=None, help="Override the Codex executable path for this invocation.")
 
     subparsers = parser.add_subparsers(dest="command", required=True)
 
@@ -475,6 +476,8 @@ def migrate_command(home: Path, target: str) -> int:
 def main(argv: list[str] | None = None) -> int:
     parser = build_parser()
     args = parser.parse_args(argv)
+    if args.codex:
+        os.environ["DEEPSCIENTIST_CODEX_BINARY"] = str(args.codex)
     configure_runtime_proxy(args.proxy)
     home = resolve_home(args)
 

package/src/deepscientist/codex_cli_compat.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import json
+import re
+import subprocess
+import tomllib
+from functools import lru_cache
+
+_MIN_XHIGH_SUPPORTED_VERSION = (0, 63, 0)
+_CODEX_VERSION_PATTERN = re.compile(r"codex-cli\s+(\d+)\.(\d+)\.(\d+)", re.IGNORECASE)
+
+
+def parse_codex_cli_version(text: str) -> tuple[int, int, int] | None:
+    match = _CODEX_VERSION_PATTERN.search(str(text or ""))
+    if not match:
+        return None
+    return tuple(int(part) for part in match.groups())
+
+
+@lru_cache(maxsize=32)
+def codex_cli_version(binary: str) -> tuple[int, int, int] | None:
+    normalized = str(binary or "").strip()
+    if not normalized:
+        return None
+    try:
+        result = subprocess.run(
+            [normalized, "--version"],
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    return parse_codex_cli_version(f"{result.stdout}\n{result.stderr}")
+
+
+def format_codex_cli_version(version: tuple[int, int, int] | None) -> str:
+    if version is None:
+        return ""
+    return ".".join(str(part) for part in version)
+
+
+def normalize_codex_reasoning_effort(
+    reasoning_effort: str | None,
+    *,
+    resolved_binary: str | None,
+) -> tuple[str | None, str | None]:
+    normalized = str(reasoning_effort or "").strip()
+    if not normalized:
+        return None, None
+    if normalized.lower() != "xhigh":
+        return normalized, None
+
+    version = codex_cli_version(str(resolved_binary or ""))
+    if version is None or version >= _MIN_XHIGH_SUPPORTED_VERSION:
+        return normalized, None
+
+    version_text = format_codex_cli_version(version)
+    return (
+        "high",
+        (
+            f"Codex CLI {version_text} does not support `xhigh`; "
+            "DeepScientist downgraded reasoning effort to `high` automatically."
+        ),
+    )
+
+
+def adapt_profile_only_provider_config(
+    config_text: str,
+    *,
+    profile: str,
+) -> tuple[str, str | None]:
+    normalized_profile = str(profile or "").strip()
+    if not normalized_profile or not str(config_text or "").strip():
+        return config_text, None
+    try:
+        parsed = tomllib.loads(config_text)
+    except tomllib.TOMLDecodeError:
+        return config_text, None
+
+    profiles = parsed.get("profiles")
+    if not isinstance(profiles, dict):
+        return config_text, None
+    profile_payload = profiles.get(normalized_profile)
+    if not isinstance(profile_payload, dict):
+        return config_text, None
+
+    prefix_lines: list[str] = []
+    injected_fields: list[str] = []
+    if "model_provider" not in parsed:
+        model_provider = str(profile_payload.get("model_provider") or "").strip()
+        if model_provider:
+            prefix_lines.append(f"model_provider = {json.dumps(model_provider, ensure_ascii=False)}")
+            injected_fields.append("model_provider")
+    if "model" not in parsed:
+        model = str(profile_payload.get("model") or "").strip()
+        if model:
+            prefix_lines.append(f"model = {json.dumps(model, ensure_ascii=False)}")
+            injected_fields.append("model")
+
+    if not prefix_lines:
+        return config_text, None
+
+    adapted = (
+        "# BEGIN DEEPSCIENTIST PROFILE COMPAT\n"
+        + "\n".join(prefix_lines)
+        + "\n# END DEEPSCIENTIST PROFILE COMPAT\n\n"
+        + config_text.lstrip()
+    )
+    return (
+        adapted,
+        (
+            f"DeepScientist promoted `{normalized_profile}` profile "
+            f"{', '.join(injected_fields)} to the top level for Codex compatibility."
+        ),
+    )

package/src/deepscientist/config/service.py

@@ -3,11 +3,14 @@ from __future__ import annotations
 import json
 import os
 import subprocess
+import tempfile
+from shutil import copy2
 from copy import deepcopy
 from pathlib import Path
 from urllib.error import URLError
 from urllib.request import Request
 
+from ..codex_cli_compat import adapt_profile_only_provider_config, normalize_codex_reasoning_effort
 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
@@ -486,6 +489,7 @@ This page edits `{home_text}/config/runners.yaml`.
 - `claude` remains TODO / reserved in the current open-source release and is not runnable 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
@@ -1206,6 +1210,31 @@ Use **Test** when the file exposes runtime dependencies.
             resolved[env_key] = str(value)
         return resolved
 
+    def _prepare_codex_probe_home(
+        self,
+        *,
+        config_dir: str,
+        profile: str,
+    ) -> tuple[str, str | None, tempfile.TemporaryDirectory[str] | None]:
+        expanded = Path(config_dir).expanduser()
+        config_path = expanded / "config.toml"
+        if not config_path.exists():
+            return str(expanded), None, None
+
+        original_text = read_text(config_path)
+        adapted_text, warning = adapt_profile_only_provider_config(original_text, profile=profile)
+        if warning is None:
+            return str(expanded), None, None
+
+        temp_home = tempfile.TemporaryDirectory(prefix="ds-codex-probe-")
+        temp_root = Path(temp_home.name)
+        for filename in ("auth.json",):
+            source_path = expanded / filename
+            if source_path.exists():
+                copy2(source_path, temp_root / filename)
+        write_text(temp_root / "config.toml", adapted_text)
+        return str(temp_root), warning, temp_home
+
     def _codex_missing_binary_guidance(self, config: dict) -> list[str]:
         profile = self._codex_profile_name(config)
         guidance = [
@@ -1221,7 +1250,9 @@ 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("If you use a custom Codex path, set `runners.codex.binary` to that absolute executable path.")
+        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]]:
@@ -1326,11 +1357,15 @@ Use **Test** when the file exposes runtime dependencies.
         profile = self._codex_profile_name(config)
         requested_model = self._codex_requested_model(config)
         raw_reasoning_effort = config.get("model_reasoning_effort")
-        reasoning_effort = (
+        requested_reasoning_effort = (
             str(raw_reasoning_effort).strip()
             if raw_reasoning_effort is not None and str(raw_reasoning_effort).strip()
             else ("xhigh" if raw_reasoning_effort is None else None)
         )
+        reasoning_effort, reasoning_effort_warning = normalize_codex_reasoning_effort(
+            requested_reasoning_effort,
+            resolved_binary=resolved_binary,
+        )
         details: dict[str, object] = {
             "binary": binary,
             "resolved_binary": resolved_binary,
@@ -1342,6 +1377,7 @@ Use **Test** when the file exposes runtime dependencies.
             "approval_policy": str(config.get("approval_policy") or "on-request"),
             "sandbox_mode": str(config.get("sandbox_mode") or "workspace-write"),
             "reasoning_effort": reasoning_effort,
+            "requested_reasoning_effort": requested_reasoning_effort,
             "model_fallback_attempted": False,
             "model_fallback_used": False,
             "checked_at": checked_at,
@@ -1365,9 +1401,20 @@ Use **Test** when the file exposes runtime dependencies.
         env = os.environ.copy()
         env.update(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] = []
         if config_dir:
-            env["CODEX_HOME"] = str(Path(config_dir).expanduser())
+            prepared_home, profile_config_warning, probe_home_handle = self._prepare_codex_probe_home(
+                config_dir=config_dir,
+                profile=profile,
+            )
+            env["CODEX_HOME"] = prepared_home
+            if profile_config_warning:
+                compatibility_warnings.append(profile_config_warning)
         prompt = "Reply with exactly HELLO."
+        if reasoning_effort_warning:
+            compatibility_warnings.append(reasoning_effort_warning)
+        base_warnings: list[str] = list(compatibility_warnings)
 
         def run_probe_once(model_for_command: str) -> tuple[list[str], subprocess.CompletedProcess[str] | None, subprocess.TimeoutExpired | None]:
             command = self._build_codex_probe_command(
@@ -1406,7 +1453,7 @@ Use **Test** when the file exposes runtime dependencies.
             return {
                 "ok": False,
                 "summary": "Codex startup probe timed out.",
-                "warnings": [],
+                "warnings": base_warnings,
                 "errors": [
                     "Codex did not answer the startup hello probe within 90 seconds.",
                     *self._codex_probe_failure_guidance(config)[0],
@@ -1463,7 +1510,7 @@ Use **Test** when the file exposes runtime dependencies.
                     return {
                         "ok": True,
                         "summary": "Codex startup probe completed with Codex default model fallback.",
-                        "warnings": [fallback_warning],
+                        "warnings": [*base_warnings, fallback_warning],
                         "errors": [],
                         "details": details,
                         "guidance": [
@@ -1483,7 +1530,7 @@ Use **Test** when the file exposes runtime dependencies.
                 "probe_command": command,
             }
         )
-        warnings: list[str] = []
+        warnings: list[str] = list(base_warnings)
         errors: list[str] = []
         if not ok:
             errors.append("Codex did not complete the startup hello probe successfully.")