super-dsh 0.1.10-e → 0.1.11

package/README.md

@@ -14,7 +14,7 @@ the foreign store.
 ## Install
 
 ```bash
-dsh plugin --profile <name> add super-dsh@0.1.0
+dsh plugin --profile <name> add super-dsh@0.1.11
 ```
 
 That single package composes the whole line (`@pgmi-builds/superd-hub` plus the
@@ -27,12 +27,28 @@ home under `<DSH_HOME>/agents/<label>/` on first boot.
 | Label | Runtime | Integration |
 |---|---|---|
 | OMP | OMP (`~/.omp`) | host `omp` binary over RPC (`omp --mode rpc`, NDJSON v1), lazy per session |
-| Codex | Codex CLI (`~/.codex`) | adapter world plugin |
+| Codex | Codex app-server (`~/.codex`) | desktop core first, CLI and bundled core fallback |
 | Claude | Claude Code (`~/.claude`) | standalone adapter, joined by the hub |
 | Pi | pi coding agent (`~/.pi`) | in-process SDK |
 | Hermes | Hermes (`~/.hermes`) | gateway child |
 | Antigravity | agy SDK | Python bridge (`bridge/agy_bridge.py`) |
 
+### Codex in 0.1.11
+
+Codex discovers the local OpenAI OAuth login as a read-only provider in the
+model selector. Selecting it explicitly overrides a third-party provider in the
+native config, while credentials and native configuration stay in the native
+home. Third-party providers remain selectable per session.
+
+The adapter prefers the installed desktop core, then the CLI, then the bundled
+0.160.0 core (`CODEX_BIN` overrides discovery). Desktop host browser and computer
+use services are separate and are not attached by this adapter.
+
+**Known limitation:** returning a session with third-party reasoning history to
+OpenAI OAuth can be rejected by the official endpoint. Use a separate official
+session for now. Compaction before switching was proven in an isolated probe;
+automatic compaction is not included in this release.
+
 ### Opt-in SDK halves
 
 Three runtimes also ship a preserved in-process SDK transport beside the primary

package/agent-agy/dist/agent.js

@@ -129,9 +129,27 @@ export class AgyAgent {
                     this.closeStep();
                 this.commitStepStart();
                 const callId = ToolCallId(ev.id || `agy-${this.dashTurn}-${this.step}`);
+                const argumentsJson = ev.args || "{}";
+                // Advertisement-before-execution (validator invariant, 2026-10-04 dev3
+                // omp/hermes repair family): agy assistant frames carry only
+                // reasoning/text — never tool-call blocks — so every tool/call needs
+                // a minimal advertisement assistant frame first; arguments are copied
+                // verbatim into both frames (validator: lifecycle arguments ≡
+                // advertised, strict string equality).
+                const advertisement = createAssistantMessage({
+                    content: [{ type: "tool-call", id: callId, name: ev.name, arguments: argumentsJson }],
+                    source: {
+                        provider: this.options.provider ?? "agy",
+                        model: this.options.model ?? "",
+                    },
+                });
+                this.session.append("assistant/message", {
+                    turn: this.dashTurn, step: this.step,
+                    message: advertisement, stream: [],
+                }, { surfaceOp: "append" });
                 this.session.append("tool/call", {
                     turn: this.dashTurn, step: this.step,
-                    callId, name: ev.name, arguments: ev.args || "{}",
+                    callId, name: ev.name, arguments: argumentsJson,
                 });
                 this.unpairedCalls.push({ callId, name: ev.name });
             }

package/agent-claude/dist/agent.js

@@ -969,8 +969,12 @@ export class ClaudeAgent {
      * projection carried — so the `tool_start` flush lands a same-attempt
      * sample and nothing ever stashes across turns.
      */
-    flushAssistant(usage) {
-        if (this.reasoningBuffer === "" && this.textBuffer === "") {
+    flushAssistant(usage, toolCall) {
+        // A toolCall rides the SAME frame (advertise+usage on one attempt): the
+        // token-meter fold requires every step's assistant frame to carry a usage
+        // sample, so a separate no-usage advertisement frame would turn the
+        // turn's whole usage disclosure undefined.
+        if (toolCall === undefined && this.reasoningBuffer === "" && this.textBuffer === "") {
             if (usage !== undefined)
                 trace("flush had usage but no buffered content — sample dropped (no message carries it)");
             return;
@@ -980,6 +984,9 @@ export class ClaudeAgent {
             blocks.push({ type: "reasoning", text: this.reasoningBuffer });
         if (this.textBuffer !== "")
             blocks.push({ type: "text", text: this.textBuffer });
+        if (toolCall !== undefined) {
+            blocks.push({ type: "tool-call", id: ToolCallId(toolCall.callId), name: toolCall.name, arguments: toolCall.arguments });
+        }
         this.reasoningBuffer = "";
         this.textBuffer = "";
         const effectiveUsage = usage ?? this.capturedUsage;
@@ -1006,13 +1013,23 @@ export class ClaudeAgent {
         this.streamBridge = undefined;
     }
     appendToolCall(callId, name, args) {
-        this.commitStepStart();
+        // The tool-call block rides the SAME assistant/message as any pending
+        // text (native advertise+usage shape): one attempt per step with the
+        // usage sample AND the advertisement on one frame. A separate no-usage
+        // advertisement frame would satisfy the format validator but break the
+        // token-meter fold (every step's assistant frame needs a usage sample).
+        const argumentsJson = JSON.stringify(args ?? {});
+        this.flushAssistant(undefined, {
+            callId,
+            name,
+            arguments: argumentsJson,
+        });
         this.session.append("tool/call", {
             turn: this.dashTurn,
             step: this.step,
             callId: ToolCallId(callId),
             name,
-            arguments: JSON.stringify(args ?? {}),
+            arguments: argumentsJson,
         });
     }
     appendToolResult(callId, content, isError) {
@@ -1193,7 +1210,8 @@ export class ClaudeAgent {
                 // RC-6: the mid-turn flush closes the attempt WITH the sample the
                 // message itself reported (captured above / on the assistant events).
                 this.captureProvenance(event);
-                this.flushAssistant();
+                // flushes pending text WITH the tool-call block as one assistant
+                // message (advertise+usage on one attempt — see appendToolCall).
                 this.appendToolCall(callId, name, event.arguments);
                 break;
             }

package/agent-codex/README.md

@@ -19,10 +19,10 @@ superd 外壳下的 **Codex adapter**（super-dsh 线）：把 Codex CLI 经由
 
 ## 线别（2026-10-03 迁移）
 
-**app-server 线**取代了原 `@openai/codex-sdk` 线（SDK 依赖已从本包与主 pack 移除）。
+**app-server 线**是主路线（SDK 依赖已从本包与主 pack 移除）。SDK 另存为默认关闭的 `agent-codex-sdk`，拥有独立的按需 runtime 安装。
 SDK 线在 adapter 里登记的一整排降级被 app-server 协议面直接消掉：
 
-| 能力 | SDK 线（已退役） | app-server 线（现役） |
+| 能力 | SDK 可选线 | app-server 主路线 |
 |---|---|---|
 | 打断 | 只有 AbortSignal（掐断本轮 stream） | **`turn/interrupt`** |
 | steer | 无 → 排队 followUp 近似 | **`turn/steer`**（注入进行中的 turn） |
@@ -82,19 +82,31 @@ collab/subagent 项。
 | 变量 | 作用 |
 |---|---|
 | `CODEX_TRACE=1` | provider/agent/app-server 追踪（stderr） |
-| `CODEX_BIN` | 覆盖 codex 入口脚本（测试）；默认 = 本包 pin 的 `@openai/codex/bin/codex.js` |
+| `CODEX_BIN` | 显式覆盖 Codex 核心或 JS 入口；默认依序发现 desktop 核心、用户 CLI、包内 exact-pin fallback |
 | `CODEX_HOME` | Codex 原生 home 重定向（**测试专用**；生产路径零重定向） |
 | `CODEX_APPROVAL_MODE` | 覆盖审批档（`never`/`on-request`/`on-failure`/`untrusted`；非法值忽略） |
 | `CODEX_APPROVAL_TIMEOUT_MS` | 审批应答超时；`0` 关闭；默认 300000 |
 | `CODEX_IDLE_EXIT_MS` | 会话空闲后拆客户端；`0` 关闭；默认 600000 |
 
+## Binary 与官方 OAuth
+
+核心发现顺序是显式 `CODEX_BIN` → 已安装 desktop 核心 → 用户 CLI → 包内 `@openai/codex@0.160.0`。
+发现和启动仅发生在真正 prompt 时。JS 入口经 Node 启动，原生核心直接执行；认证或生成失败不会静默换 provider。
+desktop 优先选择核心版本，不代表复制 desktop 宿主：独立 app-server 使用 Super D 自有 clientInfo，
+不借用父任务的 desktop 工具 pipe。browser/computer use 仍需要对应宿主服务与工具接线。
+
+本地 `auth.json` 有 ChatGPT OAuth 时，模型选择器增加只读的 **OpenAI OAuth** provider。
+adapter 正本仅存其 native 身份，token 留在 Codex home；选择该 route 时通过子进程配置覆盖 builtin `openai`，
+不会改写用户的 config/auth。官方模型读取原生 `models_cache.json`，并保留原生配置的官方默认模型；第三方自定义目录不会当作官方目录。
+没有原生目录冲突时不强制注入静态 catalog，让实际选中的 binary 按版本、身份与有效期维护 cache；有目录冲突时仅注入可消费的官方 cache，缺失时明确报错。原生默认模型的 ID 不代表当前 binary 的访问权限。OAuth logout 后显式选择必须失败，不能落到本地第三方默认配置。
+
 ## 测试
 
 ```bash
-npm run build                                   # tsc strict
+node super-dsh/scripts/pack.mjs                  # 仓根执行，唯一构建打包入口
 DSH_HOME=<repo>/.tests \
-SUPERD_DSH_ANCHOR=<repo>/upstream/deepseek-harness/package.json \
-node --test test/*.test.mjs
+SUPERD_DSH_ANCHOR=<repo>/upstream/deepseek-harness/apps/cli/package.json \
+node --test super-dsh/agent-codex/test/*.test.mjs
 ```
 
 单测全部是 fake：`test/fixtures/fake-app-server.mjs` 是一个**可编程的 app-server 替身**

package/agent-codex/dist/adapter.js

@@ -1,3 +1,5 @@
+import { readEffectiveProviderStore } from "./codex-oauth.js";
+import { resolveCodexHome } from "./codex-store.js";
 /**
  * Codex-backed `LlmAdapter` registered on `ctx.llm` by the Codex provider.
  *
@@ -23,7 +25,6 @@
  * @module agent-codex/adapter
  */
 import { LlmAdapter, LlmError, } from "@deepseek-ai/dsh-llm";
-import { readProviderStore } from "./codex-providers.js";
 /**
  * The single route every Codex model was served under before the multi-provider
  * rework. No longer registered (a session pinned to it falls back to whatever
@@ -41,7 +42,7 @@ export function routeIds(store) {
 }
 /** The provider entry a route id names, or `undefined`. */
 export function providerFor(worldHome, providerId) {
-    return readProviderStore(worldHome).providers.find((entry) => entry.id === providerId);
+    return readEffectiveProviderStore(worldHome, resolveCodexHome()).providers.find((entry) => entry.id === providerId);
 }
 export class CodexLlmAdapter extends LlmAdapter {
     worldHome;

package/agent-codex/dist/agent.js

@@ -289,6 +289,11 @@ export class CodexAgent {
      */
     #remoteQueue = [];
     #bridgedToolResults = new Set();
+    /** callIds already advertised by an appended assistant/message frame — the
+     *  strict validator refuses any `tool/call` whose callId no assistant frame
+     *  advertised, and requires the execution arguments to equal the advertised
+     *  string (2026-10-04 dev3 omp/hermes repair: same write-side family). */
+    #advertisedToolCalls = new Set();
     /**
      * The open turn's FINAL assistant message, buffered from `message_end`
      * until `turn_end` so the SAME turn's usage can land on it (the DSH
@@ -711,9 +716,14 @@ export class CodexAgent {
         // An unknown provider id (a session pinned before the multi-provider rework)
         // maps to "no injection": the user's own config.toml is the honest answer.
         const launchSpec = launch ?? NATIVE_LAUNCH;
-        const providerId = launch === undefined ? null : route?.provider ?? null;
+        const providerId = launch === undefined ? null : launch.runtimeProvider ?? route?.provider ?? null;
         const client = this.#client;
         const key = `${providerId ?? "native"}/${route?.model ?? ""}`;
+        // Pin before ensureStarted: the first thread and turn otherwise inherit
+        // the native model captured at construction, even with a new provider.
+        if (route !== undefined) {
+            await client.setModel(route.provider, route.model);
+        }
         if (!client.spawned && client.threadId === null) {
             client.applyLaunch(launchSpec, providerId);
             await client.ensureStarted();
@@ -726,11 +736,6 @@ export class CodexAgent {
         else if (client.appliedProvider !== providerId) {
             await client.reattach(launchSpec, providerId, route?.model);
         }
-        else if (route !== undefined) {
-            await client.setModel(route.provider, route.model).catch((error) => {
-                trace(`set_model ${key} failed: ${String(error)}`);
-            });
-        }
         this.#routeKey = key;
     }
     /**
@@ -1043,7 +1048,32 @@ export class CodexAgent {
             case "tool_execution_start": {
                 const callId = String(event.toolCallId ?? "");
                 const name = String(event.toolName ?? "");
+                const argumentsJson = String(event.argumentsJson ?? JSON.stringify(event.args ?? {}));
                 this.#commitStepStart();
+                // Advertisement-before-execution (validator invariant, 2026-10-04 dev3
+                // omp/hermes repair family): unless a real assistant frame advertised
+                // this callId, bridge a minimal assistant/message carrying the
+                // tool-call block — arguments copied verbatim into both frames. The
+                // synthesized source mirrors #appendAssistantMessage's open-turn
+                // fallback chain.
+                if (!this.#advertisedToolCalls.has(callId)) {
+                    const advertisement = createAssistantMessage({
+                        content: [{ type: "tool-call", id: ToolCallId(callId), name, arguments: argumentsJson }],
+                        source: {
+                            provider: String(this.#turnRoute?.provider ?? this.options.provider ?? ""),
+                            model: String(this.#turnRoute?.model ?? this.options.model ?? ""),
+                        },
+                    });
+                    this.session.append("assistant/message", {
+                        turn: this.#dashTurn,
+                        step: this.#step,
+                        message: advertisement,
+                        stream: [],
+                    }, {
+                        surfaceOp: "append",
+                    });
+                    this.#advertisedToolCalls.add(callId);
+                }
                 this.session.append("tool/call", {
                     turn: this.#dashTurn,
                     step: this.#step,
@@ -1052,7 +1082,7 @@ export class CodexAgent {
                     // The DSH payload requires the RAW JSON string the model produced;
                     // the wire carries it verbatim for MCP calls and renders it from the
                     // discrete fields for the other item shapes.
-                    arguments: String(event.argumentsJson ?? JSON.stringify(event.args ?? {})),
+                    arguments: argumentsJson,
                 });
                 break;
             }
@@ -1164,6 +1194,10 @@ export class CodexAgent {
     }
     #appendAssistantMessage(message, usage) {
         const content = convertContent(message.content);
+        for (const block of content) {
+            if (block.type === "tool-call")
+                this.#advertisedToolCalls.add(block.id);
+        }
         const assistant = createAssistantMessage({
             content,
             source: {

package/agent-codex/dist/app-server-client.js

@@ -440,11 +440,17 @@ export class CodexAppServerClient {
             // crash still fails the client.
             const generation = ++this.#transportGeneration;
             const launch = this.#launch;
+            // This is an independent Super D consumer, including when its parent
+            // happens to be a desktop task. The desktop host's attribution and
+            // tools pipe belong to that host, not to this new app-server.
+            const childEnv = { ...process.env, ...launch.env };
+            delete childEnv.CODEX_INTERNAL_ORIGINATOR_OVERRIDE;
+            delete childEnv.CODEX_APP_TOOLS_PIPE_PATH;
             transport = transportFactory({
                 ...(this.#options.cwd === undefined ? {} : { cwd: this.#options.cwd }),
                 ...(this.#options.requestTimeoutMs === undefined ? {} : { requestTimeoutMs: this.#options.requestTimeoutMs }),
                 args: ["app-server", ...launch.argv],
-                env: { ...process.env, ...launch.env },
+                env: childEnv,
                 onNotification: (notification) => this.#onNotification(notification),
                 onServerRequest: (request) => this.#onServerRequest(request),
                 onExit: (info) => {

package/agent-codex/dist/app-server-wire.js

@@ -7,7 +7,7 @@
  * `{"id":…,"result":…}` / `{"id":…,"error":{…}}`).
  *
  * This module owns exactly four things and nothing else:
- *   1. executable resolution (pin-faithful: the package's own `@openai/codex`),
+ *   1. runtime selection (override → installed desktop → CLI → pinned package),
  *   2. process spawn + line framing + per-id request/response correlation,
  *   3. dispatch of server-initiated notifications and server-requests,
  *   4. teardown (process GROUP kill — the app-server may spawn stdio MCP
@@ -22,7 +22,8 @@
  * process, and the client calls it on first real work.
  */
 import { spawn } from "node:child_process";
-import { createRequire } from "node:module";
+import { resolveCodexRuntime } from "./codex-runtime.js";
+export { resolveCodexCommand, resolveCodexRuntime } from "./codex-runtime.js";
 /** Per-request protocol error surfaced by the server (JSON-RPC `error` object). */
 export class CodexWireError extends Error {
     code;
@@ -37,23 +38,6 @@ export class CodexWireError extends Error {
 /** Server overload: the documented retryable backpressure code. */
 export const SERVER_OVERLOADED_CODE = -32001;
 const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
-/** The codex entry script this package pins (`@openai/codex/bin/codex.js`). */
-export function resolveCodexCommand() {
-    const override = process.env.CODEX_BIN;
-    if (override !== undefined && override.trim() !== "")
-        return override;
-    const require = createRequire(import.meta.url);
-    try {
-        // Pin-faithful: the SAME `@openai/codex` this package depends on, so the
-        // wire protocol and the binary version can never drift apart. Set
-        // CODEX_BIN to override (tests).
-        return require.resolve("@openai/codex/bin/codex.js");
-    }
-    catch (error) {
-        throw new Error("cannot locate the pinned codex CLI (@openai/codex/bin/codex.js): "
-            + `${error instanceof Error ? error.message : String(error)}. Install the package or set CODEX_BIN.`);
-    }
-}
 /** True for a plain JSON object (never arrays/null). */
 function asRecord(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value))
@@ -90,17 +74,21 @@ export class CodexAppServerTransport {
     start() {
         if (this.#child !== undefined)
             return;
-        const command = this.#options.command ?? resolveCodexCommand();
+        const env = this.#options.env ?? { ...process.env };
+        const runtime = resolveCodexRuntime({
+            env: this.#options.command === undefined ? env : { ...env, CODEX_BIN: this.#options.command },
+        });
         const args = [...(this.#options.args ?? ["app-server"])];
         // `detached` gives the child its own process group so teardown can kill
         // the whole tree (stdio MCP descendants included), not just the root.
-        const child = spawn(process.execPath, [command, ...args], {
+        const child = spawn(runtime.nodeScript ? process.execPath : runtime.command, runtime.nodeScript ? [runtime.command, ...args] : args, {
             cwd: this.#options.cwd,
-            env: this.#options.env ?? { ...process.env },
+            env,
             stdio: ["pipe", "pipe", "pipe"],
             detached: true,
         });
         this.#child = child;
+        this.#options.onStderr?.(`codex runtime source=${runtime.source} command=${runtime.command} mode=${runtime.nodeScript ? "node" : "native"}\n`);
         child.stdout?.setEncoding("utf8");
         child.stderr?.setEncoding("utf8");
         child.stdout?.on("data", (chunk) => this.#onStdout(chunk));

package/agent-codex/dist/codex-launch.js

@@ -1,35 +1,4 @@
-/**
- * codex-launch.ts — how a provider reaches a `codex app-server` child
- * (2026-10-04 on-the-fly rework).
- *
- * The retired design put the provider in force by REWRITING the user's
- * `~/.codex/config.toml` before the child started. That made the user's native
- * home the switchboard: every switch was a disk write, only ever affected the
- * next child, and fought every other tool that owns the same file (cc-switch's
- * whole-config rewrites, the user's own hand edits).
- *
- * This module replaces it with process arguments. `codex app-server -c
- * <dotted.path>=<value>` overrides any `config.toml` value for THAT child
- * alone (the flag's own help text: "Override a configuration value that would
- * otherwise be loaded from `~/.codex/config.toml`. Use a dotted path."), and
- * `ThreadStartParams`/`ThreadResumeParams` accept the same object as `config`.
- * A provider therefore costs nothing on disk and is scoped to one process, which
- * is exactly what a per-session provider choice needs.
- *
- * Measured constraints this module encodes (see
- * `docs/test-reports/2026-10-03-codex-provider-model-switch-probe.md`):
- *
- *  - a HYPHENATED id is fine in a dotted path (`model_providers.zhipu-cn.…`),
- *    so native table names survive verbatim as provider ids;
- *  - `model_catalog_json` is resolved against the process CWD when it arrives
- *    as an override, so the path is always absolute;
- *  - `env_key` is the one auth shape that never consults the auth manager, so a
- *    stored API key rides the CHILD's environment under a synthetic variable
- *    name. That is also what makes a keyed provider usable behind a ChatGPT
- *    login, where `requires_openai_auth` is silently shadowed.
- *
- * @module agent-codex/codex-launch
- */
+import { officialCatalogForLaunch } from "./codex-oauth.js";
 import { tomlString, writeProviderCatalog } from "./codex-native-config.js";
 /** The environment variable prefix for a key this adapter injects itself. */
 const SYNTHETIC_KEY_PREFIX = "SUPERD_CODEX_KEY_";
@@ -48,6 +17,15 @@ export function syntheticKeyName(providerId) {
  * @returns the argv/env additions and the provider id they pin.
  */
 export function providerLaunch(worldHome, codexHome, provider) {
+    if (provider.kind === "openai-oauth") {
+        const catalog = officialCatalogForLaunch(codexHome);
+        // Empty override is filtered to None by Codex, restoring its builtin
+        // endpoint without changing the user's native configuration.
+        const argv = ["-c", 'model_provider="openai"', "-c", 'openai_base_url=""'];
+        if (catalog !== undefined)
+            argv.push("-c", `model_catalog_json=${tomlString(catalog)}`);
+        return { argv, env: {}, runtimeProvider: "openai" };
+    }
     const table = `model_providers.${provider.id}`;
     const argv = [
         "-c", `${table}.name=${tomlString(provider.label)}`,

package/agent-codex/dist/codex-native-config.js

@@ -95,9 +95,10 @@ function slugOf(entry) {
  * that we do not already hold, then upserts `models` by slug. Each upserted
  * entry is a CLONE of `template` — an existing entry for the same slug if there
  * is one, else the caller's template, else the first entry either side supplied
- * — with only the identity fields overridden. The other ~35 keys are Codex's
- * and are copied through untouched; see the plan's D5 for why we do not try to
- * synthesize them.
+ * — with identity and declared context window overridden. The other metadata
+ * is copied through except `comp_hash`: this optional opaque compatibility
+ * identifier belongs to the template's model, not an unrelated provider model.
+ * See the plan's D5 for why we do not synthesize the remaining fields.
  */
 export function mergeModelCatalog(existing, absorbed, models, template) {
     // Both sides are a TEMPLATE POOL only — never output. What gets emitted is
@@ -132,6 +133,11 @@ export function mergeModelCatalog(existing, absorbed, models, template) {
             slug: model.id,
             display_name: model.displayName ?? model.id,
         };
+        // A copied OpenAI hash falsely triggers previous-model compaction on
+        // provider switches in Codex 0.160. Our provider model declarations do not
+        // carry verified hashes; remove stale generated values too. Context-limit
+        // compaction and its window/threshold metadata remain unchanged.
+        delete entry["comp_hash"];
         if (model.contextWindow !== undefined) {
             // Codex reads context_window and caps against max_context_window; a stale
             // template value must not silently cap a larger real window.

package/agent-codex/dist/codex-oauth.js

@@ -0,0 +1,153 @@
+/** Native OAuth discovery. Tokens stay in Codex's own home; no network/spawn. */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { readNativeSelection } from './codex-native-config.js';
+import { readProviderStore } from './codex-providers.js';
+export const OPENAI_OAUTH_ID = 'openai-oauth';
+export function hasOpenAiOAuth(codexHome) {
+    try {
+        const value = JSON.parse(readFileSync(join(codexHome, 'auth.json'), 'utf8'));
+        const tokens = value?.tokens;
+        return value?.auth_mode === 'chatgpt' && tokens !== null && typeof tokens === 'object'
+            && [tokens.access_token, tokens.refresh_token].some(token => typeof token === 'string' && token.trim() !== '');
+    }
+    catch {
+        return false;
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function nonEmpty(value) {
+    return typeof value === 'string' && value.trim() !== '';
+}
+function oneOf(value, choices) {
+    return typeof value === 'string' && choices.includes(value);
+}
+/**
+ * The non-defaulted ModelInfo fields consumed by Codex, including its required
+ * nested metadata. Keep unknown native fields untouched; never repair or
+ * synthesize a catalog. Source: codex-rs/protocol/src/openai_models.rs (0.154 / 0.160).
+ */
+function usableModel(value) {
+    if (!isRecord(value) || !nonEmpty(value['slug']) || typeof value['display_name'] !== 'string')
+        return false;
+    const reasoning = value['supported_reasoning_levels'];
+    const truncation = value['truncation_policy'];
+    const messages = value['model_messages'];
+    if (typeof value['base_instructions'] !== 'string' && !(isRecord(messages) && typeof messages['instructions_template'] === 'string'))
+        return false;
+    return Array.isArray(reasoning) && reasoning.every(level => isRecord(level) && nonEmpty(level['effort']) && typeof level['description'] === 'string')
+        && oneOf(value['shell_type'], ['unified_exec', 'default', 'local', 'shell_command', 'disabled'])
+        && oneOf(value['visibility'], ['list', 'hide', 'none'])
+        && typeof value['supported_in_api'] === 'boolean'
+        && Number.isSafeInteger(value['priority']) && Number(value['priority']) >= -2147483648 && Number(value['priority']) <= 2147483647
+        && typeof value['support_verbosity'] === 'boolean'
+        && isRecord(truncation) && oneOf(truncation['mode'], ['tokens', 'bytes']) && Number.isSafeInteger(truncation['limit'])
+        && Array.isArray(value['experimental_supported_tools']) && value['experimental_supported_tools'].every(tool => typeof tool === 'string');
+}
+/** One bad entry invalidates the file: Codex deserializes the whole catalog. */
+function officialCatalogModels(codexHome) {
+    try {
+        const cache = JSON.parse(readFileSync(join(codexHome, 'models_cache.json'), 'utf8'));
+        if (!isRecord(cache))
+            return undefined;
+        const models = cache['models'];
+        if (Array.isArray(models) && models.length > 0 && models.every(usableModel))
+            return models;
+    }
+    catch { /* Missing/stale cache must not become a forced catalog override. */ }
+    return undefined;
+}
+/**
+ * Conservatively detect configuration that would leak into an official child
+ * without a cache override. Inspect all tables: a profile can supply a catalog
+ * even when the root has none. Accept indentation, quoted and dotted keys. We
+ * only need to know whether a conflicting override exists, not parse its value.
+ */
+function nativeAssignments(codexHome) {
+    let text;
+    try {
+        text = readFileSync(join(codexHome, 'config.toml'), 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const assignments = [];
+    for (const line of text.split('\n')) {
+        const assignment = /^\s*((?:[\w-]+|"[^"\n]+"|'[^'\n]+')(?:\s*\.\s*(?:[\w-]+|"[^"\n]+"|'[^'\n]+'))*)\s*=\s*(.*)$/.exec(line);
+        if (assignment === null)
+            continue;
+        const key = assignment[1].split(/\s*\.\s*/).at(-1)?.replace(/^["']|["']$/g, '');
+        assignments.push({ key, value: assignment[2] });
+    }
+    return assignments;
+}
+function nativeCatalogConflict(codexHome) {
+    return nativeAssignments(codexHome).some(({ key, value }) => key === 'model_catalog_json' || key === 'profile'
+        || (key === 'model_provider' && !/^(?:"openai"|'openai')\s*(?:#.*)?$/.test(value)));
+}
+/** Official runtime cache only: never consume a third-party custom catalog. */
+export function readOpenAiModels(codexHome) {
+    const models = [];
+    for (const raw of officialCatalogModels(codexHome) ?? []) {
+        if (raw['visibility'] !== 'list')
+            continue;
+        const slug = raw['slug'];
+        if (models.some(model => model.id === slug))
+            continue;
+        const displayName = raw['display_name'];
+        const contextWindow = raw['context_window'];
+        models.push({ id: slug,
+            ...(nonEmpty(displayName) ? { displayName } : {}),
+            ...(Number.isSafeInteger(contextWindow) && Number(contextWindow) > 0 ? { contextWindow: Number(contextWindow) } : {}),
+        });
+    }
+    // A different binary can leave a valid, older catalog in the shared home.
+    // Preserve the user's official configured choice as an identity, without
+    // inventing metadata or claiming that this cache/binary supports that model.
+    if (!nativeCatalogConflict(codexHome)) {
+        const native = readNativeSelection(codexHome);
+        if ((native.providerId === undefined || native.providerId === 'openai') && nonEmpty(native.model)
+            && !models.some(model => model.id === native.model))
+            models.push({ id: native.model });
+    }
+    return models;
+}
+/** Internal catalog shape; disk serialization stores just its native identity. */
+export function openAiOAuthEntry(codexHome) {
+    return { id: OPENAI_OAUTH_ID, label: 'OpenAI OAuth', kind: 'openai-oauth', origin: 'native',
+        baseUrl: '', protocol: 'responses', auth: { kind: 'apiKey', value: '' }, models: readOpenAiModels(codexHome) };
+}
+export function readEffectiveProviderStore(worldHome, codexHome) {
+    const store = readProviderStore(worldHome);
+    const aliasEntries = store.providers.filter(entry => entry.id === OPENAI_OAUTH_ID);
+    const ambiguous = aliasEntries.length > 1;
+    const blocked = store.blockedNativeIds?.includes(OPENAI_OAUTH_ID) === true;
+    return { ...store, providers: store.providers.flatMap(entry => entry.id === OPENAI_OAUTH_ID && ambiguous ? [] : entry.kind === 'openai-oauth'
+            ? !blocked && hasOpenAiOAuth(codexHome) ? [openAiOAuthEntry(codexHome)] : [] : [entry]) };
+}
+/** A usable runtime-owned catalog path, excluding malformed/empty cache files. */
+export function openAiCatalogPath(codexHome) {
+    return officialCatalogModels(codexHome) === undefined ? undefined : join(codexHome, 'models_cache.json');
+}
+/** Do not let an official child inherit a third-party model_catalog_json. */
+export function officialCatalogForLaunch(codexHome) {
+    if (!hasOpenAiOAuth(codexHome))
+        throw new Error('OpenAI OAuth authentication is unavailable; sign in using Codex');
+    if (nativeAssignments(codexHome).some(({ key, value }) => key === 'forced_login_method' && !/^(?:"chatgpt"|'chatgpt')\s*(?:#.*)?$/.test(value))) {
+        throw new Error('OpenAI OAuth cannot use a conflicting forced_login_method; choose ChatGPT login in your Codex configuration');
+    }
+    // A forced catalog is static in Codex and disables version/identity/TTL
+    // refresh. Let the selected binary own discovery when native config is safe;
+    // only override a conflicting native catalog with the validated official one.
+    if (!nativeCatalogConflict(codexHome))
+        return undefined;
+    const catalog = openAiCatalogPath(codexHome);
+    if (catalog !== undefined)
+        return catalog;
+    const native = readNativeSelection(codexHome);
+    if (nativeCatalogConflict(codexHome) || (native.providerId !== undefined && native.providerId !== 'openai'))
+        throw new Error('OpenAI OAuth model cache unavailable; open Codex with the official provider to refresh its models');
+    return undefined;
+}