@bitkyc08/opencodex 2.84.0 → 2.87.0

package/src/codex/catalog/build-entries.ts

@@ -48,7 +48,8 @@ import { NATIVE_RESERVE_MODEL } from "./native-models";
 import { isReserveCatalogProjection, type ReserveCatalogProjection } from "./reserve";
 import { deriveEntry, finishUpstreamNativeEntry, isExactComboCatalogEntry } from "./derive-entry";
 import { PICKER_ORDER_PRIORITY_BASE, SPAWN_PRIORITY_FIELD } from "./subagent-roster";
-import { preserveOperatorUltraFastTiers } from "./operator-tiers";
+import { applyConfiguredUltraFast, configuredUltraFastSlugs } from "./configured-tiers";
+import { applyNativeUltraFastTier } from "./native-ultrafast";
 
 export interface ObservedCatalogEntryBuildInput {
   readonly template: RawEntry | null;
@@ -110,6 +111,14 @@ export function buildCatalogEntries(
     accountNativeSlugs,
     accountNativeSlugsBySelector,
   });
+  // Live discovery does not run the disk merge; use the same captured declarations and row fences.
+  const configured = configuredUltraFastSlugs(goModels);
+  for (const entry of entries) {
+    if (typeof entry.slug !== "string" || !entry.slug.includes("/")
+      || isNativeAliasCatalogEntry(entry) || isExactComboCatalogEntry(entry, exactComboSlugs)
+      || trustedAccountBoundNativeCatalogSlug(entry) !== undefined) continue;
+    applyConfiguredUltraFast(entry, undefined, configured.has(entry.slug), false);
+  }
   applyFullModelPickerOrder(entries, modelPickerOrder);
   return entries;
 }
@@ -473,6 +482,8 @@ export function applyFullModelPickerOrder(entries: RawEntry[], order: readonly s
 export interface ObservedCatalogMergeInput {
   /** Preserve operator-supplied Ultra Fast only from the exact persisted routed row. */
   readonly ultraFastTier?: boolean;
+  /** Current captured wire declarations; disk rows and templates never populate this set. */
+  readonly configuredUltraFastSlugs?: ReadonlySet<string>;
   readonly catalogModels: readonly RawEntry[];
   readonly baselineCatalogModels: readonly RawEntry[];
   readonly routedEntries: readonly RawEntry[];
@@ -514,6 +525,7 @@ export interface ObservedCatalogMergeInput {
  */
 export function mergeCatalogEntriesFromObservedState({
   ultraFastTier = false,
+  configuredUltraFastSlugs = new Set(),
   catalogModels,
   baselineCatalogModels,
   routedEntries,
@@ -865,7 +877,7 @@ export function mergeCatalogEntriesFromObservedState({
     if (typeof entry.slug !== "string" || !entry.slug.includes("/")
       || isNativeAliasCatalogEntry(entry) || isExactComboCatalogEntry(entry, exactComboSlugs)
       || trustedAccountBoundNativeCatalogSlug(entry) !== undefined) continue;
-    preserveOperatorUltraFastTiers(entry, operatorRows.get(entry.slug), ultraFastTier);
+    applyConfiguredUltraFast(entry, operatorRows.get(entry.slug), configuredUltraFastSlugs.has(entry.slug), ultraFastTier);
   }
   const finalRoutedEntrySet = new Set(finalRoutedEntries);
   const degradedPreservedCount = preservedRoutedEntries.filter(entry => {
@@ -932,6 +944,11 @@ export function mergeCatalogEntriesFromObservedState({
         );
       }
     }
+    // Native Astra/Sol rows (bare and account-bound) gain or lose the documented Ultrafast
+    // choice with the switch; aliases, combos and reserve projections keep their own tiers.
+    if (!reserveProjection && !exactCombo && m.owned_by !== COMBO_NAMESPACE && !isNativeAliasCatalogEntry(e)) {
+      applyNativeUltraFastTier(e, ultraFastTier);
+    }
     if (wsEnabled) e.supports_websockets = true;
     else {
       delete e.supports_websockets;

package/src/codex/catalog/combo-member.ts

@@ -100,7 +100,7 @@ import type {
   CatalogSourceEvidence,
   CatalogTrustedOpenAiApiPolicySnapshot,
 } from "../convergence-types";
-import { applyProviderConfigHints, configuredAutoCompactTokenLimit, positiveSafeInteger } from "./model-hints";
+import { applyProviderConfigHints, configuredAutoCompactTokenLimit, positiveSafeInteger, withVisionSidecarInput } from "./model-hints";
 
 /** Model ids each provider must retain for combo catalog derivation (OCX-111). */
 export function configuredComboTargetModelsByProvider(
@@ -219,6 +219,7 @@ export function resolveComboCatalogMember(
   callerFallback?: ComboCatalogMemberFallback,
   metadataModelIdCaseFold?: boolean,
   metadataConfigDir?: string,
+  visionSidecarEnabled = true,
 ): CatalogModel | undefined {
   const existing = memberByKey.get(targetKey(target));
   const prov = providers.get(target.provider);
@@ -227,6 +228,16 @@ export function resolveComboCatalogMember(
   // is unusable for catalog derivation while the provider is off.
   if (prov?.disabled === true) return undefined;
 
+  /** Preserve custom modality overrides while filling missing provider metadata. */
+  const withProviderHints = (model: CatalogModel): CatalogModel => {
+    const hinted = prov
+      ? applyProviderConfigHints(target.provider, prov, model, contextCap, metadataModelIdCaseFold, undefined, metadataConfigDir, visionSidecarEnabled)
+      : model;
+    return model.catalogKind === CODEX_CUSTOM_MODEL_CATALOG_KIND && model.inputModalities !== undefined
+      ? withVisionSidecarInput({ ...hinted, inputModalities: [...model.inputModalities] }, prov, visionSidecarEnabled)
+      : hinted;
+  };
+
   const withFallbackMetadata = (member: CatalogModel): CatalogModel => {
     const contextWindow = typeof member.contextWindow === "number" && member.contextWindow > 0
       ? member.contextWindow
@@ -276,7 +287,7 @@ export function resolveComboCatalogMember(
     // supplies a vision sidecar. Apply the same provider hints used for thin
     // rows before deriving a combo from this complete row.
     const hinted = prov && isModelVisionSidecarConsumer(prov, existing.id)
-      ? applyProviderConfigHints(target.provider, prov, existing, contextCap, metadataModelIdCaseFold, undefined, metadataConfigDir)
+      ? withProviderHints(existing)
       : existing;
     const capped = applyProviderContextCap(hinted.contextWindow, contextCap);
     if (capped === undefined || capped === existing.contextWindow) {
@@ -298,9 +309,7 @@ export function resolveComboCatalogMember(
     id: target.model,
     provider: target.provider,
   };
-  const hinted = prov
-    ? applyProviderConfigHints(target.provider, prov, base, contextCap, metadataModelIdCaseFold, undefined, metadataConfigDir)
-    : base;
+  const hinted = withProviderHints(base);
   const hintedContext = typeof hinted.contextWindow === "number" && hinted.contextWindow > 0
     ? hinted.contextWindow
     : undefined;

package/src/codex/catalog/configured-tiers.ts

@@ -0,0 +1,50 @@
+import { COMBO_NAMESPACE } from "../../combos";
+import type { ResolvedFastPolicy } from "../../providers/fastwire";
+import { catalogModelSlug, type CatalogModel, type RawEntry } from "./parsing";
+import { preserveOperatorUltraFastTiers } from "./operator-tiers";
+
+const MANAGED_ULTRAFAST = "opencodex_managed_ultrafast";
+
+/** Advertise Ultra Fast only when the eligible final wire explicitly maps that exact tier. */
+export function supportsConfiguredUltraFast(policy: ResolvedFastPolicy | undefined): boolean {
+  return policy?.eligibility === "eligible"
+    && policy.fastWire?.kind === "service-tier"
+    && policy.fastWire.canonicalToWire.ultrafast === "ultrafast";
+}
+
+/** Carry captured capability to catalog projection without treating persisted metadata as authority. */
+export function configuredUltraFastSlugs(models: readonly CatalogModel[]): ReadonlySet<string> {
+  const declarations = new Map<string, boolean>();
+  for (const model of models) {
+    const slug = catalogModelSlug(model);
+    const supported = model.provider !== COMBO_NAMESPACE && model.nativeAlias !== true
+      && model.supportsServiceTier === true && model.supportsUltraFastTier === true;
+    // A conflicting duplicate cannot lend its capability to the surviving row.
+    declarations.set(slug, supported && declarations.get(slug) !== false);
+  }
+  return new Set([...declarations].filter(([, supported]) => supported).map(([slug]) => slug));
+}
+
+/** Apply current configuration, or retain an independently supplied exact-row operator tier. */
+export function applyConfiguredUltraFast(
+  entry: RawEntry,
+  previous: RawEntry | undefined,
+  configured: boolean,
+  retainOperatorTier: boolean,
+): void {
+  // This marker only rejects stale generated metadata; it never authorizes a new tier.
+  const wasManaged = previous?.[MANAGED_ULTRAFAST] === entry.slug;
+  preserveOperatorUltraFastTiers(entry, wasManaged || configured ? undefined : previous, retainOperatorTier);
+  delete entry[MANAGED_ULTRAFAST];
+  if (!configured) return;
+  entry.service_tiers = [...(Array.isArray(entry.service_tiers) ? entry.service_tiers : []), {
+    id: "ultrafast",
+    name: "Ultra Fast",
+    description: "Higher speed and usage; provider access required",
+  }];
+  entry.additional_speed_tiers = [
+    ...(Array.isArray(entry.additional_speed_tiers) ? entry.additional_speed_tiers : []), "ultrafast",
+  ];
+  // Advertising a selectable capability does not opt the user into its increased usage.
+  entry[MANAGED_ULTRAFAST] = entry.slug;
+}

package/src/codex/catalog/effort.ts

@@ -204,6 +204,8 @@ export function applyCatalogModelMetadata(entry: RawEntry, model?: CatalogModel)
  * Two real sources exist and both are consulted here, in the same precedence the
  * writers use (`applyCatalogMetadata` runs first, the model's own fields
  * overwrite it): the `CatalogModel` and the generated jawcode metadata table.
+ * Vendor-ID fallback windows are estimates for client budgets, recorded separately rather
+ * than promoted to serving-provider assertions.
  * Reading only the model would silently drop every provider whose capabilities
  * live in that table.
  */
@@ -230,7 +232,8 @@ function stampCapabilityProvenance(entry: RawEntry, model: CatalogModel): void {
   entry.opencodex_capability_provenance = {
     provider: model.provider,
     model_id: model.id,
-    ...(contextWindow !== undefined ? { context_window: contextWindow } : {}),
+    ...(contextWindow !== undefined && !model.contextWindowInference ? { context_window: contextWindow } : {}),
+    ...(model.contextWindowInference ? { inferred_context_window: contextWindow, context_window_inference: { ...model.contextWindowInference } } : {}),
     ...(inputModalities !== undefined ? { input_modalities: [...inputModalities] } : {}),
     ...(Array.isArray(model.capabilities) && model.capabilities.length > 0
       ? { capabilities: [...model.capabilities] }

package/src/codex/catalog/gather-capture.ts

@@ -564,6 +564,7 @@ function providerCatalogFingerprint(name: string, prov: OcxProviderConfig): Reco
   };
 }
 
+/** Coalesce only gathers with the same model inventory and effective sidecar visibility policy. */
 export function gatherFlightKey(config: OcxConfig): string {
   const providers = Object.entries(config.providers)
     .filter(([, prov]) => prov.disabled !== true)
@@ -571,6 +572,7 @@ export function gatherFlightKey(config: OcxConfig): string {
     .sort((a, b) => String(a.n).localeCompare(String(b.n)));
   const assembly = stableJson({
     providers,
+    visionSidecarEnabled: config.visionSidecar?.enabled !== false,
     disabledModels: [...(config.disabledModels ?? [])].sort(),
     combos: config.combos ?? {},
     customModels: (config.customModels ?? []).map((cm) => ({

package/src/codex/catalog/metadata.ts

@@ -276,6 +276,14 @@ function asLimits(input: NativeContextLimitsInput): NativeContextLimits {
   return typeof input === "number" ? { cap: input } : input;
 }
 
+/** Configured hard ceiling only; an advertised default window is not a user limit. */
+export function nativeOpenAiConfiguredContextLimit(slug: string, input?: NativeContextLimitsInput): number | undefined {
+  const limits = asLimits(input);
+  const overlay = positiveInt(limits.modelWindows?.[slug]) ?? positiveInt(limits.providerWindow);
+  const cap = positiveInt(limits.cap);
+  return overlay === undefined ? cap : cap === undefined ? overlay : Math.min(overlay, cap);
+}
+
 /** Read both levers out of a config once, for call sites that hold one. */
 export function nativeContextLimits(
   config: Pick<OcxConfig, "providers" | "providerContextCaps">,
@@ -326,18 +334,12 @@ function longWindowOptInCeiling(slug: string): number | undefined {
 
 function narrowToLimits(raw: number | undefined, slug: string, input: NativeContextLimitsInput): number | undefined {
   if (raw === undefined) return undefined;
-  const limits = asLimits(input);
-  const overlay = positiveInt(limits.modelWindows?.[slug]) ?? positiveInt(limits.providerWindow);
-  const cap = positiveInt(limits.cap);
+  const limit = nativeOpenAiConfiguredContextLimit(slug, input);
   const optInCeiling = longWindowOptInCeiling(slug);
   if (optInCeiling !== undefined) {
-    const ceiling = optInCeiling;
-    const chosen = overlay ?? cap ?? raw;
-    const window = Math.min(chosen, ceiling);
-    return overlay !== undefined && cap !== undefined ? Math.min(window, cap) : window;
+    return Math.min(limit ?? raw, optInCeiling);
   }
-  const narrowed = overlay === undefined ? raw : Math.min(raw, overlay);
-  return applyProviderContextCap(narrowed, cap) ?? narrowed;
+  return applyProviderContextCap(raw, limit);
 }
 
 export function nativeOpenAiContextWindow(slug: string, limits?: NativeContextLimitsInput): number | undefined {

package/src/codex/catalog/model-hints.ts

@@ -1,5 +1,7 @@
+import { canInferVendorContext, vendorContextInference } from "./vendor-context";
 import { effectiveProviderAlias, effectiveProviderAliasDecision } from "../../providers/default-aliases";
 import { initialModelSelectionPending } from "../../providers/initial-model-selection";
+import { supportsConfiguredUltraFast } from "./configured-tiers";
 import { execFileSync } from "node:child_process";
 import { createHash, createHmac, randomBytes } from "node:crypto";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, realpathSync } from "node:fs";
@@ -250,6 +252,18 @@ export function configuredReasoningSummarySupport(prov: OcxProviderConfig | unde
   return modelRecordValue(prov.modelReasoningSummaryDelivery, id) !== undefined ? true : undefined;
 }
 
+/** Add attachment metadata at publication time, independently of cached provider evidence. */
+export function withVisionSidecarInput(
+  model: CatalogModel,
+  provider: OcxProviderConfig | undefined,
+  enabled = true,
+): CatalogModel {
+  if (!enabled || !provider || !isModelVisionSidecarConsumer(provider, model.id)) return model;
+  const modalities = model.inputModalities ?? ["text"];
+  return modalities.includes("image") ? model : { ...model, inputModalities: [...modalities, "image"] };
+}
+
+/** Reapply configured limits and captured wire capabilities without trusting stale discovery hints. */
 export function applyProviderConfigHints(
   name: string,
   prov: OcxProviderConfig,
@@ -258,6 +272,7 @@ export function applyProviderConfigHints(
   metadataModelIdCaseFold?: boolean,
   effectiveAlias?: string | null,
   metadataConfigDir?: string,
+  includeVisionSidecar = true,
 ): CatalogModel {
   const staticPolicy = resolveModelPolicy({
     providerName: name,
@@ -286,18 +301,7 @@ export function applyProviderConfigHints(
   // Removing an exact capability row therefore returns this projection to legacy-map inference.
   const resolvedModalities = staticPolicy.model.inputModalities ?? model.inputModalities
     ?? (azureMetadata?.input ? modelInputModalities({ id: model.id, input_modalities: azureMetadata.input }, undefined) : undefined);
-  let inputModalities = resolvedModalities ? [...resolvedModalities] : undefined;
-  // The shared vision-sidecar consumer predicate keeps catalog advertisement and request-time
-  // planning aligned. The catalog must still advertise image input — the Codex app
-  // gates attachments client-side on input_modalities, and a text-only entry would block images
-  // before the sidecar ever runs ("This model does not support image inputs"). Discovery-derived
-  // text-only rows stay untouched: the runtime predicate only reads these two config sources, so
-  // it would not convert those.
-  const sidecarCovered = isModelVisionSidecarConsumer(prov, model.id);
-  if (sidecarCovered) {
-    const base = inputModalities ?? model.inputModalities ?? ["text"];
-    inputModalities = base.includes("image") ? [...base] : [...base, "image"];
-  }
+  const inputModalities = resolvedModalities ? [...resolvedModalities] : undefined;
   const reasoningEfforts = configuredReasoningEfforts(prov, model.id);
   const suppressSyntheticMax = modelRecordValue(prov.modelSuppressSyntheticMax, model.id)
     ?? (model.antigravityEffortWireModelIds !== undefined);
@@ -309,7 +313,12 @@ export function applyProviderConfigHints(
   // owns catalog publication, including an explicit provider-level false.
   const supportsServiceTier = serviceTierSupportFromPolicy(fastPolicy);
   const {
+    contextWindowInference: _staleContextInference,
+    contextWindow: _previousContextWindow,
+    contextCap: previousContextCap,
+    contextCapped: previousContextCapped,
     supportsServiceTier: _staleServiceTier,
+    supportsUltraFastTier: _staleUltraFastTier,
     fastTierDescription: _staleFastTierDescription,
     providerAlias: _staleProviderAlias,
     suppressSyntheticMax: _staleSuppressSyntheticMax,
@@ -317,16 +326,23 @@ export function applyProviderConfigHints(
   } = model;
   // 已发现窗口只允许被配置值压低；缺窗口时，已开的 Context cap 就是实际窗口。
   const discoveredWindow = githubCopilotCatalogContextWindow(name, prov, model.id,
-    typeof model.contextWindow === "number" && model.contextWindow > 0 ? model.contextWindow : undefined);
+    !model.contextWindowInference && typeof model.contextWindow === "number" && model.contextWindow > 0 ? model.contextWindow : undefined);
   const projectedLimits = clampObservedModelLimits(staticPolicy.model, {
     ...(discoveredWindow !== undefined ? { contextWindow: discoveredWindow } : {}),
     ...(typeof model.maxInputTokens === "number" && model.maxInputTokens > 0 ? { maxInputTokens: model.maxInputTokens } : {}),
   });
+  const azureWindow = positiveSafeInteger(azureMetadata?.contextWindow);
+  const inferredWindow = projectedLimits.contextWindow === undefined && azureWindow === undefined && canInferVendorContext(name, prov)
+    ? vendorContextInference(model.id) : undefined;
   const hintedWindow = projectedLimits.contextWindow
-    ?? positiveSafeInteger(azureMetadata?.contextWindow)
+    ?? azureWindow
+    ?? inferredWindow?.contextWindow
     ?? (providerCap !== undefined ? resolveUnknownRoutedContextWindow(providerCap) : undefined);
-  const hinted = {
+  const hinted = withVisionSidecarInput({
     ...modelWithoutServiceTier,
+    ...(!model.contextWindowInference && previousContextCap !== undefined
+      ? { contextCap: previousContextCap, contextCapped: previousContextCapped } : {}),
+    ...(inferredWindow ? { contextWindowInference: inferredWindow } : {}),
     ...(displayName !== undefined ? { displayName } : {}),
     ...(providerAlias !== undefined ? { providerAlias } : {}),
     ...(hintedWindow !== undefined ? { contextWindow: hintedWindow } : {}),
@@ -343,6 +359,7 @@ export function applyProviderConfigHints(
     ...(typeof supportsReasoningSummaries === "boolean" ? { supportsReasoningSummaries } : {}),
     ...(typeof supportsVerbosity === "boolean" ? { supportsVerbosity } : {}),
     ...(typeof supportsServiceTier === "boolean" ? { supportsServiceTier } : {}),
+    supportsUltraFastTier: supportsConfiguredUltraFast(fastPolicy),
     ...(supportsServiceTier === true && fastPolicy.fastTierDescription !== undefined
       ? { fastTierDescription: fastPolicy.fastTierDescription }
       : {}),
@@ -352,7 +369,7 @@ export function applyProviderConfigHints(
       ? { parallelToolCalls: true }
       : {}),
     ...(prov.codexToolMode !== undefined ? { codexToolMode: prov.codexToolMode } : {}),
-  };
+  }, prov, includeVisionSidecar);
   const capped = applyProviderContextCap(hinted.contextWindow, providerCap);
   const withCap = providerCap !== undefined
     ? capped !== hinted.contextWindow
@@ -381,6 +398,7 @@ export function applyProviderConfigHints(
   };
 }
 
+/** Project a configured row, optionally deferring sidecar attachment metadata until publication. */
 export function catalogHintsFromProviderConfig(
   name: string,
   prov: OcxProviderConfig,
@@ -389,12 +407,14 @@ export function catalogHintsFromProviderConfig(
   metadataModelIdCaseFold?: boolean,
   effectiveAlias?: string | null,
   metadataConfigDir?: string,
+  includeVisionSidecar = true,
 ): Partial<CatalogModel> {
-  const hinted = applyProviderConfigHints(name, prov, { id, provider: name }, contextCap, metadataModelIdCaseFold, effectiveAlias, metadataConfigDir);
+  const hinted = applyProviderConfigHints(name, prov, { id, provider: name }, contextCap, metadataModelIdCaseFold, effectiveAlias, metadataConfigDir, includeVisionSidecar);
   const { provider: _provider, id: _id, ...hints } = hinted;
   return hints;
 }
 
+/** Reapply current hints to cached rows without mutating their provider evidence. */
 export function applyConfigHintsToCachedModels(
   name: string,
   prov: OcxProviderConfig,
@@ -403,8 +423,9 @@ export function applyConfigHintsToCachedModels(
   metadataModelIdCaseFold?: boolean,
   effectiveAlias?: string | null,
   metadataConfigDir?: string,
+  includeVisionSidecar = true,
 ): CatalogModel[] {
-  return models.map(model => applyProviderConfigHints(name, prov, model, contextCap, metadataModelIdCaseFold, effectiveAlias, metadataConfigDir));
+  return models.map(model => applyProviderConfigHints(name, prov, model, contextCap, metadataModelIdCaseFold, effectiveAlias, metadataConfigDir, includeVisionSidecar));
 }
 
 /** Catalog slugs whose configured model must not gain a missing synthetic max rung. */
@@ -431,7 +452,9 @@ export function suppressedSyntheticMaxCatalogSlugs(
   }
   return slugs;
 }
-export const QUIET_AUTHORITATIVE_CATALOG_PROVIDERS = new Set(["kimi", "xai"]);
+// google-antigravity: the static lineup is an entitlement superset (Claude 5.5 and Gemini 4 Argon
+// are per-account), so a live roster that omits some of it is the expected case, not drift.
+export const QUIET_AUTHORITATIVE_CATALOG_PROVIDERS = new Set(["kimi", "xai", "google-antigravity"]);
 
 export const CALLABLE_CONFIGURED_COMPATIBILITY_MODELS: Readonly<Record<string, ReadonlySet<string>>> = {
   // CodeBuddy's vendor defaults are real callable selectors — both the bundled manifests

package/src/codex/catalog/model-visibility.ts

@@ -231,6 +231,7 @@ export function mergeConfiguredModelsIntoLiveCatalog(opts: {
   retainComboTargets?: boolean;
   metadataModelIdCaseFold?: boolean;
   metadataConfigDir?: string;
+  includeVisionSidecar?: boolean;
 }): { models: CatalogModel[]; droppedConfiguredIds: string[] } {
   const {
     name,
@@ -242,6 +243,7 @@ export function mergeConfiguredModelsIntoLiveCatalog(opts: {
     retainComboTargets = true,
     metadataModelIdCaseFold,
     metadataConfigDir,
+    includeVisionSidecar,
   } = opts;
   const out = [...opts.models];
   const present = new Set(out.map(model => model.id));
@@ -250,7 +252,7 @@ export function mergeConfiguredModelsIntoLiveCatalog(opts: {
     if (present.has(candidate.id)) continue;
     const dated = out.find(live => isDatedVariantId(live.id, candidate.id));
     if (dated) {
-      out.push(applyProviderConfigHints(name, prov, { ...dated, id: candidate.id }, contextCap, metadataModelIdCaseFold, undefined, metadataConfigDir));
+      out.push(applyProviderConfigHints(name, prov, { ...dated, id: candidate.id }, contextCap, metadataModelIdCaseFold, undefined, metadataConfigDir, includeVisionSidecar));
       present.add(candidate.id);
       continue;
     }

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

@@ -0,0 +1,106 @@
+import type { RawEntry } from "./parsing";
+import { trustedAccountBoundNativeCatalogSlug } from "./account-models";
+import { NATIVE_GPT6_ASTRA_MODEL, NATIVE_GPT61_SOL_MODEL } from "./native-models";
+
+/**
+ * The Ultrafast speed choice OpenAI documents for GPT-6 Astra and GPT-6.1 Sol
+ * (https://developers.openai.com/api/docs/guides/ultrafast-mode and
+ * https://learn.chatgpt.com/docs/agent-configuration/speed, checked 2026-10-13).
+ *
+ * The upstream bundled catalog lists only `priority` for both models; ChatGPT's live model
+ * list adds Ultrafast for eligible plans. Codex stops consulting that live list once
+ * `model_catalog_json` points at our generated catalog, so without this row the speed picker
+ * never offers Ultrafast. The `ultraFastTier` switch is the operator's statement that their
+ * plan is eligible; the description still says the tier requires one.
+ */
+export const NATIVE_ULTRAFAST_SERVICE_TIER: Readonly<{ id: string; name: string; description: string }> = Object.freeze({
+  id: "ultrafast",
+  name: "Ultrafast",
+  description: "Lower latency, increased usage; requires an eligible plan",
+});
+
+export const NATIVE_ULTRAFAST_MODELS: ReadonlySet<string> = new Set([NATIVE_GPT6_ASTRA_MODEL, NATIVE_GPT61_SOL_MODEL]);
+
+function isUltraFastId(value: unknown): boolean {
+  return typeof value === "string" && value.trim().toLowerCase() === "ultrafast";
+}
+
+function isUltraFastDescriptor(value: unknown): boolean {
+  return value !== null && typeof value === "object" && "id" in value && isUltraFastId((value as { id: unknown }).id);
+}
+
+/**
+ * Provenance marker naming the tier fields this module added to a row. Ownership is never
+ * inferred from a descriptor's text: an operator may have written the very same entry, and only
+ * a row carrying this marker has anything for the switch to withdraw.
+ */
+export const NATIVE_ULTRAFAST_PROVENANCE_FIELD = "opencodex_generated_service_tiers";
+type TierField = "service_tiers" | "additional_speed_tiers";
+
+function generatedFields(entry: RawEntry): Set<TierField> {
+  const raw = entry[NATIVE_ULTRAFAST_PROVENANCE_FIELD];
+  const fields = new Set<TierField>();
+  if (Array.isArray(raw)) {
+    for (const value of raw) if (value === "service_tiers" || value === "additional_speed_tiers") fields.add(value);
+  }
+  return fields;
+}
+
+function isGeneratedDescriptor(value: unknown): boolean {
+  if (!isUltraFastDescriptor(value)) return false;
+  const tier = value as Record<string, unknown>;
+  return Object.keys(tier).length === 3
+    && tier.id === NATIVE_ULTRAFAST_SERVICE_TIER.id
+    && tier.name === NATIVE_ULTRAFAST_SERVICE_TIER.name
+    && tier.description === NATIVE_ULTRAFAST_SERVICE_TIER.description;
+}
+
+/** Bare native rows and trusted account-bound clones of the two Ultrafast models. */
+export function nativeUltraFastSlug(entry: RawEntry): string | undefined {
+  const slug = trustedAccountBoundNativeCatalogSlug(entry)
+    ?? (typeof entry.slug === "string" && !entry.slug.includes("/") ? entry.slug : undefined);
+  return slug !== undefined && NATIVE_ULTRAFAST_MODELS.has(slug) ? slug : undefined;
+}
+
+/**
+ * Add (enabled) or withdraw (disabled) the documented Ultrafast choice on an eligible native row.
+ *
+ * Enabling appends the descriptor to `service_tiers` and "ultrafast" to the deprecated
+ * `additional_speed_tiers` mirror, after the existing Fast tier and only when absent, and records
+ * each field it filled in the provenance marker. A repeated sync is a no-op and an
+ * operator-written Ultrafast entry wins. Disabling removes only what the marker names (and only
+ * the unedited generated descriptor), then drops the marker; rows without it are left as they
+ * are. The catalog default tier is never set.
+ */
+export function applyNativeUltraFastTier(entry: RawEntry, enabled: boolean): void {
+  const owned = generatedFields(entry);
+  if (nativeUltraFastSlug(entry) === undefined) {
+    delete entry[NATIVE_ULTRAFAST_PROVENANCE_FIELD];
+    return;
+  }
+  const tiers = Array.isArray(entry.service_tiers) ? entry.service_tiers : undefined;
+  const speeds = Array.isArray(entry.additional_speed_tiers) ? entry.additional_speed_tiers : undefined;
+  if (enabled) {
+    if (!tiers?.some(isUltraFastDescriptor)) {
+      entry.service_tiers = [...(tiers ?? []), { ...NATIVE_ULTRAFAST_SERVICE_TIER }];
+      owned.add("service_tiers");
+    }
+    if (!speeds?.some(isUltraFastId)) {
+      entry.additional_speed_tiers = [...(speeds ?? []), NATIVE_ULTRAFAST_SERVICE_TIER.id];
+      owned.add("additional_speed_tiers");
+    }
+    if (owned.size > 0) entry[NATIVE_ULTRAFAST_PROVENANCE_FIELD] = [...owned].sort();
+    return;
+  }
+  delete entry[NATIVE_ULTRAFAST_PROVENANCE_FIELD];
+  if (owned.has("service_tiers") && tiers) {
+    const kept = tiers.filter(tier => !isGeneratedDescriptor(tier));
+    if (kept.length > 0) entry.service_tiers = kept;
+    else delete entry.service_tiers;
+  }
+  if (owned.has("additional_speed_tiers") && speeds) {
+    const kept = speeds.filter(speed => !isUltraFastId(speed));
+    if (kept.length > 0) entry.additional_speed_tiers = kept;
+    else delete entry.additional_speed_tiers;
+  }
+}