pennyrouter 0.3.28 → 0.3.29

package/README.md

@@ -147,6 +147,17 @@ the user explicitly changes it. Close running Claude Code or Codex sessions only
 removing global bare-command routing. A Penny-only install does not require closing native sessions.
 
 The launcher uses a private config, a Claude settings overlay, and a secret-free Codex profile.
+For `penny claude`, it refreshes the gateway's `/v1/models` catalog before launch. A private
+gateway explicitly marks that catalog as its complete allowlist, so Penny uses it as Claude
+Code's curated `modelPicker` lineup and hides named built-in Anthropic rows while preserving the
+gateway's order and labels; Claude Code's own `Default` row remains. Hosted gateways omit the
+marker and retain Claude Code's normal built-in lineup. The last successful catalog and its
+private-gateway marker are cached per Penny profile for transient discovery failures.
+For `penny codex`, that same private marker makes the launcher write the gateway's rich Codex
+catalog to a per-profile file and select it with Codex's `model_catalog_json` setting. The picker
+and startup model are therefore limited to models the private upstream advertised. Hosted
+gateways do not set the marker, so Codex keeps its normal built-in catalog and automatically
+receives new OpenAI models. A cached private catalog is used only for the same gateway URL.
 The installer adds marked PATH blocks to the interactive and login startup files for zsh or bash
 on macOS/Linux, or a single user-PATH entry on Windows, when needed; `--no-path-update` skips that
 edit. Open a new terminal after a PATH update.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pennyrouter",
-  "version": "0.3.28",
+  "version": "0.3.29",
   "description": "Install and manage PennyRouter local coding-agent integrations.",
   "homepage": "https://pennyrouter.com",
   "bugs": {

package/src/harnesses/claude-code.js

@@ -53,6 +53,63 @@ export function writeClaudeCodeModelPresentation(env) {
   }
 }
 
+/**
+ * Fetch the Anthropic-shaped catalog that Claude Code would discover at startup.
+ *
+ * `modelPicker.replaceBuiltInOptions` also suppresses discovered rows, so the launcher
+ * has to repeat those rows as curated options if it wants a gateway-only picker. Keep
+ * the same id filter and display-name behavior as Claude Code: ids must contain
+ * "claude" or "anthropic", and a display name identical to the id is not an override.
+ */
+export async function fetchClaudeCodeModels(gatewayBaseUrl, apiKey) {
+  const headers = {
+    "x-pennyrouter-harness": "claude-code",
+    "anthropic-version": "2023-06-01",
+  };
+  if (apiKey) {
+    headers.Authorization = `Bearer ${apiKey}`;
+    headers["x-api-key"] = apiKey;
+  }
+  const response = await fetch(
+    `${String(gatewayBaseUrl).replace(/\/+$/, "")}/v1/models?limit=1000`,
+    {
+      headers,
+      redirect: "error",
+      signal: AbortSignal.timeout(3000),
+    },
+  );
+  if (!response.ok) throw new Error(`model catalog returned ${response.status}`);
+  const payload = await response.json();
+  const source = Array.isArray(payload?.data)
+    ? payload.data
+    : (Array.isArray(payload?.models) ? payload.models : []);
+  const seen = new Set();
+  const models = [];
+  for (const entry of source) {
+    const id = typeof entry?.id === "string" ? entry.id.trim() : "";
+    if (!id || !/(claude|anthropic)/i.test(id) || seen.has(id)) continue;
+    seen.add(id);
+    const displayName = typeof entry.display_name === "string"
+      ? entry.display_name.trim()
+      : (typeof entry.name === "string" ? entry.name.trim() : "");
+    const description = typeof entry.description === "string"
+      ? entry.description.replace(/\s+/g, " ").trim()
+      : "";
+    models.push({
+      model: id,
+      ...(displayName && displayName !== id ? { label: displayName } : {}),
+      ...(description ? { description } : {}),
+    });
+  }
+  if (models.length === 0) {
+    throw new Error("gateway returned no Claude-compatible models");
+  }
+  return {
+    models,
+    privateGateway: response.headers?.get?.("x-pennyrouter-private-gateway") === "1",
+  };
+}
+
 const CLAUDE_CODE_MODEL_PRESENTATION_KEYS = Object.keys(CLAUDE_CODE_MODEL_PRESENTATION)
   .flatMap((slot) => {
     const prefix = `ANTHROPIC_DEFAULT_${slot.toUpperCase()}_MODEL`;

package/src/harnesses/claude-code.test.js

@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 
 import {
   disableClaudeAiConnectors,
+  fetchClaudeCodeModels,
   restoreClaudeAiConnectors,
 } from "./claude-code.js";
 
@@ -54,4 +55,52 @@ testAbsentSettingIsRemovedOnUninstall();
 testExistingSettingIsRestored();
 testReinstallKeepsOriginalValue();
 testUninstallPreservesLaterUserEdit();
+
+async function testGatewayModelPickerRows() {
+  const previousFetch = globalThis.fetch;
+  let request;
+  try {
+    globalThis.fetch = async (url, options) => {
+      request = { url, options };
+      return {
+        ok: true,
+        headers: { get: (name) => name === "x-pennyrouter-private-gateway" ? "1" : null },
+        async json() {
+          return {
+            data: [
+              { id: "claude-fable-5-1", display_name: "Fable 5.1", description: "Fast\nmodel" },
+              { id: "claude-opus-4.8", display_name: "claude-opus-4.8" },
+              { id: "gpt-5", display_name: "GPT 5" },
+              { id: "vertex_ai/anthropic.claude-sonnet-5", name: "Vertex Sonnet" },
+              { id: "claude-fable-5-1", display_name: "Duplicate" },
+            ],
+          };
+        },
+      };
+    };
+    assert.deepEqual(
+      await fetchClaudeCodeModels("https://gateway.example/", "pr-test"),
+      {
+        models: [
+          { model: "claude-fable-5-1", label: "Fable 5.1", description: "Fast model" },
+          { model: "claude-opus-4.8" },
+          { model: "vertex_ai/anthropic.claude-sonnet-5", label: "Vertex Sonnet" },
+        ],
+        privateGateway: true,
+      },
+    );
+    assert.equal(request.url, "https://gateway.example/v1/models?limit=1000");
+    assert.deepEqual(request.options.headers, {
+      "x-pennyrouter-harness": "claude-code",
+      "anthropic-version": "2023-06-01",
+      Authorization: "Bearer pr-test",
+      "x-api-key": "pr-test",
+    });
+    assert.equal(request.options.redirect, "error");
+  } finally {
+    globalThis.fetch = previousFetch;
+  }
+}
+
+await testGatewayModelPickerRows();
 console.log("claude-code.test.js: all checks passed");

package/src/harnesses/codex.js

@@ -90,6 +90,41 @@ export async function detectCodexChatgptAuth() {
   return status.status === 0 && /logged in using chatgpt/i.test(`${status.stdout}\n${status.stderr}`);
 }
 
+/** Fetch the rich Codex catalog advertised by a PennyRouter gateway. */
+export async function fetchCodexModels(gatewayBaseUrl, apiKey) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 3000);
+  let response;
+  try {
+    response = await fetch(
+      `${String(gatewayBaseUrl).replace(/\/+$/, "")}/v1/models?limit=1000`,
+      {
+        headers: {
+          authorization: `Bearer ${apiKey}`,
+          "x-api-key": apiKey,
+          "x-pennyrouter-harness": "codex",
+        },
+        redirect: "error",
+        signal: controller.signal,
+      },
+    );
+  } finally {
+    clearTimeout(timeout);
+  }
+  if (!response.ok) {
+    throw new Error(`model discovery returned HTTP ${response.status}`);
+  }
+  const payload = await response.json();
+  const models = Array.isArray(payload?.models)
+    ? payload.models.filter((model) => model && typeof model.slug === "string" && model.slug.trim())
+    : [];
+  if (!models.length) throw new Error("model discovery returned no Codex models");
+  return {
+    models,
+    privateGateway: response.headers.get("x-pennyrouter-private-gateway") === "1",
+  };
+}
+
 /**
  * Install one marker-fenced provider block immediately before the first TOML table.
  * Root keys appended after a table are scoped into that table by TOML, so model_provider

package/src/harnesses/codex.test.js

@@ -6,11 +6,45 @@ import path from "node:path";
 import {
   codexHarness,
   codexUsesChatgptAuth,
+  fetchCodexModels,
   removeManagedCodexConfig,
   renderCodexConfig,
   isHostedPennyRouterGateway,
 } from "./codex.js";
 
+async function testGatewayCatalogDiscovery() {
+  const originalFetch = globalThis.fetch;
+  let request;
+  globalThis.fetch = async (url, options) => {
+    request = { url, options };
+    return {
+      ok: true,
+      status: 200,
+      headers: { get: (name) => name === "x-pennyrouter-private-gateway" ? "1" : null },
+      async json() {
+        return {
+          models: [
+            { slug: "gpt-5.6-terra", display_name: "GPT-5.6-Terra" },
+            { id: "not-a-codex-entry" },
+          ],
+        };
+      },
+    };
+  };
+  try {
+    const catalog = await fetchCodexModels("https://private.example/", "pr-secret");
+    assert.equal(request.url, "https://private.example/v1/models?limit=1000");
+    assert.equal(request.options.redirect, "error");
+    assert.equal(request.options.headers.authorization, "Bearer pr-secret");
+    assert.equal(request.options.headers["x-api-key"], "pr-secret");
+    assert.equal(request.options.headers["x-pennyrouter-harness"], "codex");
+    assert.equal(catalog.privateGateway, true);
+    assert.deepEqual(catalog.models.map((model) => model.slug), ["gpt-5.6-terra"]);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+}
+
 function testAuthDetection() {
   assert.equal(codexUsesChatgptAuth(null), false);
   assert.equal(codexUsesChatgptAuth({ auth_mode: "apikey" }), false);
@@ -140,5 +174,6 @@ testPrivateAndProxyGatewaysNeverEnableNativeSubscription();
 testLegacyMigrationAndIdempotence();
 testProviderCollisionFailsClosed();
 testUninstallLeavesUserConfig();
+await testGatewayCatalogDiscovery();
 await testReinstallPreservesRecordedProvider();
 console.log("codex.test.js: all checks passed");

package/src/launch.js

@@ -21,10 +21,12 @@ import { randomUUID } from "node:crypto";
 
 import { configureClaudeCodeStatusline } from "./statusline.js";
 import {
+  fetchClaudeCodeModels,
   upgradeClaudeCodeModelValue,
   writeClaudeCodeModelPresentation,
 } from "./harnesses/claude-code.js";
 import {
+  fetchCodexModels,
   isCodexSubscriptionAuthGateway,
   renderCodexConfig,
 } from "./harnesses/codex.js";
@@ -125,6 +127,14 @@ export function codexProfileName(profile = DEFAULT_PROFILE) {
   return `pennyrouter-${profile}`;
 }
 
+export function codexModelCatalogPath(profile = DEFAULT_PROFILE) {
+  return join(pennyDataDir(), `codex-models-${profile}.json`);
+}
+
+function codexModelCatalogStatePath(profile = DEFAULT_PROFILE) {
+  return join(pennyDataDir(), `codex-models-${profile}.state.json`);
+}
+
 export function claudeUserSkillPath() {
   return join(homeDir(), ".claude", "skills", "penny", "SKILL.md");
 }
@@ -442,7 +452,13 @@ export async function installPennyRuntime({ updatePath = true } = {}) {
   return { supported: true, ...path, shim_path: pennyShimPath(), compare };
 }
 
-export function renderCodexLaunchProfile({ gatewayBaseUrl, subscriptionAuth, privateGateway = false }) {
+export function renderCodexLaunchProfile({
+  gatewayBaseUrl,
+  subscriptionAuth,
+  privateGateway = false,
+  modelCatalogPath = null,
+  model = null,
+}) {
   // Native ChatGPT subscription auth is allowed for the hosted gateway and the explicitly
   // supported local development gateway. Apply the same rule as the config renderer at this
   // boundary, since this path is what bare `penny codex` selects at runtime.
@@ -466,7 +482,11 @@ export function renderCodexLaunchProfile({ gatewayBaseUrl, subscriptionAuth, pri
   ];
   return [
     CODEX_PROFILE_MARKER,
+    ...(model ? [`model = ${JSON.stringify(model)}`] : []),
     'model_provider = "pennyrouter"',
+    ...(privateGateway && modelCatalogPath
+      ? [`model_catalog_json = ${JSON.stringify(modelCatalogPath)}`]
+      : []),
     "",
     "[model_providers.pennyrouter]",
     'name = "PennyRouter"',
@@ -824,7 +844,12 @@ export function startPennyTerminalTitle({ gatewayBaseUrl, apiKey, titleSessionId
   };
 }
 
-async function writeClaudeLaunchSettings({ gatewayBaseUrl, apiKey } = {}) {
+export async function writeClaudeLaunchSettings({
+  gatewayBaseUrl,
+  apiKey,
+  models = [],
+  privateGateway = false,
+} = {}) {
   const native = (await readJsonFile(join(homeDir(), ".claude", "settings.json"), null)) || {};
   // Claude Code gives values from --settings precedence over the parent process
   // environment. Keep this overlay authoritative so a separately-managed
@@ -832,6 +857,17 @@ async function writeClaudeLaunchSettings({ gatewayBaseUrl, apiKey } = {}) {
   // redirect a `penny claude` session away from the selected Penny profile.
   const overlay = {
     disableClaudeAiConnectors: true,
+    ...(privateGateway && models.length
+      ? {
+          // Replacement hides both Claude's built-in rows and its automatically
+          // discovered rows. Repeat the gateway catalog here so the curated picker
+          // contains exactly the models that gateway advertised, in gateway order.
+          modelPicker: {
+            options: models,
+            replaceBuiltInOptions: true,
+          },
+        }
+      : {}),
     ...(gatewayBaseUrl && apiKey
       ? {
           env: {
@@ -849,6 +885,82 @@ async function writeClaudeLaunchSettings({ gatewayBaseUrl, apiKey } = {}) {
   await privateWrite(claudeLaunchSettingsPath(), `${JSON.stringify(overlay, null, 2)}\n`);
 }
 
+function claudeCodeModelCachePath(profile) {
+  return join(pennyDataDir(), `claude-models-${profile || DEFAULT_PROFILE}.json`);
+}
+
+/** Resolve a gateway-only Claude picker without making gateway availability fatal. */
+export async function resolveClaudeCodeLaunchModels(config) {
+  const cachePath = claudeCodeModelCachePath(config.profile);
+  try {
+    const catalog = await fetchClaudeCodeModels(config.gateway_base_url, config.api_key);
+    await writeJsonFile(cachePath, { ...catalog, fetched_at: new Date().toISOString() });
+    return catalog;
+  } catch (error) {
+    const cached = await readJsonFile(cachePath, null);
+    if (Array.isArray(cached?.models) && cached.models.length) {
+      console.error(
+        `PennyRouter: could not refresh Claude models from ${config.gateway_base_url} `
+        + `(${error.message}). Using the catalog cached ${cached.fetched_at}.`,
+      );
+      return {
+        models: cached.models,
+        // Old cache files predate the explicit server marker. Treating them as hosted
+        // is the safe rollout behavior: never hide built-ins based on a guess.
+        privateGateway: cached.privateGateway === true,
+      };
+    }
+    console.error(
+      `PennyRouter: could not load Claude models from ${config.gateway_base_url} `
+      + `(${error.message}). Claude Code will use its normal discovery fallback.`,
+    );
+    return { models: [], privateGateway: false };
+  }
+}
+
+function normalizedGatewayBaseUrl(value) {
+  return String(value || "").replace(/\/+$/, "");
+}
+
+/** Resolve the private Codex allowlist without ever applying it to the hosted gateway. */
+export async function resolveCodexLaunchCatalog(config) {
+  const catalogPath = codexModelCatalogPath(config.profile);
+  const statePath = codexModelCatalogStatePath(config.profile);
+  const gatewayBaseUrl = normalizedGatewayBaseUrl(config.gateway_base_url);
+  try {
+    const catalog = await fetchCodexModels(config.gateway_base_url, config.api_key);
+    const state = {
+      gateway_base_url: gatewayBaseUrl,
+      privateGateway: catalog.privateGateway,
+      models: catalog.models,
+      fetched_at: new Date().toISOString(),
+    };
+    await privateWrite(statePath, `${JSON.stringify(state, null, 2)}\n`);
+    if (!catalog.privateGateway) {
+      return { models: [], privateGateway: false, modelCatalogPath: null };
+    }
+    await privateWrite(catalogPath, `${JSON.stringify({ models: catalog.models }, null, 2)}\n`);
+    return { ...catalog, modelCatalogPath: catalogPath };
+  } catch (error) {
+    const cached = await readJsonFile(statePath, null);
+    if (cached?.privateGateway === true
+        && normalizedGatewayBaseUrl(cached.gateway_base_url) === gatewayBaseUrl
+        && Array.isArray(cached.models) && cached.models.length) {
+      await privateWrite(catalogPath, `${JSON.stringify({ models: cached.models }, null, 2)}\n`);
+      console.error(
+        `PennyRouter: could not refresh Codex models from ${config.gateway_base_url} `
+        + `(${error.message}). Using the private catalog cached ${cached.fetched_at}.`,
+      );
+      return { models: cached.models, privateGateway: true, modelCatalogPath: catalogPath };
+    }
+    console.error(
+      `PennyRouter: could not load Codex models from ${config.gateway_base_url} `
+      + `(${error.message}). Codex will use its normal model catalog.`,
+    );
+    return { models: [], privateGateway: false, modelCatalogPath: null };
+  }
+}
+
 async function writeClaudeUserSkill() {
   const path = claudeUserSkillPath();
   const existing = await readText(path, "");
@@ -879,7 +991,31 @@ async function writeClaudeUserSkill() {
   }
 }
 
-async function writeCodexLaunchProfile({ gatewayBaseUrl, subscriptionAuth, profile, privateGateway = false }) {
+function rootTomlString(text, key) {
+  const root = String(text || "").split(/^\s*\[/m, 1)[0];
+  const match = root.match(new RegExp(`^\\s*${key}\\s*=\\s*("(?:[^"\\\\]|\\\\.)*")`, "m"));
+  if (!match) return null;
+  try {
+    return JSON.parse(match[1]);
+  } catch {
+    return null;
+  }
+}
+
+export function selectCodexLaunchModel(models, ...candidates) {
+  const slugs = models.map((item) => item?.slug).filter(Boolean);
+  const allowed = new Set(slugs);
+  return candidates.find((candidate) => allowed.has(candidate)) || slugs[0] || null;
+}
+
+async function writeCodexLaunchProfile({
+  gatewayBaseUrl,
+  subscriptionAuth,
+  profile,
+  privateGateway = false,
+  models = [],
+  modelCatalogPath = null,
+}) {
   const path = codexLaunchProfilePath(profile);
   const existing = await readText(path, "");
   if (existing.trim() && !existing.startsWith(CODEX_PROFILE_MARKER)) {
@@ -887,7 +1023,21 @@ async function writeCodexLaunchProfile({ gatewayBaseUrl, subscriptionAuth, profi
       `${path} already exists and is not managed by PennyRouter. Rename it before installing.`,
     );
   }
-  await privateWrite(path, renderCodexLaunchProfile({ gatewayBaseUrl, subscriptionAuth, privateGateway }));
+  const native = await readText(join(dirname(path), "config.toml"), "");
+  const model = privateGateway
+    ? selectCodexLaunchModel(
+        models,
+        rootTomlString(existing, "model"),
+        rootTomlString(native, "model"),
+      )
+    : null;
+  await privateWrite(path, renderCodexLaunchProfile({
+    gatewayBaseUrl,
+    subscriptionAuth,
+    privateGateway,
+    modelCatalogPath,
+    model,
+  }));
 }
 
 export async function configurePennyHarness(harness, {
@@ -1298,22 +1448,31 @@ export async function runPenny(argv = process.argv.slice(2)) {
   if (harness === "codex") {
     // Re-render on every launch so an upgraded Penny command moves existing subscription
     // profiles onto Codex's built-in OpenAI provider without requiring a reinstall. Profiles
-    // using API/proxy/OpenRouter funding retain the custom HTTP provider for now.
+    // using API/proxy/OpenRouter funding retain the custom HTTP provider for now. Only a
+    // gateway that explicitly identifies itself as private may replace Codex's built-in catalog.
+    const catalog = await resolveCodexLaunchCatalog(config);
     await writeCodexLaunchProfile({
       gatewayBaseUrl: config.gateway_base_url,
       subscriptionAuth: resolveSubscriptionAuth(config, "codex"),
       profile: config.profile,
+      privateGateway: catalog.privateGateway,
+      models: catalog.models,
+      modelCatalogPath: catalog.modelCatalogPath,
     });
   }
+  let models = null;
   if (harness === "claude") {
     // Refresh on every launch so profile selection is honored immediately,
     // including --private, --cloud, and named profiles.
+    const catalog = await resolveClaudeCodeLaunchModels(config);
     await writeClaudeLaunchSettings({
       gatewayBaseUrl: config.gateway_base_url,
       apiKey: config.api_key,
+      models: catalog.models,
+      privateGateway: catalog.privateGateway,
     });
   }
-  const models = harness === "opencode" ? await resolveOpenCodeLaunchModels(config) : null;
+  if (harness === "opencode") models = await resolveOpenCodeLaunchModels(config);
   const invocation = buildPennyInvocation(harness, argv.slice(1), config, models);
   const child = spawn(invocation.command, invocation.args, {
     cwd: process.cwd(),

package/src/launch.test.js

@@ -11,6 +11,7 @@ import {
   claudeLaunchSettingsPath,
   claudeUserSkillPath,
   codexLaunchProfilePath,
+  codexModelCatalogPath,
   configureClaudeDesktopProfile,
   createCodexDesktopHome,
   configurePennyHarness,
@@ -31,8 +32,11 @@ import {
   restoreClaudeDesktopProfile,
   selectClaudeDesktopNativeMode,
   renderCodexLaunchProfile,
+  selectCodexLaunchModel,
   extractProfileArgs,
+  resolveCodexLaunchCatalog,
   resolveOpenCodeLaunchModels,
+  writeClaudeLaunchSettings,
   buildOpenCodeSessionConfig,
   resolvePennyProfile,
   setPennyProfile,
@@ -137,6 +141,37 @@ async function main() {
       ANTHROPIC_AUTH_TOKEN: "pr-super-secret",
       ANTHROPIC_API_KEY: "",
     });
+    await writeClaudeLaunchSettings({
+      gatewayBaseUrl: "https://gateway.example/",
+      apiKey: "pr-super-secret",
+      models: [
+        { model: "claude-fable-5-1", label: "Fable 5.1" },
+        { model: "claude-opus-4.8" },
+      ],
+    });
+    const hostedClaudeSettings = JSON.parse(
+      fs.readFileSync(claudeLaunchSettingsPath(), "utf8"),
+    );
+    assert.equal(hostedClaudeSettings.modelPicker, undefined);
+    await writeClaudeLaunchSettings({
+      gatewayBaseUrl: "https://gateway.example/",
+      apiKey: "pr-super-secret",
+      privateGateway: true,
+      models: [
+        { model: "claude-fable-5-1", label: "Fable 5.1" },
+        { model: "claude-opus-4.8" },
+      ],
+    });
+    const curatedClaudeSettings = JSON.parse(
+      fs.readFileSync(claudeLaunchSettingsPath(), "utf8"),
+    );
+    assert.deepEqual(curatedClaudeSettings.modelPicker, {
+      options: [
+        { model: "claude-fable-5-1", label: "Fable 5.1" },
+        { model: "claude-opus-4.8" },
+      ],
+      replaceBuiltInOptions: true,
+    });
     assert.equal(fs.readFileSync(path.join(home, ".codex", "config.toml"), "utf8"), nativeCodex);
     assert.equal(await fileMode(pennyConfigPath()), 0o600);
     assert.equal(await fileMode(claudeLaunchSettingsPath()), 0o600);
@@ -324,10 +359,86 @@ async function main() {
     });
     assert.ok(localSubscription.includes('model_provider = "openai"'));
     const localPrivate = renderCodexLaunchProfile({
-      gatewayBaseUrl: "http://localhost:8400", subscriptionAuth: true, privateGateway: true,
+      gatewayBaseUrl: "http://localhost:8400",
+      subscriptionAuth: true,
+      privateGateway: true,
+      modelCatalogPath: "/tmp/private-models.json",
+      model: "gpt-5.6-terra",
     });
     assert.ok(localPrivate.includes('model_provider = "pennyrouter"'));
     assert.ok(localPrivate.includes('env_key = "PENNYROUTER_API_KEY"'));
+    assert.ok(localPrivate.includes('model = "gpt-5.6-terra"'));
+    assert.ok(localPrivate.includes('model_catalog_json = "/tmp/private-models.json"'));
+    assert.ok(!paid.includes("model_catalog_json"));
+    assert.equal(
+      selectCodexLaunchModel(
+        [{ slug: "gpt-5.6-sol" }, { slug: "gpt-5.6-terra" }],
+        "gpt-6-luna",
+        "gpt-5.6-terra",
+      ),
+      "gpt-5.6-terra",
+    );
+    assert.ok(codexModelCatalogPath("private").endsWith("codex-models-private.json"));
+
+    const originalFetch = globalThis.fetch;
+    try {
+      globalThis.fetch = async () => ({
+        ok: true,
+        status: 200,
+        headers: { get: (name) => name === "x-pennyrouter-private-gateway" ? "1" : null },
+        json: async () => ({ models: [{ slug: "gpt-5.6-terra", display_name: "Terra" }] }),
+      });
+      const privateCatalog = await resolveCodexLaunchCatalog({
+        gateway_base_url: "https://private.example",
+        api_key: "pr-private",
+        profile: "private",
+      });
+      assert.equal(privateCatalog.privateGateway, true);
+      assert.deepEqual(
+        JSON.parse(fs.readFileSync(privateCatalog.modelCatalogPath, "utf8")),
+        { models: [{ slug: "gpt-5.6-terra", display_name: "Terra" }] },
+      );
+
+      globalThis.fetch = async () => { throw new Error("offline"); };
+      const cachedCatalog = await resolveCodexLaunchCatalog({
+        gateway_base_url: "https://private.example/",
+        api_key: "pr-private",
+        profile: "private",
+      });
+      assert.equal(cachedCatalog.privateGateway, true);
+
+      globalThis.fetch = async () => ({
+        ok: true,
+        status: 200,
+        headers: { get: () => null },
+        json: async () => ({ models: [{ slug: "gpt-6-luna" }] }),
+      });
+      const unmarkedCatalog = await resolveCodexLaunchCatalog({
+        gateway_base_url: "https://private.example",
+        api_key: "pr-private",
+        profile: "private",
+      });
+      assert.equal(unmarkedCatalog.privateGateway, false);
+      assert.equal(unmarkedCatalog.modelCatalogPath, null);
+
+      globalThis.fetch = async () => { throw new Error("offline"); };
+      const invalidatedCache = await resolveCodexLaunchCatalog({
+        gateway_base_url: "https://private.example",
+        api_key: "pr-private",
+        profile: "private",
+      });
+      assert.equal(invalidatedCache.privateGateway, false);
+
+      const wrongGateway = await resolveCodexLaunchCatalog({
+        gateway_base_url: "https://other.example",
+        api_key: "pr-private",
+        profile: "private",
+      });
+      assert.equal(wrongGateway.privateGateway, false);
+      assert.equal(wrongGateway.modelCatalogPath, null);
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
 
     // Inside the fixture: testProfiles persists a config, which must land in the
     // temporary HOME and never in the developer's real ~/.config/pennyrouter.