super-dsh 0.1.11 → 0.1.12

package/agent-claude/dist/agent.js

@@ -286,6 +286,8 @@ export class ClaudeAgent {
     observedDefaultModel = "";
     /** Deliveries parked while idle without a wakeup; flushed at the next prompt. */
     remoteQueue = [];
+    /** Busy peer deliveries start their own turn inside the native Mod. */
+    pendingHubTurns = [];
     /** Serialization chain for async prompt deliveries (attachment prefetch). */
     deliveryChain = Promise.resolve();
     sessionIdentityCommitted = false;
@@ -456,13 +458,20 @@ export class ClaudeAgent {
         }
     }
     // ── internals ────────────────────────────────────────────────────────────
+    isHubMessage(message) {
+        const source = message.source;
+        return source?.kind === "a2a-relay" || source?.kind === "a2a-notice"
+            || ((source?.kind === "user" || source?.kind === "user-rpc") && source.rpcId?.startsWith("a2a-") === true);
+    }
     deliver(message, target, wakeup) {
         if (this.disposed)
             return;
         const busy = this.turnOpen || this.streaming;
         trace(`deliver target=${target} wakeup=${wakeup} busy=${busy}`);
         if (busy) {
-            this.appendUserMessage(message);
+            const peer = this.isHubMessage(message);
+            if (!peer)
+                this.appendUserMessage(message);
             this.scheduleDelivery(async () => {
                 const payload = await this.promptContent(message);
                 if (payload.kind === "empty") {
@@ -473,8 +482,22 @@ export class ClaudeAgent {
                     trace(`busy ${target} delivery for turn ${this.dashTurn} has no attachable content — not pushed`);
                     return;
                 }
-                const sent = target === "next-turn" ? this.client.followUp(payload.content) : this.client.steer(payload.content);
-                await sent;
+                if (peer) {
+                    const entry = { message, id: undefined, started: false };
+                    this.pendingHubTurns.push(entry);
+                    try {
+                        entry.id = await this.client.receiveHub(payload.content);
+                    }
+                    catch (error) {
+                        const index = this.pendingHubTurns.indexOf(entry);
+                        if (index >= 0)
+                            this.pendingHubTurns.splice(index, 1);
+                        throw error;
+                    }
+                }
+                else {
+                    await (target === "next-turn" ? this.client.followUp(payload.content) : this.client.steer(payload.content));
+                }
             });
             return;
         }
@@ -687,7 +710,7 @@ export class ClaudeAgent {
             this.fail(new Error(payload.reason));
             return;
         }
-        void this.client.prompt(payload.content).catch((error) => this.fail(error));
+        void (this.isHubMessage(message) ? this.client.receiveHub(payload.content) : this.client.prompt(payload.content)).catch((error) => this.fail(error));
     }
     /**
      * One-shot first-turn identity commit: the agent-preset stamp plus, when
@@ -1163,8 +1186,47 @@ export class ClaudeAgent {
         trace(`forwarding "${line}" to Claude`);
         this.prompt(createUserMessage({ content: [{ type: "text", text: line }], source: { kind: "user" } }));
     }
+    openStartedHubTurn() {
+        if (this.turnOpen)
+            return;
+        const index = this.pendingHubTurns.findIndex(entry => entry.started);
+        if (index < 0)
+            return;
+        const { message } = this.pendingHubTurns.splice(index, 1)[0];
+        this.openNativeTurn(message);
+    }
+    openNativeTurn(message) {
+        this.reserveTurn();
+        clearTimeout(this.idleExitTimer);
+        this.idleExitTimer = undefined;
+        this.beginActivity();
+        this.markRunning();
+        this.session.append("turn/start", { turn: this.dashTurn });
+        if (this.turnRoute !== undefined)
+            this.commitRequestHeader(this.turnRoute);
+        this.emitRequestContext(this.turnRoute);
+        if (message !== undefined)
+            this.appendUserMessage(message);
+    }
     handleEvent(event) {
+        // Any native plugin may start a model turn without an SDK input. Keep its
+        // observed output inside a valid turn even if its input is absent from
+        // the SDK stream. An explicit Hub receipt alone establishes peer source.
+        if (!this.turnOpen && (event.parentToolUseId ?? null) === null
+            && ["assistant_reasoning", "assistant_text", "assistant_message"].includes(event.type)) {
+            this.openStartedHubTurn();
+            if (!this.turnOpen)
+                this.openNativeTurn();
+        }
         switch (event.type) {
+            case "hub_turn_start": {
+                const entry = this.pendingHubTurns.find(item => item.id === event.messageId);
+                if (entry !== undefined) {
+                    entry.started = true;
+                    this.openStartedHubTurn();
+                }
+                break;
+            }
             case "session_init":
                 trace(`session_init model=${String(event.model)}`);
                 this.observeModelCatalog(event);
@@ -1242,6 +1304,7 @@ export class ClaudeAgent {
                         : { kind: "completed" });
                 this.markIdle();
                 this.endActivity();
+                this.openStartedHubTurn();
                 break;
             }
             case "todo_write": {

package/agent-claude/dist/claude-client.js

@@ -67,6 +67,8 @@ import { loadClaudeQuery, resolveClaudeBinary } from "./sdk-runtime.js";
 import { InputQueue } from "./input-queue.js";
 import { projectClaudeEvent } from "./claude-events.js";
 import { NATIVE_LAUNCH } from "./claude-launch.js";
+import { resolveClaudeHome } from "./claude-home.js";
+import { prepareClaudeNativePlugin } from "../../superd-hub/dist/foreign-claude.js";
 /** The default executable resolution: Task 1's `resolveClaudeBinary` —
  * `$CLAUDE_EXECUTABLE` (only while it exists) > `claude` on PATH >
  * `~/.local/bin/claude` > `/usr/local/bin/claude`. `undefined` means "no
@@ -158,6 +160,10 @@ export class ClaudeSdkClient {
     launch;
     /** True while a user turn is in flight (set on push, cleared on `turn_end`/`agent_end`). */
     turnActive = false;
+    hub;
+    prepareHub;
+    preparation;
+    hubSession;
     queue;
     query;
     pendingControls = [];
@@ -177,6 +183,15 @@ export class ClaudeSdkClient {
         this.canUseTool = config.canUseTool;
         this.allowDangerouslySkipPermissions = config.allowDangerouslySkipPermissions;
         this.launch = config.launch ?? NATIVE_LAUNCH;
+        this.hub = config.hub;
+        this.hub?.onTurnStarted(id => {
+            if (!this.closed) {
+                this.turnActive = true;
+                for (const listener of this.listeners)
+                    listener({ type: "hub_turn_start", messageId: id });
+            }
+        });
+        this.prepareHub = config.prepareHub ?? (config.hub === undefined ? undefined : () => prepareClaudeNativePlugin(config.hub, resolveClaudeHome()));
         refcount += 1;
     }
     /**
@@ -259,7 +274,13 @@ export class ClaudeSdkClient {
     async ensureStarted() {
         if (this.query !== undefined)
             return;
+        this.ensureUsable();
+        if (this.prepareHub !== undefined) {
+            this.preparation ??= this.prepareHub().then(value => { this.hubSession = value; });
+            await this.preparation;
+        }
         const f = await resolveFactory(this.worldHome); // await BEFORE the sync section
+        this.ensureUsable();
         if (this.query !== undefined)
             return; // lost the race to a concurrent first prompt — reuse its query
         const queue = new InputQueue();
@@ -282,6 +303,22 @@ export class ClaudeSdkClient {
         await this.ensureStarted();
         this.push(content, undefined);
     }
+    /** Peer messages enter the real Claude runtime through the native Mod inbox. */
+    async receiveHub(content) {
+        this.ensureUsable();
+        await this.ensureStarted();
+        if (this.hub === undefined || this.hubSession === undefined) {
+            // Standalone adapter has no Hub host and keeps its usual input channel.
+            this.push(content, undefined);
+            return;
+        }
+        const text = typeof content === "string" ? content : content.map(block => block.type === "text" ? block.text : "").join("\n\n");
+        if (!text)
+            throw new Error("[E_HUB_INPUT] Hub messages require text");
+        const id = await this.hub.enqueue(text);
+        this.turnActive = true;
+        return id;
+    }
     /** Surface parity with prompt: a plain queued user turn. */
     async followUp(content) {
         this.ensureUsable();
@@ -328,18 +365,23 @@ export class ClaudeSdkClient {
         this.closed = true;
         this.queue?.close();
         this.query?.close();
+        this.hub?.dispose();
         refcount = Math.max(0, refcount - 1);
     }
     // --- internals ------------------------------------------------------------
     buildOptions() {
         const launchExecutable = this.launch.pathToClaudeCodeExecutable;
         const executable = launchExecutable !== undefined && launchExecutable !== "" ? launchExecutable : executableResolver();
+        const env = { ...process.env, ...this.launch.env };
+        delete env.SUPERD_HUB_SESSION;
+        if (this.hubSession !== undefined)
+            env.SUPERD_HUB_SESSION = this.hubSession;
         return {
             cwd: this.cwdPath,
             // The launch env holds ADDITIONS only; spreading process.env first keeps
             // PATH/HOME and the user's own key alive (NATIVE_LAUNCH carries an empty
             // env, so the native shape is exactly `{ ...process.env }`).
-            env: { ...process.env, ...this.launch.env },
+            env,
             // The `--settings` command-line tier (a JSON string) outranks the user's
             // native settings.json env, so a provider-pinned launch rides it here
             // (2026-10-04 F-B: without it the native env pins the endpoint).
@@ -387,6 +429,9 @@ export class ClaudeSdkClient {
                     if (event.type === "session_init" && typeof event.sessionId === "string") {
                         this.threadIdValue = event.sessionId;
                     }
+                    if ((event.parentToolUseId ?? null) === null
+                        && ["assistant_text", "assistant_reasoning", "assistant_message"].includes(event.type))
+                        this.turnActive = true;
                     if (event.type === "turn_end")
                         this.turnActive = false;
                     this.emit(event);

package/agent-claude/dist/index.js

@@ -27,6 +27,7 @@ import { ClaudeSdkClient, probeClaudeModels } from "./claude-client.js";
 import { ClaudeAgent } from "./agent.js";
 import { ClaudeLlmAdapter, CLAUDE_PROVIDER_ID, routeIds } from "./adapter.js";
 import { resolveClaudeHome } from "./claude-home.js";
+import { bindForeignHub } from "../../superd-hub/dist/foreign-hub.js";
 import { resetProjectionState } from "./claude-events.js";
 import { claudeSessionIdFromDsh } from "./session-id.js";
 import { claudePermissionMode, defaultPermissionPreset, modeChangePatch, presetFromEvents, } from "./permission.js";
@@ -308,6 +309,7 @@ export class ClaudeProvider extends Service {
             cwd: spawnCwd,
             worldHome: this.home,
             canUseTool,
+            hub: bindForeignHub("claude", String(id), this.home, () => agentRef.current),
             allowDangerouslySkipPermissions: claudeMode === "bypassPermissions",
             ...overrides,
         });
@@ -419,6 +421,7 @@ export class ClaudeProvider extends Service {
             cwd: spawnCwd,
             worldHome: this.home,
             canUseTool,
+            hub: bindForeignHub("claude", String(id), this.home, () => agentRef.current),
             allowDangerouslySkipPermissions: claudeMode === "bypassPermissions",
             ...overrides,
         });

package/agent-claude/dist/sdk-runtime.js

@@ -49,7 +49,7 @@ import { promisify } from "node:util";
 /** The coding-agent SDK this line drives (a plain npm package, never declared). */
 export const SDK_PACKAGE = "@anthropic-ai/claude-agent-sdk";
 /** The pin, written here rather than in `package.json` — the marker carries it. */
-export const SDK_PACKAGE_VERSION = "0.3.263";
+export const SDK_PACKAGE_VERSION = "0.3.291";
 export function sdkRuntimeLayout(worldHome) {
     return {
         dir: join(worldHome, "sdk-runtime"),
@@ -139,7 +139,7 @@ export function resolveClaudeBinary() {
 export function sdkInstallArgv(version, mode) {
     const argv = [
         "install",
-        "--exact",
+        "--save-exact",
         "--ignore-scripts",
         "--omit=dev",
         "--no-audit",

package/agent-codex/dist/agent.js

@@ -1,3 +1,4 @@
+import { ToolCallRecovery } from "@deepseek-ai/dsh-session";
 import { agentEvents } from "@deepseek-ai/dsh-agent";
 import { Inbox } from "./inbox.js";
 import { canonicalHeader, headerEquals } from "@deepseek-ai/dsh-session";
@@ -267,6 +268,8 @@ export class CodexAgent {
     #step = 0;
     #lastTurn = 0;
     #turnOpen = false;
+    #turnCommitted = false;
+    #stepOpen = false;
     #cancelCause = null;
     /** Terminal model failure of the open turn (`message_end` stopReason "error"); consumed by `agent_end`. */
     #pendingFailure = null;
@@ -526,7 +529,7 @@ export class CodexAgent {
         catch (error) {
             trace(`#startTurn cold start failed: ${String(error)}`);
             if (this.#turnOpen) {
-                this.session.append("turn/start", { turn: this.#dashTurn });
+                this.#commitTurnStart();
                 this.session.append("user/message", message, { surfaceOp: "append" });
                 this.#closeTurn({ kind: "error", error: { message: String(error), code: "UNKNOWN" } });
             }
@@ -535,7 +538,7 @@ export class CodexAgent {
         }
         if (this.#disposed)
             return;
-        this.session.append("turn/start", { turn: this.#dashTurn });
+        this.#commitTurnStart();
         if (route !== undefined)
             this.#commitRequestHeader(route);
         this.#emitRequestContext(route);
@@ -812,7 +815,7 @@ export class CodexAgent {
             return;
         this.#reserveTurn();
         this.#localUserPending = localUser;
-        this.session.append("turn/start", { turn: this.#dashTurn });
+        this.#commitTurnStart();
         // This path opens a turn for a message the CLIENT queued and is now
         // generating, so the child is already running: resolve the route for the
         // log's benefit only. It cannot have moved since the turn it belongs to
@@ -824,9 +827,32 @@ export class CodexAgent {
         this.#emitRequestContext(route);
         this.session.append("user/message", message, { surfaceOp: "append" });
     }
+    #commitTurnStart() {
+        if (this.#turnCommitted)
+            return;
+        this.session.append("turn/start", { turn: this.#dashTurn });
+        this.#turnCommitted = true;
+    }
     #closeTurn(reason) {
         if (!this.#turnOpen)
             return;
+        this.#commitTurnStart();
+        if (this.#stepOpen) {
+            const events = this.session.snapshotEvents();
+            const start = events.findLastIndex(event => event.type === "step/start");
+            const recovery = new ToolCallRecovery();
+            for (const event of events.slice(start))
+                recovery.observe(event);
+            for (const result of recovery.results()) {
+                this.session.append("tool/result", result.data, {
+                    surfaceOp: "append",
+                    ...(result.sourceEventSeqs === undefined ? {} : { sourceEventSeqs: result.sourceEventSeqs }),
+                });
+            }
+            this.session.append("step/end", { turn: this.#dashTurn, step: this.#step });
+            this.#stepOpen = false;
+        }
+        this.#turnCommitted = false;
         this.#turnOpen = false;
         this.#localUserPending = false;
         this.session.append("turn/end", { turn: this.#dashTurn, reason });
@@ -848,6 +874,7 @@ export class CodexAgent {
         this.#stepStartPending = false;
         this.#step += 1;
         this.session.append("step/start", { turn: this.#dashTurn, step: this.#step });
+        this.#stepOpen = true;
         trace(`step/start turn=${this.#dashTurn} step=${this.#step}`);
     }
     /**
@@ -986,10 +1013,6 @@ export class CodexAgent {
                 trace("event turn_start");
                 this.#stepStartPending = true;
                 this.#pendingFailure = null;
-                // Open the step immediately (the SDK may never send message_start)
-                // and try the system prompt now that the thread's rollout exists.
-                this.#commitStepStart();
-                this.#emitSystemMessage();
                 break;
             case "message_start": {
                 const message = event.message;
@@ -1046,6 +1069,7 @@ export class CodexAgent {
                 break;
             }
             case "tool_execution_start": {
+                this.#flushDeferredAssistant();
                 const callId = String(event.toolCallId ?? "");
                 const name = String(event.toolName ?? "");
                 const argumentsJson = String(event.argumentsJson ?? JSON.stringify(event.args ?? {}));
@@ -1112,8 +1136,9 @@ export class CodexAgent {
                 // DSH turn-token fold requires the sample on a message of the SAME
                 // turn. Flushed inside the still-open step, BEFORE step/end.
                 this.#flushDeferredAssistant(convertUsage(event.data?.usage));
-                if (this.#turnOpen && this.#step > 0) {
+                if (this.#turnOpen && this.#stepOpen) {
                     this.session.append("step/end", { turn: this.#dashTurn, step: this.#step });
+                    this.#stepOpen = false;
                 }
                 break;
             case "agent_end": {

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

@@ -406,6 +406,7 @@ export class CodexAppServerClient {
         if (this.#closed)
             return;
         this.#closed = true;
+        this.#options.hub?.dispose();
         this.#sessionEpoch += 1;
         this.#transport?.close();
         this.#transport = undefined;
@@ -449,6 +450,7 @@ export class CodexAppServerClient {
             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: childEnv,
                 onNotification: (notification) => this.#onNotification(notification),
@@ -462,7 +464,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 },
@@ -488,7 +490,13 @@ export class CodexAppServerClient {
             ...(this.#options.sandboxMode === undefined ? {} : { sandbox: this.#options.sandboxMode }),
         };
         const response = asRecord(resumeId === null
-            ? await transport.request("thread/start", shared)
+            ? await transport.request("thread/start", {
+                ...shared,
+                ...(() => {
+                    const definition = this.#options.hub?.definition();
+                    return definition === undefined ? {} : { dynamicTools: [{ type: 'function', ...definition }] };
+                })(),
+            })
             : await transport.request("thread/resume", { threadId: resumeId, ...shared }));
         const thread = asRecord(response?.["thread"]);
         const threadId = asString(thread?.["id"]) ?? resumeId;
@@ -658,7 +666,22 @@ export class CodexAppServerClient {
         // closes the just-finished Dash turn and opens a fresh one.
         void this.#startTurn(next).catch((error) => this.#fail(error));
     }
-    #onServerRequest(request) {
+    async #onServerRequest(request) {
+        if (request.method === 'item/tool/call') {
+            const params = asRecord(request.params);
+            try {
+                const hub = this.#options.hub;
+                if (hub === undefined || params?.tool !== 'superd-hub' ||
+                    params.threadId !== this.#threadId || (params.namespace !== undefined && params.namespace !== null)) {
+                    throw new Error('[E_HUB_BINDING] Tool call does not belong to this Super D session; reconnect through Super D');
+                }
+                const result = await hub.execute(params.arguments);
+                return { result: { success: true, contentItems: [{ type: 'inputText', text: JSON.stringify(result) }] } };
+            }
+            catch (error) {
+                return { result: { success: false, contentItems: [{ type: 'inputText', text: error instanceof Error ? error.message : String(error) }] } };
+            }
+        }
         const handler = this.#serverRequestHandler;
         if (handler === undefined)
             return failClosedResponse(request.method);

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. runtime selection (override → installed desktop → CLI → pinned package),
+ *   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,6 +25,7 @@
  * process, and the client calls it on first real work.
  */
 import { spawn } from "node:child_process";
+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). */
@@ -69,15 +73,14 @@ 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 env = this.#options.env ?? { ...process.env };
-        const runtime = resolveCodexRuntime({
-            env: this.#options.command === undefined ? env : { ...env, CODEX_BIN: this.#options.command },
-        });
+        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.
@@ -99,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-native-config.js

@@ -127,7 +127,7 @@ export function mergeModelCatalog(existing, absorbed, models, template) {
         if (seen.has(model.id))
             continue;
         seen.add(model.id);
-        const base = bySlug.get(model.id) ?? fallback ?? {};
+        const base = { ...fallback, ...bySlug.get(model.id) };
         const entry = {
             ...base,
             slug: model.id,
@@ -138,6 +138,10 @@ export function mergeModelCatalog(existing, absorbed, models, template) {
         // carry verified hashes; remove stale generated values too. Context-limit
         // compaction and its window/threshold metadata remain unchanged.
         delete entry["comp_hash"];
+        // OpenAI's code-mode-only catalog entry cannot establish another
+        // endpoint's tool protocol. Omit it so Codex uses its normal tool mode.
+        // Also repair stale provider entries previously cloned from that cache.
+        delete entry["tool_mode"];
         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.
@@ -359,6 +363,7 @@ export function catalogTemplate(codexHome, worldHome) {
         readIfExists(providerCatalogPath(worldHome, "superd-model-catalog")),
         absorbedPath === undefined ? undefined : readIfExists(absorbedPath),
         readIfExists(join(codexHome, SUPERD_CATALOG_FILE)),
+        readIfExists(join(codexHome, "models_cache.json")),
     ];
     for (const text of sources) {
         const first = catalogEntries(text)[0];