super-dsh 0.1.10-e → 0.1.11-a

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
@@ -22,17 +22,53 @@ six primary `@pgmi-builds/agent-*` packages and three OPTIONAL SDK halves).
 Restart the profile and the
 home under `<DSH_HOME>/agents/<label>/` on first boot.
 
+## Remote web access
+
+To use the same authenticated UI through a reverse proxy or LAN relay, enable
+this profile patch:
+
+```yaml
+- id: superd-web-trust
+  config:
+    trustAllHosts: true
+```
+
+This skips Host/Origin restrictions and enables browser ownership for every
+hostname. Native token-to-cookie login, cookie expiry, and authority binding
+remain in effect. The default is `false`, preserving declared-authority mode.
+It does not change the server's listening address: keep loopback behind Caddy
+and a LAN relay. The test launcher enables this mode without `--host` or
+`--trusted-host` and starts the relay on every test port, including 4999.
+
 ## Runtimes
 
 | 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.
+
+**Provider compatibility:** each provider defines its own message, reasoning,
+and encrypted-state formats. Selecting another provider does not guarantee
+that it can consume the existing session history. Successful continuation
+across endpoints is an observed convenience, not an adapter guarantee.
+The adapter surfaces provider errors; if the selected provider rejects the
+history, start a new session with that provider.
+
 ### 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/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,18 @@ 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 }),
+                ...(this.#options.worldHome === undefined ? {} : { worldHome: this.#options.worldHome }),
                 args: ["app-server", ...launch.argv],
-                env: { ...process.env, ...launch.env },
+                env: childEnv,
                 onNotification: (notification) => this.#onNotification(notification),
                 onServerRequest: (request) => this.#onServerRequest(request),
                 onExit: (info) => {
@@ -456,7 +463,7 @@ export class CodexAppServerClient {
         }
         this.#transport = transport;
         if (first) {
-            transport.start();
+            await transport.start();
             const info = asRecord(await transport.request("initialize", {
                 clientInfo: { name: "superd-agent-codex", title: "Super D agent-codex", version: "0.1.0" },
                 capabilities: { experimentalApi: true, requestAttestation: false },

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

@@ -1,8 +1,12 @@
 /**
  * Narrow hand-written types for the codex `app-server` JSONL JSON-RPC wire.
  *
- * DERIVED FROM: the `codex app-server generate-ts --out <dir>` output for the
- * `@openai/codex` version this package pins (0.154.0). That tree is ~617 files;
+ * DERIVED FROM: the `codex app-server generate-ts --out <dir>` output for
+ * `@openai/codex@0.154.0` (the SDK line's tested pair). The app-server line's
+ * runtime target is the exact-pin `@openai/codex@0.160.0`, lazily fetched into
+ * the world home (codex-runtime-fetch.ts) — never an install-time dependency.
+ * That tree is ~617 files;
+
  * this module is a hand-written, deliberately narrow subset covering exactly
  * the envelopes, requests, notifications and item shapes
  * `src/app-server-client.ts` and `src/app-server-events.ts` consume. Each

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

@@ -7,7 +7,10 @@
  * `{"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 → PATH CLI → desktop core → fetched world-home
+ *      runtime — codex-runtime-fetch.ts; the pinned package is NEVER an
+ *      install-time dependency, 2026-10-06 ruling),
+
  *   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 +25,9 @@
  * process, and the client calls it on first real work.
  */
 import { spawn } from "node:child_process";
-import { createRequire } from "node:module";
+import { createCodexRuntimeDeps, ensureCodexRuntime } from "./codex-runtime-fetch.js";
+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 +42,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))
@@ -85,22 +73,25 @@ export class CodexAppServerTransport {
     }
     /**
      * Spawn the child exactly once. Idempotent.
-     * @throws when the child cannot be spawned at all (bad executable).
+     * @throws when no runtime can be discovered or fetched, or the child cannot
+     *   be spawned at all (bad executable).
      */
-    start() {
+    async start() {
         if (this.#child !== undefined)
             return;
-        const command = this.#options.command ?? resolveCodexCommand();
+        const env = this.#options.env ?? { ...process.env };
+        const runtime = await this.#resolveRuntime(env);
         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));
@@ -111,6 +102,20 @@ export class CodexAppServerTransport {
         child.on("error", (error) => this.#onExit(null, null, error));
         child.on("exit", (code, signal) => this.#onExit(code, signal));
     }
+    /**
+  
+     * Resolve the child's runtime. An explicit `command` and world-home-less
+     * calls stay on the pure sync ladder; only a world home arms the lazy fetch
+     * of the pinned package (2026-10-06 ruling — never an install-time dep).
+     */
+    async #resolveRuntime(env) {
+        if (this.#options.command !== undefined || this.#options.worldHome === undefined) {
+            return resolveCodexRuntime({
+                env: this.#options.command === undefined ? env : { ...env, CODEX_BIN: this.#options.command },
+            });
+        }
+        return ensureCodexRuntime(this.#options.worldHome, createCodexRuntimeDeps({ env }));
+    }
     /** Send a request and await its result. Rejects on protocol error, timeout, or EOF. */
     request(method, params, options = {}) {
         if (this.#closed || this.#child === undefined) {

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;
+}