fix(codex): preserve Daybreak access programs in native catalog

docs-site/src/content/docs/guides/codex-integration.md

@@ -15,6 +15,11 @@ file, removes OpenCodex's generated routing artifacts, and leaves the proxy runn
 clients. Re-enabling rebuilds the catalog from the models available at that time, so it does not
 restore the Codex files byte for byte.
 
+For bare native Codex models and OpenCodex-generated account-selector rows, the catalog carries
+authenticated access program metadata. Bare models use the main Codex account; account-qualified
+models use their selected account. Refreshing the integration updates these rows when upstream
+changes the account's access programs.
+
 The proxy exposes one bare `openai` Codex-login route with Pool(default) and Direct account modes,
 plus `openai-apikey/<model>` for the configured API key. Pool includes main plus added accounts;
 Direct uses only the caller/main bearer. The routes do not fall back to one another. Shipped v1

scripts/test-layout/layout.json

@@ -612,6 +612,7 @@
     "codex-cli-update-launcher-policy.test.ts": "codex-integration",
     "codex-cli-update-zero-effect.test.ts": "codex-integration",
     "codex-cli-windows-installation-files.test.ts": "codex-integration",
+    "codex-forward-access-programs-writer.test.ts": "codex-integration",
     "codex-composed-acceptance.test.ts": "codex-integration",
     "codex-config-generation.test.ts": "codex-integration",
     "codex-context-owner.test.ts": "codex-integration",
@@ -667,6 +668,7 @@
     "codex-model-availability-error.test.ts": "codex-integration",
     "codex-model-denial-evidence.test.ts": "codex-integration",
     "codex-model-entitlement-admission.test.ts": "codex-integration",
+    "codex-model-entitlements-program-shape.test.ts": "codex-integration",
     "codex-model-entitlements.test.ts": "codex-integration",
     "codex-models-cache-invalidate.test.ts": "codex-integration",
     "codex-native-residue.test.ts": "codex-integration",

src/codex/catalog/access-programs.ts

@@ -0,0 +1,50 @@
+import { isMainCodexAccountTarget } from "../account-namespaces";
+import { COMBO_NAMESPACE } from "../../combos";
+import { MAIN_CODEX_ACCOUNT_ID } from "../main-account";
+import type { CodexModelEntitlementSnapshot } from "../model-entitlements";
+import { trustedAccountBoundNativeCatalogSlug } from "./account-models";
+import { isNativeAliasCatalogEntry, SUPPORTED_NATIVE_OPENAI_SLUGS } from "./metadata";
+import type { RawEntry } from "./parsing";
+
+/** Project authenticated account metadata onto native rows only. */
+export function applyNativeAccessPrograms(
+  entries: RawEntry[],
+  snapshot: CodexModelEntitlementSnapshot,
+  accountTargets: ReadonlyMap<string, string>,
+): void {
+  for (const entry of entries) {
+    // A combo may deliberately claim a bare native slug. It is still a routed combo row,
+    // so the matching native Codex roster must not project its access programs onto it.
+    if (isNativeAliasCatalogEntry(entry)) continue;
+    if (entry.owned_by === COMBO_NAMESPACE) {
+      delete entry.available_access_programs;
+      continue;
+    }
+    const accountBoundSlug = trustedAccountBoundNativeCatalogSlug(entry);
+    const bareSlug = typeof entry.slug === "string" && !entry.slug.includes("/")
+      && SUPPORTED_NATIVE_OPENAI_SLUGS.has(entry.slug) ? entry.slug : undefined;
+    const slug = accountBoundSlug ?? bareSlug;
+    if (!slug) continue;
+    const selector = accountBoundSlug && typeof entry.slug === "string"
+      ? entry.slug.slice(0, entry.slug.indexOf("/")) : undefined;
+    const target = selector === undefined ? MAIN_CODEX_ACCOUNT_ID : accountTargets.get(selector);
+    const accountId = target && isMainCodexAccountTarget(target) ? MAIN_CODEX_ACCOUNT_ID : target;
+    if (!accountId) {
+      delete entry.available_access_programs;
+      continue;
+    }
+    // An old on-disk catalog can contain metadata from a previous credential. Until this
+    // account has a confirmed roster, that value is no longer evidence of a grant.
+    if (!snapshot.confirmedAccountIds.has(accountId)
+      || !snapshot.modelsByAccount.get(accountId)?.has(slug)) {
+      delete entry.available_access_programs;
+      continue;
+    }
+    const accountPrograms = snapshot.accessProgramsByAccount?.get(accountId);
+    if (accountPrograms?.has(slug)) {
+      entry.available_access_programs = accountPrograms.get(slug) ?? null;
+    } else {
+      delete entry.available_access_programs;
+    }
+  }
+}

src/codex/catalog/build-entries.ts

@@ -865,9 +865,22 @@ export function mergeCatalogEntriesFromObservedState({
     const normalized = reserveProjection ? m : normalizeServiceTiers(m);
     if (!reserveProjection && !isNativeAliasCatalogEntry(normalized)) applyNativeOpenAiContextOverride(normalized, openaiContextCap);
     const exactCombo = isExactComboCatalogEntry(m, exactComboSlugs);
+    // The builder copied this metadata from the pinned first-party row only for an exact
+    // ChatGPT/Codex forward custom alias. Freshness plus source equality prevents an old or
+    // unrelated routed row from claiming the native account's access programs at this second
+    // normalization boundary.
+    const nativeSourceSlug = typeof m.slug === "string" && m.slug.startsWith("openai/")
+      ? m.slug.slice("openai/".length) : undefined;
+    const nativeSource = nativeSourceSlug ? upstreamNativeEntry(nativeSourceSlug) : undefined;
+    const preserveNativeAccessPrograms = freshCustomEntries.has(m)
+      && m.owned_by !== COMBO_NAMESPACE
+      && nativeSource != null
+      && Object.hasOwn(nativeSource, "available_access_programs")
+      && JSON.stringify(m.available_access_programs) === JSON.stringify(nativeSource.available_access_programs);
     const e = reserveProjection ? normalized : ensureStrictCatalogFields(normalized, {
       preserveExactInputModalities: exactCombo,
       isRouted: finalRoutedEntrySet.has(m),
+      preserveNativeAccessPrograms,
     });
     // Mock-max universality (260709): preserved routed entries from disk may predate
     // the max rung — ensure it here so subagent max spawns validate on every

src/codex/catalog/derive-entry.ts

@@ -195,6 +195,7 @@ export function deriveEntry(
     return ensureStrictCatalogFields(normalizeServiceTiers(e), {
       preserveExactInputModalities: preserveExact,
       isRouted,
+      preserveNativeAccessPrograms: codexForwardNativeCapabilityAlias !== null,
     });
   }
   // Fallback when no template is available (best-effort; strict parser may need more).

src/codex/catalog/parsing.ts

@@ -582,9 +582,10 @@ export function applyNativeOpenAiContextOverride(entry: RawEntry, limits?: Nativ
   }
 }
 
+/** Normalize a row for Codex's catalog parser, stripping native eligibility from routed rows unless explicitly preserved. */
 export function ensureStrictCatalogFields(
   entry: RawEntry,
-  options: { preserveExactInputModalities?: boolean; isRouted?: boolean } = {},
+  options: { preserveExactInputModalities?: boolean; isRouted?: boolean; preserveNativeAccessPrograms?: boolean } = {},
 ): RawEntry {
   if (entry.shell_type === "default" || entry.shell_type === "local" || entry.shell_type === "shell_command") {
     entry.shell_type = "unified_exec";
@@ -634,7 +635,7 @@ export function ensureStrictCatalogFields(
   if (typeof entry.effective_context_window_percent !== "number") entry.effective_context_window_percent = 95;
   if (typeof entry.comp_hash !== "string") entry.comp_hash = "opencodex";
   // Routed rows must not carry NATIVE eligibility metadata. `deriveEntry` deep-clones a
-  // native template and deletes a fixed denylist, so these five survive onto rows backed
+  // native template and deletes a fixed denylist, so these eligibility fields survive onto rows backed
   // by unrelated provider credentials — advertising ChatGPT plan eligibility for a model
   // that never touches a ChatGPT account (#2813).
   //
@@ -644,6 +645,9 @@ export function ensureStrictCatalogFields(
   // leave already-contaminated rows contaminated forever.
   if (options.isRouted === true) {
     entry.supported_in_api = true;
+    // Exact Codex-forward aliases still use a ChatGPT credential and may retain their native
+    // source metadata. Other routed rows cannot claim that account's access programs.
+    if (!options.preserveNativeAccessPrograms) delete entry.available_access_programs;
     delete entry.available_in_plans;
     delete entry.minimal_client_version;
     delete entry.availability_nux;

src/codex/catalog/retained-sync.ts

@@ -12,6 +12,7 @@ import { providerCodexAccountMode } from "../../providers/registry";
 import { COMBO_NAMESPACE } from "../../combos";
 import { codexAccountNamespaceEntries, isMainCodexAccountTarget } from "../account-namespaces";
 import { MAIN_CODEX_ACCOUNT_ID } from "../main-account";
+import { applyNativeAccessPrograms } from "./access-programs";
 import {
   availableAccountGatedNativeModels,
   codexModelEntitlementStateForAccount,
@@ -266,6 +267,7 @@ function catalogModelsForMergeWithNativeRecovery(
   ]);
 }
 
+/** Merge retained rows, project confirmed account metadata, and publish only changed catalog bytes. */
 function writeRetainedCatalogSync({
   config,
   goModels,
@@ -526,6 +528,7 @@ function writeRetainedCatalogSync({
       warningPolicy: "emit",
     },
   });
+  applyNativeAccessPrograms(catalog.models, modelEntitlements, accountTargets);
   clampCatalogModelsToCodexSupport(catalog.models);
   finalizeAutoReviewModelOverride(catalog.models, catalogModelsForMerge, config);
   // Last mutation before serialization; see `enforceCatalogSlugUniqueness` for why the ordering

src/codex/convergence.ts

@@ -74,6 +74,7 @@ import { suppressedSyntheticMaxCatalogSlugs } from "./catalog/model-hints";
 import { codexRuntimeStatePath, peekCodexRuntimeProcessCache } from "./runtime";
 import { codexAccountNamespaceEntries, isMainCodexAccountTarget } from "./account-namespaces";
 import { MAIN_CODEX_ACCOUNT_ID } from "./main-account";
+import { applyNativeAccessPrograms } from "./catalog/access-programs";
 import {
   availableAccountGatedNativeModels,
   codexModelEntitlementStateForAccount,
@@ -384,6 +385,7 @@ function prepareCatalog(
       warningPolicy: "suppress",
     },
   });
+  applyNativeAccessPrograms(mergedModels, modelEntitlements, accountTargets);
   clampCatalogModelsToObservedCodexSupport(
     mergedModels,
     source.runtimeSupport.kind === "available"

src/codex/model-entitlements.ts

@@ -407,17 +407,21 @@ interface CachedAccountModels {
   readonly clientVersion: string;
   readonly expiresAt: number;
   readonly models: ReadonlySet<string>;
+  readonly accessProgramsByModel?: ReadonlyMap<string, CodexAvailableAccessPrograms>;
   readonly confirmed: boolean;
   readonly provenance?: CodexModelEntitlementProvenance;
 }
 
 export interface CodexModelEntitlementSnapshot {
   readonly modelsByAccount: ReadonlyMap<string, ReadonlySet<string>>;
+  readonly accessProgramsByAccount?: ReadonlyMap<string, ReadonlyMap<string, CodexAvailableAccessPrograms>>;
   readonly clientVersionByAccount: ReadonlyMap<string, string>;
   readonly confirmedAccountIds: ReadonlySet<string>;
   readonly credentialIdentities: ReadonlyMap<string, string>;
 }
 
+export type CodexAvailableAccessPrograms = Readonly<Record<string, readonly string[]>> | null;
+
 export type CodexModelEntitlementState = "granted" | "denied" | "unknown";
 
 export interface CodexModelEntitlementResolveOptions {
@@ -633,17 +637,28 @@ async function accountCredentialSnapshot(
   }
 }
 
-function parseAccountModels(text: string): ReadonlySet<string> | null {
+/** Keep valid roster slugs while dropping malformed program metadata; preserve explicit null separately from absence. */
+function parseAccountModels(text: string): { models: ReadonlySet<string>; accessProgramsByModel: ReadonlyMap<string, CodexAvailableAccessPrograms> } | null {
   try {
     const payload = JSON.parse(text) as { models?: unknown };
     if (!Array.isArray(payload.models)) return null;
+    const accessProgramsByModel = new Map<string, CodexAvailableAccessPrograms>();
     const models = payload.models.flatMap(entry => {
       if (!entry || typeof entry !== "object" || Array.isArray(entry)) return [];
-      const row = entry as { slug?: unknown; supported_in_api?: unknown; visibility?: unknown };
+      const row = entry as { slug?: unknown; supported_in_api?: unknown; visibility?: unknown; available_access_programs?: unknown };
       if (typeof row.slug !== "string" || row.supported_in_api !== true || row.visibility === "hide") return [];
+      const programs = row.available_access_programs;
+      if (programs === null) accessProgramsByModel.set(row.slug, null);
+      else if (programs && typeof programs === "object" && !Array.isArray(programs)) {
+        const record = programs as Record<string, unknown>;
+        if (Array.isArray(record.cyber) && record.cyber.every(item => typeof item === "string")
+          && Object.values(record).every(value => Array.isArray(value) && value.every(item => typeof item === "string"))) {
+          accessProgramsByModel.set(row.slug, record as Record<string, string[]>);
+        }
+      }
       return [row.slug];
     });
-    return new Set(models);
+    return { models: new Set(models), accessProgramsByModel };
   } catch {
     return null;
   }
@@ -669,6 +684,7 @@ function isTimeoutError(error: unknown): boolean {
   return error instanceof Error && error.name === "TimeoutError";
 }
 
+/** Fetch one bounded, version-scoped roster; failures and empty results remain unconfirmed for a short retry. */
 async function fetchAccountModels(
   credential: CodexModelEntitlementCredentialSnapshot,
   fetcher: typeof fetch,
@@ -702,8 +718,8 @@ async function fetchAccountModels(
     if (!body.displaySafe || body.truncated) {
       return unconfirmedAccountModels(credential, clientVersion, now, { kind: "unparseable" });
     }
-    const models = parseAccountModels(body.text);
-    if (models === null) {
+    const parsed = parseAccountModels(body.text);
+    if (parsed === null) {
       return unconfirmedAccountModels(credential, clientVersion, now, { kind: "unparseable" });
     }
     // A roster is a confirmation only when it lists something usable. `models` is a Set, and an
@@ -713,6 +729,7 @@ async function fetchAccountModels(
     // account asked under too old a client version answers with no gated rows, and treating
     // that as authoritative is exactly how 2.36.0 denied sol/terra/luna to accounts that own
     // them (#3022). No usable rows means unconfirmed, on the 15s failure TTL, asked again.
+    const { models, accessProgramsByModel } = parsed;
     const usable = models.size > 0;
     if (!usable) {
       return unconfirmedAccountModels(credential, clientVersion, now, { kind: "parsed-empty" });
@@ -735,6 +752,7 @@ async function fetchAccountModels(
         ? MODEL_ROSTER_TTL_MS
         : MODEL_ROSTER_FAILURE_TTL_MS),
       models,
+      accessProgramsByModel,
       confirmed: true,
     };
   } catch (error) {
@@ -1173,6 +1191,10 @@ export async function resolveCodexModelEntitlements(
   })));
   return {
     modelsByAccount: new Map(results.map(({ credential, result }) => [credential.accountId, result.models])),
+    accessProgramsByAccount: new Map(results.flatMap(({ credential, result }) => (
+      result.confirmed && result.accessProgramsByModel
+        ? [[credential.accountId, result.accessProgramsByModel] as const] : []
+    ))),
     clientVersionByAccount: new Map(results.map(({ credential, result }) => (
       [credential.accountId, result.clientVersion]
     ))),

structure/catalog.md

@@ -158,12 +158,12 @@ before registration. Covered by `tests/codex-integration/configured-native-model
 Retirement is a catalog/evidence policy, not a universal request denylist. Manually supplied
 model ids still follow generic routing. User-selected config and historical usage remain stored.
 
-Account-gated native ids are a stricter subset. Their authenticated ChatGPT `/models` roster is
-cached per credential generation with a bounded timeout. A bare gated row is emitted only when at
-least one confirmed eligible account reports it; a selector-qualified row is emitted only when the
-mapped account reports it. A failed or malformed discovery is not positive evidence and therefore
-hides the gated row until a later refresh. The same snapshot gates Pool selection, so the catalog
-and runtime cannot disagree by advertising through one account and dispatching through another.
+Account-gated native ids use authenticated ChatGPT `/models` rosters cached per credential generation with a bounded timeout.
+A bare gated row requires a confirmed eligible account; a selector-qualified row requires its mapped account. Failed discovery
+grants neither. The same snapshot gates Pool selection, so catalog and runtime use consistent account evidence.
+The roster's per-model `available_access_programs` is projected separately: bare native rows use only confirmed main-account
+metadata, and selector-qualified rows use only their mapped account. Explicit `null` stays null; omission stays omitted.
+Failed discovery or credential replacement removes stale access-program metadata. It changes presentation, not routing grants.
 
 `client_version` arrives on the inbound request and is part of that cache identity, so
 `src/codex/model-entitlements.ts` bounds the work as well as the state: stored versions per account, concurrent

tests/codex-integration/codex-convergence-account-selectors.test.ts

@@ -66,6 +66,7 @@ let previousOpencodexHome: string | undefined;
 let previousCodexCliPath: string | undefined;
 let previousFetch: typeof fetch;
 let modelRostersByChatgptAccount: Map<string, readonly string[]>;
+let modelAccessProgramsByChatgptAccount: Map<string, ReadonlyMap<string, unknown>>;
 
 const GPT56_NATIVE_MODELS = ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"] as const;
 
@@ -307,6 +308,7 @@ beforeEach(() => {
   process.env.OPENCODEX_HOME = opencodexHome;
   previousFetch = globalThis.fetch;
   modelRostersByChatgptAccount = new Map();
+  modelAccessProgramsByChatgptAccount = new Map();
   writeFileSync(join(codexHome, "auth.json"), JSON.stringify({
     tokens: { access_token: "main-token", account_id: "main-chatgpt-account" },
   }));
@@ -325,6 +327,9 @@ beforeEach(() => {
           slug,
           supported_in_api: true,
           visibility: "list",
+          ...(modelAccessProgramsByChatgptAccount.get(accountId)?.has(slug)
+            ? { available_access_programs: modelAccessProgramsByChatgptAccount.get(accountId)!.get(slug) }
+            : {}),
         })),
       });
     }
@@ -335,6 +340,25 @@ beforeEach(() => {
   resetCodexModelEntitlementCacheForTests();
 });
 
+test.each(["convergence", "retained"] as const)("%s writes account-specific access programs into the serialized catalog", async writer => {
+  primeCodexRuntimeFixture();
+  writeCatalog([nativeEntry()]);
+  grantGpt56NativeModels("main-chatgpt-account", "side-chatgpt-account");
+  const mainPrograms = { cyber: ["standard", "daybreak_blue"] };
+  const sidePrograms = { cyber: ["standard"] };
+  modelAccessProgramsByChatgptAccount.set("main-chatgpt-account", new Map([["gpt-5.6-sol", mainPrograms]]));
+  modelAccessProgramsByChatgptAccount.set("side-chatgpt-account", new Map([["gpt-5.6-sol", sidePrograms]]));
+  const next = config(true);
+  const catalog = writer === "convergence"
+    ? await convergeCatalog(next)
+    : (await syncCatalogModels(next), JSON.parse(readFileSync(catalogPath, "utf8")) as RawCatalog);
+  const rows = catalog.models ?? [];
+  expect(rows.find(row => row.slug === "gpt-5.6-sol")?.available_access_programs).toEqual(mainPrograms);
+  expect(rows.find(row => row.slug === "desktop/gpt-5.6-sol")?.available_access_programs).toEqual(mainPrograms);
+  expect(rows.find(row => row.slug === "team/gpt-5.6-sol")?.available_access_programs).toEqual(sidePrograms);
+  expect(JSON.parse(readFileSync(catalogPath, "utf8")).models).toEqual(rows);
+});
+
 afterEach(() => {
   globalThis.fetch = previousFetch;
   const identity = resolveEffectiveUserIdentity();