@bitkyc08/opencodex 2.14.0 → 2.14.2

package/src/cli/init.ts

@@ -1,7 +1,7 @@
 import * as readline from "node:readline";
-import { constants as fsConstants, copyFileSync, existsSync, readFileSync, unlinkSync } from "node:fs";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { injectCodexConfig } from "../codex/inject";
-import { classifyOpenAiTierBackup, getConfigPath, getDefaultConfig, isValidProviderName, saveConfig } from "../config";
+import { classifyOpenAiTierBackup, getConfigPath, getDefaultConfig, isValidProviderName, preserveOpenAiTierRollbackSnapshot, saveConfig } from "../config";
 import { enrichProviderFromCatalog } from "../oauth/key-providers";
 import { deriveInitProviders } from "../providers/derive";
 import type { OcxConfig, OcxProviderConfig } from "../types";
@@ -80,21 +80,8 @@ export function cleanupOpenAiTierBackupAfterInit(configPath = getConfigPath()):
       unlinkSync(backup);
       return;
     }
-    // Publish the preserved snapshot with a no-replace copy (COPYFILE_EXCL) so a
-    // destination collision (frozen/rolled-back clock, pre-created file) can never
-    // silently overwrite another rollback snapshot; retry with a sequence suffix.
-    for (let attempt = 0; attempt < 16; attempt++) {
-      const preserved = `${configPath}.pre-openai-tiers-v1-rollback.${Date.now()}${attempt ? `-${attempt}` : ""}.bak`;
-      try {
-        copyFileSync(backup, preserved, fsConstants.COPYFILE_EXCL);
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException).code === "EEXIST") continue;
-        throw error;
-      }
-      unlinkSync(backup);
-      console.warn(`⚠️  Kept your pre-migration config rollback snapshot at ${preserved}`);
-      return;
-    }
+    const preserved = preserveOpenAiTierRollbackSnapshot(configPath);
+    console.warn(`⚠️  Kept your pre-migration config rollback snapshot at ${preserved}`);
   } catch { /* cleanup is best-effort; never block init on backup housekeeping */ }
 }
 

package/src/codex/auth-api.ts

@@ -82,7 +82,7 @@ export {
   setAccountQuotaFromParsed,
   updateAccountQuota,
 } from "./quota";
-import { extractAccountId, decodeJwtPayload } from "../oauth/chatgpt";
+import { extractAccountId } from "../oauth/chatgpt";
 import { getMainAccountPlan, MAIN_CODEX_ACCOUNT_ID, setMainAccountPlan } from "./main-account";
 import { captureConfigGeneration, registerStateSweepAfterTick } from "../lib/state-store-sweeper";
 import { reconcileLiveStateStores } from "../lib/state-store-registrations";
@@ -147,7 +147,6 @@ function nativeMainProfileBusyResponse(): Response {
   return response;
 }
 
-const MANUAL_IMPORT_ENV = "OPENCODEX_ENABLE_UNVERIFIED_CODEX_IMPORT";
 const CODEX_CREDENTIAL_PERSISTENCE_ERROR = "Account was saved, but credential setup did not complete. Reauthenticate or remove the account.";
 const CODEX_CREDENTIAL_PERSISTENCE_CODE = "codex_credential_persistence_failed";
 
@@ -375,10 +374,6 @@ async function readResetCreditJson(
   }
 }
 
-export function isUnverifiedCodexImportEnabled(): boolean {
-  return process.env[MANUAL_IMPORT_ENV] === "1";
-}
-
 function manualImportDisabledResponse(): Response {
   return jsonResponse({
     error: "Manual Codex account import is disabled. Use OAuth login to add a pool account.",
@@ -1368,74 +1363,7 @@ export async function handleCodexAuthAPI(
   }
 
   if (url.pathname === "/api/codex-auth/accounts" && req.method === "POST") {
-    if (!isUnverifiedCodexImportEnabled()) return manualImportDisabledResponse();
-
-    let body: { id: string; email: string; plan?: unknown; accessToken: string; refreshToken: string; chatgptAccountId: string };
-    try { body = (await req.json()) as typeof body; } catch { return jsonResponse({ error: "Invalid JSON" }, 400); }
-    if (!body.id || !body.email || !body.accessToken || !body.refreshToken || !body.chatgptAccountId) {
-      return jsonResponse({ error: "Missing required fields" }, 400);
-    }
-    if (!isValidCodexAccountId(body.id)) {
-      return jsonResponse({ error: "Invalid account id format" }, 400);
-    }
-    if (body.accessToken.length > 10_000 || body.refreshToken.length > 10_000) {
-      return jsonResponse({ error: "Input too large" }, 400);
-    }
-    const runtimeConfig = getRuntimeConfig(config);
-    const preflightConflict = codexAccountPersistenceConflict(runtimeConfig, body.id, "create");
-    if (preflightConflict) return jsonResponse({ error: preflightConflict }, 400);
-    // 1.1: Duplicate check is scoped by personal vs workspace plan bucket.
-    const plan = codexPlanValue(body.plan);
-    const derivedAccountId = extractAccountId(undefined, body.accessToken) ?? body.chatgptAccountId;
-    const collision = checkAccountIdCollision(derivedAccountId, body.email, plan);
-    if (collision.collision) {
-      return jsonResponse({ error: collision.reason }, 400);
-    }
-    // 4.2: use JWT exp for expiresAt instead of hardcoded 1 hour
-    const payload = decodeJwtPayload(body.accessToken);
-    const exp = typeof payload?.exp === "number" ? payload.exp * 1000 : Date.now() + 3600_000;
-    const warmup = await verifyCodexAccountWarmup(body.id, body.accessToken, derivedAccountId);
-    if (!warmup.ok) return warmup.response;
-    const latestConfig = getRuntimeConfig(config);
-    const commitConflict = codexAccountPersistenceConflict(latestConfig, body.id, "create");
-    if (commitConflict) return jsonResponse({ error: commitConflict }, 400);
-    const addedAccount = withCodexAccountLogLabel(
-      {
-        id: body.id,
-        email: body.email,
-        ...(plan !== undefined ? { plan } : {}),
-        isMain: false,
-      },
-      latestConfig.codexAccounts ?? [],
-    );
-    const persistence = persistNewCodexAccount(
-      config,
-      latestConfig,
-      addedAccount,
-      {
-        credential: {
-          accessToken: body.accessToken,
-          refreshToken: body.refreshToken,
-          expiresAt: exp,
-          chatgptAccountId: derivedAccountId,
-        },
-        validatedAt: warmup.validatedAt,
-      },
-    );
-    reconcileLiveStateStores();
-    if (persistence.status === "publication-failed") markAccountNeedsReauth(body.id);
-    const catalogRefresh = await convergeAccountNamespaceCatalog(
-      latestConfig,
-      persistence.pickerVisibilityChanged,
-      convergeCodexCatalog,
-    );
-    if (persistence.status === "publication-failed") {
-      return jsonResponse({
-        ok: false,
-        ...codexCredentialPersistenceFailure(body.id, catalogRefresh.catalogRefreshPending === true),
-      }, 500);
-    }
-    return jsonResponse({ ok: true, ...catalogRefresh });
+    return manualImportDisabledResponse();
   }
 
   if (url.pathname === "/api/codex-auth/accounts" && req.method === "DELETE") {

package/src/codex/catalog/effort.ts

@@ -34,6 +34,7 @@ import upstreamModelsSnapshot from "../data/upstream-models.json";
 import { readCatalog, readCodexCatalogPath } from "./parsing";
 import type { CatalogModel, RawEntry } from "./parsing";
 import { UPSTREAM_NATIVE_ENTRIES } from "./metadata";
+import { nativeOpenAiCapabilitySourceSlug } from "./native-models";
 import { loadBundledCodexCatalog } from "./bundled";
 import type { BundledCatalogDeps, ReadonlyRawCatalog } from "./bundled";
 import { deriveEntry } from "./sync";
@@ -180,7 +181,7 @@ export function applyReasoningLevels(
 }
 
 export function isGpt56NativeSlug(slug: string): boolean {
-  return !slug.includes("/") && slug.startsWith("gpt-5.6-");
+  return !slug.includes("/") && nativeOpenAiCapabilitySourceSlug(slug).startsWith("gpt-5.6-");
 }
 
 export function ensureGpt56ReasoningLevels(entry: RawEntry): void {

package/src/codex/catalog/metadata.ts

@@ -15,7 +15,7 @@ import { enrichProviderFromRegistry, shouldCaseFoldMetadataModelId } from "../..
 import { getProviderRegistryEntry } from "../../providers/registry";
 import { applyProviderContextCap, providerContextCap } from "../../providers/context-cap";
 import { routedSlug, slugEquals, slugsEquivalent } from "../../providers/slug-codec";
-import { CODEX_GPT5_IDENTITY_LINE } from "../../adapters/identity";
+import { identifyRoutedModel } from "../../adapters/identity";
 import { filterCursorConfiguredModelsByLiveDiscovery } from "../../adapters/cursor/discovery";
 import { fetchCursorUsableModels } from "../../adapters/cursor/live-models";
 import { isCanonicalOpenAiForwardProvider, OPENAI_API_PROVIDER_ID, OPENAI_CODEX_PROVIDER_ID } from "../../providers/openai-tiers";
@@ -37,9 +37,23 @@ import type { RawEntry } from "./parsing";
 import { readCurrentCatalogOrCache, readCurrentCodexCatalog, readCurrentCodexModelsCache, unique } from "./bundled";
 import { trustedAccountBoundNativeCatalogSlug, visibleCodexAccountSelectors } from "./account-models";
 import { CODEX_NATIVE_ALIAS_CATALOG_KIND } from "./kinds";
-import { NATIVE_OPENAI_MODELS, SUPPORTED_NATIVE_OPENAI_SLUGS } from "./native-models";
+import {
+  NATIVE_DAYBREAK_BLUE_MODEL,
+  NATIVE_OPENAI_CAPABILITY_ALIAS_MODELS,
+  NATIVE_OPENAI_MODELS,
+  SUPPORTED_NATIVE_OPENAI_SLUGS,
+  isNativeOpenAiCapabilityAliasModel,
+  nativeOpenAiCapabilitySourceSlug,
+} from "./native-models";
 export { CODEX_NATIVE_ALIAS_CATALOG_KIND } from "./kinds";
-export { NATIVE_OPENAI_MODELS, SUPPORTED_NATIVE_OPENAI_SLUGS } from "./native-models";
+export {
+  NATIVE_DAYBREAK_BLUE_MODEL,
+  NATIVE_OPENAI_CAPABILITY_ALIAS_MODELS,
+  NATIVE_OPENAI_MODELS,
+  SUPPORTED_NATIVE_OPENAI_SLUGS,
+  isNativeOpenAiCapabilityAliasModel,
+  nativeOpenAiCapabilitySourceSlug,
+} from "./native-models";
 
 export const DOCUMENTED_NATIVE_OPENAI_ADDITIONS = [
   "gpt-5.3-codex-spark",
@@ -94,18 +108,28 @@ export const NATIVE_OPENAI_CONTEXT_OVERRIDES: Record<string, { contextWindow?: n
   "gpt-5.6-sol": { contextWindow: NATIVE_GPT56_CONTEXT_WINDOW, maxContextWindow: NATIVE_GPT56_CONTEXT_WINDOW },
   "gpt-5.6-terra": { contextWindow: NATIVE_GPT56_CONTEXT_WINDOW, maxContextWindow: NATIVE_GPT56_CONTEXT_WINDOW },
   "gpt-5.6-luna": { contextWindow: NATIVE_GPT56_CONTEXT_WINDOW, maxContextWindow: NATIVE_GPT56_CONTEXT_WINDOW },
+  [NATIVE_DAYBREAK_BLUE_MODEL]: { contextWindow: NATIVE_GPT56_CONTEXT_WINDOW, maxContextWindow: NATIVE_GPT56_CONTEXT_WINDOW },
 };
 
+const PINNED_UPSTREAM_MODELS: Map<string, RawEntry> = new Map(
+  ((upstreamModelsSnapshot as unknown as { models?: RawEntry[] }).models ?? [])
+    .flatMap(model => typeof model.slug === "string" ? [[model.slug, model] as const] : []),
+);
+
+function pinnedNativeCapabilityEntry(slug: string): RawEntry | undefined {
+  return PINNED_UPSTREAM_MODELS.get(nativeOpenAiCapabilitySourceSlug(slug));
+}
+
 /**
  * Pinned capability metadata is safe to use as a fallback for every supported native model.
  * Keep it separate from UPSTREAM_NATIVE_ENTRIES: that narrower map also authorizes replacing
  * persisted native rows during sync, which is currently intentional only for the GPT-5.6 family.
  */
 const PINNED_NATIVE_CAPABILITY_ENTRIES: Map<string, RawEntry> = new Map(
-  ((upstreamModelsSnapshot as unknown as { models?: RawEntry[] }).models ?? [])
-    .filter(m => typeof m.slug === "string"
-      && SUPPORTED_NATIVE_OPENAI_SLUGS.has(m.slug as string))
-    .map(m => [m.slug as string, m]),
+  [...NATIVE_OPENAI_MODELS, ...NATIVE_OPENAI_CAPABILITY_ALIAS_MODELS].flatMap(slug => {
+    const entry = pinnedNativeCapabilityEntry(slug);
+    return entry ? [[slug, entry] as const] : [];
+  }),
 );
 
 export function nativeOpenAiContextWindow(slug: string, contextCap?: number): number | undefined {
@@ -259,12 +283,38 @@ export function applyNativeVisibility(
   return entries;
 }
 
+function upstreamNativeEntryForSlug(slug: string): RawEntry | undefined {
+  const sourceSlug = nativeOpenAiCapabilitySourceSlug(slug);
+  if (!sourceSlug.startsWith("gpt-5.6-")) return undefined;
+  const source = PINNED_UPSTREAM_MODELS.get(sourceSlug);
+  if (!source) return undefined;
+  if (slug === sourceSlug) return source;
+
+  const alias = structuredClone(source) as RawEntry;
+  alias.slug = slug;
+  alias.display_name = "Daybreak Blue";
+  alias.description = "Frontier general-purpose model with safeguards for defensive cybersecurity work.";
+  if (typeof alias.base_instructions === "string") {
+    alias.base_instructions = identifyRoutedModel(alias.base_instructions, slug);
+  }
+  if (alias.model_messages && typeof alias.model_messages === "object" && !Array.isArray(alias.model_messages)) {
+    const modelMessages = alias.model_messages as Record<string, unknown>;
+    if (typeof modelMessages.instructions_template === "string") {
+      alias.model_messages = {
+        ...modelMessages,
+        instructions_template: identifyRoutedModel(modelMessages.instructions_template, slug),
+      };
+    }
+  }
+  delete alias.availability_nux;
+  return alias;
+}
+
 export const UPSTREAM_NATIVE_ENTRIES: Map<string, RawEntry> = new Map(
-  ((upstreamModelsSnapshot as unknown as { models?: RawEntry[] }).models ?? [])
-    .filter(m => typeof m.slug === "string"
-      && SUPPORTED_NATIVE_OPENAI_SLUGS.has(m.slug as string)
-      && (m.slug as string).startsWith("gpt-5.6-"))
-    .map(m => [m.slug as string, m]),
+  [...NATIVE_OPENAI_MODELS, ...NATIVE_OPENAI_CAPABILITY_ALIAS_MODELS].flatMap(slug => {
+    const entry = upstreamNativeEntryForSlug(slug);
+    return entry ? [[slug, entry] as const] : [];
+  }),
 );
 
 export function upstreamNativeEntry(slug: string): RawEntry | null {

package/src/codex/catalog/native-models.ts

@@ -1,3 +1,30 @@
+/** ChatGPT/Codex wire id observed for the account-native Daybreak Blue surface. */
+export const NATIVE_DAYBREAK_BLUE_MODEL = "gpt-daybreak-blue-latest";
+
+/**
+ * Account-native aliases whose Codex capabilities track another pinned native row.
+ *
+ * This is catalog metadata inheritance only. Routing always preserves the requested
+ * wire id, so the ChatGPT/Codex `gpt-daybreak-*` surface never collapses into the
+ * separately billed API-key `daybreak-*-latest` surface or into `gpt-5.6-sol`.
+ */
+const NATIVE_OPENAI_CAPABILITY_SOURCES: Readonly<Record<string, string>> = Object.freeze({
+  [NATIVE_DAYBREAK_BLUE_MODEL]: "gpt-5.6-sol",
+});
+
+/** Account-scoped native ids that may inherit metadata but never enter the bare allowlist. */
+export const NATIVE_OPENAI_CAPABILITY_ALIAS_MODELS = Object.freeze(
+  Object.keys(NATIVE_OPENAI_CAPABILITY_SOURCES),
+);
+
+export function isNativeOpenAiCapabilityAliasModel(slug: string): boolean {
+  return Object.hasOwn(NATIVE_OPENAI_CAPABILITY_SOURCES, slug);
+}
+
+export function nativeOpenAiCapabilitySourceSlug(slug: string): string {
+  return NATIVE_OPENAI_CAPABILITY_SOURCES[slug] ?? slug;
+}
+
 /** Native OpenAI model ids that this release can route and restore with authoritative metadata. */
 export const NATIVE_OPENAI_MODELS = [
   "gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex-spark",

package/src/codex/catalog/parsing.ts

@@ -31,7 +31,7 @@ import { redactSecretString } from "../../lib/redact";
 import upstreamModelsSnapshot from "../data/upstream-models.json";
 
 
-import { NATIVE_OPENAI_CONTEXT_OVERRIDES, SUPPORTED_NATIVE_OPENAI_SLUGS, UPSTREAM_NATIVE_ENTRIES, nativeMultiAgentVersion } from "./metadata";
+import { NATIVE_OPENAI_CONTEXT_OVERRIDES, SUPPORTED_NATIVE_OPENAI_SLUGS, UPSTREAM_NATIVE_ENTRIES, isNativeOpenAiCapabilityAliasModel, nativeMultiAgentVersion } from "./metadata";
 import { trustedAccountBoundNativeCatalogSlug } from "./account-models";
 import { CODEX_NATIVE_ALIAS_CATALOG_KIND } from "./kinds";
 
@@ -116,6 +116,11 @@ export interface CatalogModel {
   inputModalities?: string[];
   /** Provider opted into parallel tool calls (OcxProviderConfig.parallelToolCalls). */
   parallelToolCalls?: boolean;
+  /**
+   * This routed row is an explicitly configured account-native alias on the canonical ChatGPT
+   * forward provider. It may inherit pinned native Codex metadata without changing its wire id.
+   */
+  codexForwardNativeCapabilityAlias?: boolean;
   /** Whether Codex may send Responses text.verbosity for this routed model. */
   supportsVerbosity?: boolean;
   supportsReasoningSummaries?: boolean;
@@ -359,9 +364,19 @@ export function applyMultiAgentMode(entries: RawEntry[], mode: MultiAgentMode, v
     for (const entry of entries) {
       const slug = typeof entry.slug === "string" ? entry.slug : "";
       const nativeAlias = entry.opencodex_catalog_kind === CODEX_NATIVE_ALIAS_CATALOG_KIND;
+      const routedNativeSlug = slug.startsWith(`${OPENAI_CODEX_PROVIDER_ID}/`)
+        ? slug.slice(OPENAI_CODEX_PROVIDER_ID.length + 1)
+        : "";
+      const codexForwardCapabilityAlias = entry.opencodex_catalog_kind === CODEX_CUSTOM_MODEL_CATALOG_KIND
+        && entry.use_responses_lite === true
+        && isNativeOpenAiCapabilityAliasModel(routedNativeSlug)
+        ? routedNativeSlug
+        : undefined;
       const upstreamPin = nativeAlias
         ? nativeMultiAgentVersion(slug)
-        : UPSTREAM_NATIVE_ENTRIES.get(trustedAccountBoundNativeCatalogSlug(entry) ?? slug)?.multi_agent_version;
+        : codexForwardCapabilityAlias
+          ? nativeMultiAgentVersion(codexForwardCapabilityAlias)
+          : UPSTREAM_NATIVE_ENTRIES.get(trustedAccountBoundNativeCatalogSlug(entry) ?? slug)?.multi_agent_version;
       if (typeof upstreamPin === "string") {
         entry.multi_agent_version = upstreamPin;
       } else if (v2FeatureEnabled) {
@@ -394,17 +409,21 @@ export function normalizeRoutedCatalogEntry(entry: RawEntry, parallelToolCalls =
   delete entry.supports_reasoning_summaries;
   const isCursorEntry = typeof entry.slug === "string" && entry.slug.startsWith("cursor/");
   // `supports_search_tool` selects Codex's deferred tool-discovery surface; it is not the hosted
-  // web-search capability. OpenCodex can round-trip tool_search when a client sends it, but routed
-  // providers have no provider/model proof that Codex App plugins work through that deferred
-  // surface. Advertising it unconditionally hides the App's compatible direct MCP tools (#1522),
-  // so routed rows fail closed to direct discovery. The sidecar-backed hosted web-search metadata
-  // remains advertised independently for non-Cursor routes.
+  // web-search capability. Routed rows also carry tool_mode=code_mode_only (below), and under code
+  // mode DEFERRED MCP tools remain callable through exec's `tools` global / ALL_TOOLS without any
+  // tool_search round-trip (upstream codex-rs code_mode suite; live canary 2026-08-13: routed
+  // kimi/k3 called tools.mcp__node_repl__js → isError:false). Stamping false here instead forces
+  // every MCP declaration into exec.description — a measured 2.7x turn-1 payload regression
+  // (96,699 → 258,929 chars; devlog/_plan/260813_tool_catalog_deferral/010). So non-Cursor routed
+  // rows advertise deferred discovery; the #1522 reachability concern is covered by the code-mode
+  // path, not by paying the full-catalog tax. Cursor stays false: its runTurn transport bypasses
+  // the web-search sidecar and has no proven deferred path.
   if (isCursorEntry) {
     delete entry.web_search_tool_type;
   } else {
     entry.web_search_tool_type = "text_and_image";
   }
-  entry.supports_search_tool = false;
+  entry.supports_search_tool = !isCursorEntry;
   // Cursor's transport already serializes overlapping tool calls into atomic Responses tool events.
   // Advertising parallel calls lets Codex send the same native capability bit it sends for OpenAI.
   // Opt-in providers (OcxProviderConfig.parallelToolCalls, e.g. xAI) advertise it too: the

package/src/codex/catalog/provider-fetch.ts

@@ -69,7 +69,7 @@ import { createAdmissionGate, ResourceAdmissionError, type AdmissionMetrics } fr
 
 import { CODEX_CUSTOM_MODEL_CATALOG_KIND, JAWCODE_CATALOG_AUGMENT_PROVIDERS, catalogModelSlug, shouldExposeRoutedModel } from "./parsing";
 import type { CatalogModel } from "./parsing";
-import { disabledNativeSlugs, hasComboTargets, nativeDefaultReasoningEffort, nativeInputModalities, nativeOpenAiContextWindow, nativeOpenAiSlugs, nativeParallelToolCalls, nativeReasoningEfforts } from "./metadata";
+import { disabledNativeSlugs, hasComboTargets, isNativeOpenAiCapabilityAliasModel, nativeDefaultReasoningEffort, nativeInputModalities, nativeOpenAiContextWindow, nativeOpenAiSlugs, nativeParallelToolCalls, nativeReasoningEfforts } from "./metadata";
 import { deriveComboCatalogModel, normalizedOpenAiApiSignature, openAiApiCollisionWarnings, replaceLastComboCatalogOmissions, warnUncataloguedComboOnce } from "./aggregation";
 import type { ComboCatalogOmission } from "./aggregation";
 import type { CatalogGatherProviderAuthEvidence } from "./filesystem-evidence";
@@ -209,6 +209,15 @@ interface GatherInflightEntry {
   readonly promise: Promise<GatherFlightResult>;
 }
 
+function withCanonicalOpenAiForwardAuthDefault(
+  name: string,
+  provider: OcxProviderConfig,
+): OcxProviderConfig {
+  if (name !== OPENAI_CODEX_PROVIDER_ID || provider.authMode !== undefined) return provider;
+  const candidate = { ...provider, authMode: "forward" as const };
+  return isCanonicalOpenAiForwardProvider(candidate) ? candidate : provider;
+}
+
 const gatherInflight = new Map<string, GatherInflightEntry[]>();
 const CATALOG_GATHER_AUTHORITY_KEY = randomBytes(32);
 const REQUEST_CREDENTIAL_SENTINEL = `ocx-catalog-credential-${randomBytes(16).toString("hex")}`;
@@ -390,7 +399,7 @@ function captureProviderGather(
   authResolver: ModelsAuthResolver,
   retainConfiguredModelIds?: ReadonlySet<string>,
 ): CapturedProviderGather {
-  const enriched = detachedClone(configured);
+  const enriched = detachedClone(withCanonicalOpenAiForwardAuthDefault(name, configured));
   enrichProviderFromRegistry(name, enriched);
   const provider = recursivelyFreeze(enriched);
   const observedAuth = authResolver.kind === "observed"
@@ -1714,16 +1723,49 @@ async function gatherRoutedModelsUncached(
   const replacedByRoutedSlug = new Map(all.map(model => [routedSlug(model.provider, model.id), model]));
   const customModels = (config.customModels ?? []).map(cm => {
     const rawProvider = config.providers[cm.provider];
+    // Registry routing backfills an omitted authMode on the built-in OpenAI provider to
+    // forward. Keep the catalog projection on the same contract while still failing closed
+    // for every explicit non-forward mode and every non-canonical endpoint.
+    const providerForCanonicalCheck = rawProvider
+      ? withCanonicalOpenAiForwardAuthDefault(cm.provider, rawProvider)
+      : undefined;
+    const codexForwardNativeCapabilityAlias = cm.provider === OPENAI_CODEX_PROVIDER_ID
+      && providerForCanonicalCheck !== undefined
+      && isCanonicalOpenAiForwardProvider(providerForCanonicalCheck)
+      && isNativeOpenAiCapabilityAliasModel(cm.modelId);
+    const nativeAliasContextWindow = codexForwardNativeCapabilityAlias
+      ? nativeOpenAiContextWindow(cm.modelId, providerContextCap(config, OPENAI_CODEX_PROVIDER_ID))
+      : undefined;
+    const customContextWindow = cm.contextWindow
+      ? nativeAliasContextWindow !== undefined
+        ? Math.min(cm.contextWindow, nativeAliasContextWindow)
+        : cm.contextWindow
+      : nativeAliasContextWindow;
+    const nativeAliasDefaultEffort = codexForwardNativeCapabilityAlias
+      ? nativeDefaultReasoningEffort(cm.modelId)
+      : undefined;
     const supportsReasoningSummaries = configuredReasoningSummarySupport(rawProvider, cm.modelId);
     const base: CatalogModel = {
       id: cm.modelId,
       provider: cm.provider,
       catalogKind: CODEX_CUSTOM_MODEL_CATALOG_KIND,
       // Display-only label: never feeds routing (customModels are keyed by routedSlug below).
-      ...(cm.displayName ? { displayName: cm.displayName } : {}),
-      ...(cm.contextWindow ? { contextWindow: cm.contextWindow } : {}),
-      ...(cm.inputModalities ? { inputModalities: cm.inputModalities } : {}),
+      ...(cm.displayName
+        ? { displayName: cm.displayName }
+        : codexForwardNativeCapabilityAlias ? { displayName: "Daybreak Blue" } : {}),
+      ...(customContextWindow !== undefined ? { contextWindow: customContextWindow } : {}),
+      ...(cm.inputModalities
+        ? { inputModalities: cm.inputModalities }
+        : codexForwardNativeCapabilityAlias ? { inputModalities: nativeInputModalities(cm.modelId) } : {}),
       ...(typeof supportsReasoningSummaries === "boolean" ? { supportsReasoningSummaries } : {}),
+      ...(codexForwardNativeCapabilityAlias
+        ? {
+          codexForwardNativeCapabilityAlias: true,
+          reasoningEfforts: nativeReasoningEfforts(cm.modelId),
+          parallelToolCalls: nativeParallelToolCalls(cm.modelId),
+          ...(nativeAliasDefaultEffort ? { defaultReasoningEffort: nativeAliasDefaultEffort } : {}),
+        }
+        : {}),
     };
     // #962: the dedupe below drops the provider-derived row this custom row replaces. Inherit that
     // row's provider capability metadata (reasoning ladder, default effort, parallel tool calls,

package/src/codex/catalog/sync.ts

@@ -248,6 +248,9 @@ export function deriveEntry(
   contextCap?: number,
 ): RawEntry {
   const preserveExact = isExactComboCatalogModel(model, exactComboSlugs);
+  const codexForwardNativeCapabilityAlias = model?.codexForwardNativeCapabilityAlias === true
+    ? upstreamNativeEntry(model.id)
+    : null;
   const isRouted = model !== undefined;
   if (!isRouted && !slug.includes("/")) {
     // Supported native slug covered by the upstream snapshot: use the REAL entry (exact
@@ -256,8 +259,8 @@ export function deriveEntry(
     const upstream = upstreamNativeEntry(slug);
     if (upstream) return finishUpstreamNativeEntry(upstream, priority, contextCap);
   }
-  if (template) {
-    const e = JSON.parse(JSON.stringify(template)) as RawEntry;
+  if (template || codexForwardNativeCapabilityAlias) {
+    const e = JSON.parse(JSON.stringify(codexForwardNativeCapabilityAlias ?? template)) as RawEntry;
     e.slug = slug;
     e.display_name = routedDisplayName(slug);
     e.description = desc;
@@ -272,9 +275,11 @@ export function deriveEntry(
       // window when /models omits context metadata (#992). Known metadata
       // restores exact values below; otherwise the strict-fields fallback
       // supplies the conservative 128k triple.
-      delete e.context_window;
-      delete e.max_context_window;
-      delete e.auto_compact_token_limit;
+      if (!codexForwardNativeCapabilityAlias) {
+        delete e.context_window;
+        delete e.max_context_window;
+        delete e.auto_compact_token_limit;
+      }
       // Native id for identity text + metadata lookups — the slug may be an encoded
       // alias (`provider/vendor-model`); the model object carries the native id.
       const modelName = model?.id ?? slug.slice(slug.indexOf("/") + 1);
@@ -283,8 +288,17 @@ export function deriveEntry(
         // (leaking that into base_instructions is a non-first-party signature → ToS risk).
         e.base_instructions = identifyRoutedModel(e.base_instructions, modelName);
       }
-      applyReasoningLevels(e, model?.reasoningEfforts, model?.defaultReasoningEffort, preserveExact);
-      normalizeRoutedCatalogEntry(e, model?.parallelToolCalls === true);
+      applyReasoningLevels(
+        e,
+        model?.reasoningEfforts,
+        model?.defaultReasoningEffort,
+        preserveExact || codexForwardNativeCapabilityAlias !== null,
+      );
+      // This exact provider/model pair is the ChatGPT/Codex forward surface. Keep the pinned
+      // native tool/search/responses-lite contract while preserving the routed slug and wire id.
+      if (!codexForwardNativeCapabilityAlias) {
+        normalizeRoutedCatalogEntry(e, model?.parallelToolCalls === true);
+      }
       if (model) applyCatalogMetadata(e, model.provider, model.id, model.contextCap);
       applyCatalogModelMetadata(e, model);
       if (model?.catalogKind) e.opencodex_catalog_kind = model.catalogKind;
@@ -310,11 +324,20 @@ export function deriveEntry(
     });
   }
   // Fallback when no template is available (best-effort; strict parser may need more).
+  // Cursor fallback rows mirror normalizeRoutedCatalogEntry: no deferred discovery, no hosted
+  // web-search metadata (runTurn transport bypasses the sidecar). Non-Cursor routed fallbacks
+  // advertise deferred discovery — code mode keeps deferred MCP callable (devlog
+  // 260813_tool_catalog_deferral/010+020); search=false costs a measured 2.7x turn-1 payload.
+  const isCursorFallback = isRouted && model?.provider === "cursor";
   const entry: RawEntry = {
     slug, display_name: routedDisplayName(slug), description: desc,
     shell_type: "shell_command", visibility: "list", supported_in_api: true,
     priority, base_instructions: "You are a helpful coding assistant.",
-    ...(isRouted ? { web_search_tool_type: "text_and_image", supports_search_tool: false } : {}),
+    ...(isRouted
+      ? isCursorFallback
+        ? { supports_search_tool: false }
+        : { web_search_tool_type: "text_and_image", supports_search_tool: true }
+      : {}),
   };
   if (isRouted) {
     applyRoutedCodexToolMode(entry);

package/src/codex/catalog.ts

@@ -2,7 +2,7 @@
 // Public surface preserved exactly; importers keep using "src/codex/catalog".
 export { isMediaGenerationModelId, shouldExposeRoutedModel, readCodexCatalogPath, readCatalog, normalizeRoutedCatalogEntry, catalogModelSlug, filterSupportedNativeSlugs, catalogModelSupportsReasoningSummaries } from "./catalog/parsing";
 export type { CatalogModel, MultiAgentMode } from "./catalog/parsing";
-export { accountBoundNativeOpenAiSlugs, accountBoundNativeOpenAiSlugsBySelector, CODEX_NATIVE_ALIAS_CATALOG_KIND, NATIVE_OPENAI_MODELS, configuredNativeAliasSlugs, desktopAllowlistSuppressedNativeSlugs, isNativeAliasCatalogEntry, nativeOpenAiContextWindow, disabledNativeSlugs, visibleNativeSlugs, desktopVisibleNativeSlugs, nativeModelRows, applyNativeVisibility, observedAccountBoundNativeEntries, observedAccountBoundNativeOpenAiSlugs, upstreamNativeEntry, nativeOpenAiSlugs, listCatalogNativeSlugs, nativeInputModalities, nativeReasoningEfforts, nativeDefaultReasoningEffort, shouldIncludeAccountBoundNativeOpenAi, shouldIncludeNativeOpenAi } from "./catalog/metadata";
+export { accountBoundNativeOpenAiSlugs, accountBoundNativeOpenAiSlugsBySelector, CODEX_NATIVE_ALIAS_CATALOG_KIND, NATIVE_DAYBREAK_BLUE_MODEL, NATIVE_OPENAI_CAPABILITY_ALIAS_MODELS, NATIVE_OPENAI_MODELS, configuredNativeAliasSlugs, desktopAllowlistSuppressedNativeSlugs, isNativeAliasCatalogEntry, isNativeOpenAiCapabilityAliasModel, nativeOpenAiCapabilitySourceSlug, nativeOpenAiContextWindow, disabledNativeSlugs, visibleNativeSlugs, desktopVisibleNativeSlugs, nativeModelRows, applyNativeVisibility, observedAccountBoundNativeEntries, observedAccountBoundNativeOpenAiSlugs, upstreamNativeEntry, nativeOpenAiSlugs, listCatalogNativeSlugs, nativeInputModalities, nativeReasoningEfforts, nativeDefaultReasoningEffort, shouldIncludeAccountBoundNativeOpenAi, shouldIncludeNativeOpenAi } from "./catalog/metadata";
 export { isSpawnableCodexCandidate, codexExecInvocation, loadBundledCodexCatalog, materializeBundledCodexCatalog, loadCatalogTemplate } from "./catalog/bundled";
 export { nativeEffortClamp, shouldApplyNativeEffortClamp, catalogModelEfforts, codexSupportedReasoningEfforts, clampedDefaultEffort, clampEntryToCodexSupportedEfforts, clampCatalogModelsToCodexSupport } from "./catalog/effort";
 export { applyProviderConfigHints, isDatedVariantId, filterCatalogVisibleModels, gatherRoutedModels, clearGatherRoutedModelsInflight, augmentRoutedModelsWithRegistryOpenAiApiRows, augmentRoutedModelsWithMetadata, resolveComboCatalogMember, configuredComboTargetModelsByProvider } from "./catalog/provider-fetch";

package/src/codex/features.ts

@@ -1036,7 +1036,18 @@ export function setMultiAgentModeHintText(value: string | null, configPath?: str
   return setV2StringField("multi_agent_mode_hint_text", value, configPath);
 }
 
-const modeHintCapabilityCache = new Map<string, boolean | null>();
+export const MODE_HINT_CAPABILITY_CACHE_MAX_ENTRIES = 8;
+export const modeHintCapabilityCache = new Map<string, boolean | null>();
+
+export function rememberModeHintCapability(cacheKey: string, capability: boolean | null): void {
+  modeHintCapabilityCache.delete(cacheKey);
+  modeHintCapabilityCache.set(cacheKey, capability);
+  while (modeHintCapabilityCache.size > MODE_HINT_CAPABILITY_CACHE_MAX_ENTRIES) {
+    const oldest = modeHintCapabilityCache.keys().next().value;
+    if (oldest === undefined) break;
+    modeHintCapabilityCache.delete(oldest);
+  }
+}
 
 /**
  * True when the installed Codex runtime binary contains the
@@ -1069,7 +1080,7 @@ export function probeCodexSupportsModeHint(): boolean | null {
         if (!isNativeExecutable(buf)) continue;
         sawBinary = true;
         if (buf.includes(Buffer.from("multi_agent_mode_hint_text", "utf8"))) {
-          modeHintCapabilityCache.set(cacheKey, true);
+          rememberModeHintCapability(cacheKey, true);
           return true;
         }
       } catch {
@@ -1078,7 +1089,7 @@ export function probeCodexSupportsModeHint(): boolean | null {
     }
     // At least one real binary was inspected and none contained the key.
     const result = sawBinary ? false : null;
-    modeHintCapabilityCache.set(cacheKey, result);
+    rememberModeHintCapability(cacheKey, result);
     return result;
   } catch {
     return null;

package/src/codex/model-cache.ts

@@ -47,7 +47,7 @@ export type ModelCacheClearReason = "authority" | "eviction";
 
 const cache = new Map<string, CacheEntry>();
 let globalCacheGeneration = 0;
-const providerCacheGenerations = new Map<string, number>();
+export const providerCacheGenerations = new Map<string, number>();
 let cacheBytes = 0;
 let oldestCachedProvider: string | undefined;
 let oldestCachedAt: number | null = null;
@@ -235,9 +235,15 @@ export function reconcileModelCacheProviders(
     ...liveModelCounts.keys(),
     ...cache.keys(),
   ]);
+  let revokedRemovedProviderAuthority = false;
   for (const provider of trackedProviders) {
     if (validProviders.has(provider)) continue;
+    if (!revokedRemovedProviderAuthority) {
+      globalCacheGeneration += 1;
+      revokedRemovedProviderAuthority = true;
+    }
     providerCacheGenerations.set(provider, (providerCacheGenerations.get(provider) ?? 0) + 1);
+    providerCacheGenerations.delete(provider);
     deleteCachedProvider(provider);
     failureAt.delete(provider);
     discoveryStatus.delete(provider);

package/src/codex/native-main-claim.ts

@@ -22,7 +22,18 @@ export interface NativeMainClaimOptions {
   env?: NodeJS.ProcessEnv;
 }
 
-const hardenedIdentities = new Map<string, string>();
+export const NATIVE_MAIN_HARDENED_IDENTITY_MAX_ENTRIES = 32;
+export const hardenedIdentities = new Map<string, string>();
+
+export function rememberHardenedIdentity(path: string, identity: string): void {
+  hardenedIdentities.delete(path);
+  hardenedIdentities.set(path, identity);
+  while (hardenedIdentities.size > NATIVE_MAIN_HARDENED_IDENTITY_MAX_ENTRIES) {
+    const oldest = hardenedIdentities.keys().next().value;
+    if (oldest === undefined) break;
+    hardenedIdentities.delete(oldest);
+  }
+}
 
 export function nativeMainClaimPath(context: NativeProfileContext): string {
   return join(context.codexHome, NATIVE_MAIN_CLAIM_DB);
@@ -86,7 +97,7 @@ async function openClaimDatabase(
       // tests stayed green, because nearly every claim test injects `hardenPath`.
       await (options.hardenPath ?? ((target: string) => hardenStableLockFile(target, platform)))(path);
       assertStableLockFile(path, file);
-      hardenedIdentities.set(path, identity);
+      rememberHardenedIdentity(path, identity);
     }
     database = new Database(path, { create: true });
     // Journal-mode negotiation itself may need a database lock. Disable