@bitkyc08/opencodex 2.41.0 → 2.43.0-preview.20260906

package/src/codex/catalog/effort.ts

@@ -35,7 +35,8 @@ import upstreamModelsSnapshot from "../data/upstream-models.json";
 import { generatedModelMetadata, readCatalog, readCodexCatalogPath } from "./parsing";
 import type { CatalogModel, RawEntry } from "./parsing";
 import { UPSTREAM_NATIVE_ENTRIES } from "./metadata";
-import { nativeOpenAiCapabilitySourceSlug } from "./native-models";
+import { nativeOpenAiCapabilitySourceSlug, SELF_DESCRIBED_NATIVE_OPENAI_MODELS, NATIVE_RESERVE_MODEL } from "./native-models";
+import { isReserveCatalogProjection } from "./reserve";
 import { loadBundledCodexCatalog } from "./bundled";
 import type { BundledCatalogDeps, ReadonlyRawCatalog } from "./bundled";
 import { deriveEntry } from "./sync";
@@ -158,11 +159,14 @@ export function applyCatalogModelMetadata(entry: RawEntry, model?: CatalogModel)
     entry.supports_reasoning_summaries = model.supportsReasoningSummaries;
   }
   if (model.supportsServiceTier === true) {
+    const nativeFast = model.codexForwardNativeCapabilityAlias && Array.isArray(entry.service_tiers)
+      ? entry.service_tiers.find(tier => tier?.id === "priority")
+      : undefined;
     entry.default_service_tier = null;
     entry.service_tiers = [{
       id: "priority",
       name: "Fast",
-      description: model.fastTierDescription ?? "1.5x speed, increased usage",
+      description: model.fastTierDescription ?? nativeFast?.description ?? "1.5x speed, increased usage",
     }];
     entry.additional_speed_tiers = ["fast"];
   }
@@ -258,8 +262,21 @@ export function applyReasoningLevels(
     : efforts.find(effort => effort !== "none" && effort !== "minimal") ?? efforts[0];
 }
 
+/**
+ * Native slugs entitled to the full GPT-5.6-era ladder (low..ultra, with max restored).
+ *
+ * The name is historical: membership is about the LADDER, not the model generation. `gpt-6-astra`
+ * qualifies because upstream ships it with the same six rungs
+ * (`supported_reasoning_levels` low/medium/high/xhigh/max/ultra, #42607). It used to qualify only
+ * as a side effect of borrowing Sol's capability source; once it became self-described that
+ * accident disappeared, and the sync path's else-branch
+ * (`applyReasoningLevels(entry, ["low","medium","high","xhigh"])`) would have truncated the
+ * shipped ladder, silently dropping `max` and `ultra`.
+ */
 export function isGpt56NativeSlug(slug: string): boolean {
-  return !slug.includes("/") && nativeOpenAiCapabilitySourceSlug(slug).startsWith("gpt-5.6-");
+  if (slug.includes("/")) return false;
+  if (SELF_DESCRIBED_NATIVE_OPENAI_MODELS.has(slug)) return true;
+  return nativeOpenAiCapabilitySourceSlug(slug).startsWith("gpt-5.6-");
 }
 
 export function ensureGpt56ReasoningLevels(entry: RawEntry): void {
@@ -324,6 +341,10 @@ export function clampedDefaultEffort(original: string, surviving: readonly strin
   return (atOrBelow.at(-1) ?? ranked[0]!).effort;
 }
 
+function requiresExactReserveEfforts(entry: RawEntry): boolean {
+  return entry.slug === NATIVE_RESERVE_MODEL || isReserveCatalogProjection(entry);
+}
+
 export function clampEntryToCodexSupportedEfforts(
   entry: RawEntry,
   supported: ReadonlySet<string> | null,
@@ -334,6 +355,19 @@ export function clampEntryToCodexSupportedEfforts(
     : null;
   if (levels && levels.length > 0) {
     const kept = levels.filter(level => typeof level?.effort === "string" && supported.has(level.effort));
+    if (requiresExactReserveEfforts(entry)) {
+      entry.supported_reasoning_levels = kept;
+      if (kept.length === 0) {
+        // The list-level clamp removes this incompatible row; never invent another ladder.
+        delete entry.default_reasoning_level;
+      } else if (!kept.some(level => level.effort === entry.default_reasoning_level)) {
+        entry.default_reasoning_level = clampedDefaultEffort(
+          typeof entry.default_reasoning_level === "string" ? entry.default_reasoning_level : "",
+          kept.map(level => level.effort!),
+        );
+      }
+      return;
+    }
     entry.supported_reasoning_levels = kept.length > 0
       ? kept
       : CODEX_REASONING_LEVELS
@@ -364,7 +398,9 @@ export function clampCatalogModelsToObservedCodexSupport(
 
   const removed = new Set<string>();
   const affected: string[] = [];
-  for (const entry of models) {
+  for (let index = 0; index < models.length;) {
+    const entry = models[index]!;
+    const hadLadder = Array.isArray(entry.supported_reasoning_levels) && entry.supported_reasoning_levels.length > 0;
     const before = new Set(
       (Array.isArray(entry.supported_reasoning_levels) ? entry.supported_reasoning_levels : [])
         .flatMap(level => typeof (level as { effort?: string })?.effort === "string"
@@ -386,11 +422,14 @@ export function clampCatalogModelsToObservedCodexSupport(
       : null;
     const lost = [...before].filter(effort => !after.has(effort));
     const defaultClamped = Boolean(beforeDefault && beforeDefault !== afterDefault);
-    if (lost.length > 0 || defaultClamped) {
+    const omitted = requiresExactReserveEfforts(entry) && hadLadder && after.size === 0;
+    if (lost.length > 0 || defaultClamped || omitted) {
       for (const effort of lost) removed.add(effort);
       if (defaultClamped && beforeDefault) removed.add(beforeDefault);
       if (typeof entry.slug === "string") affected.push(entry.slug);
     }
+    if (omitted) models.splice(index, 1);
+    else index += 1;
   }
 
   return {

package/src/codex/catalog/metadata.ts

@@ -38,13 +38,19 @@ 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 { RESERVE_METADATA_SOURCE_FIELD } from "./reserve";
 import {
   ACCOUNT_GATED_NATIVE_OPENAI_MODELS,
   NATIVE_DAYBREAK_BLUE_MODEL,
+  NATIVE_GPT6_ASTRA_MODEL,
+  NATIVE_RESERVE_MODEL,
   NATIVE_OPENAI_CAPABILITY_ALIAS_MODELS,
   NATIVE_OPENAI_MODELS,
+  SELF_DESCRIBED_NATIVE_OPENAI_MODELS,
   SUPPORTED_NATIVE_OPENAI_SLUGS,
+  hasNativeOpenAiCapabilityMetadata,
   isNativeOpenAiCapabilityAliasModel,
+  nativeOpenAiAliasPresentation,
   nativeOpenAiCapabilitySourceSlug,
 } from "./native-models";
 import { cachedAvailableAccountGatedNativeModels } from "../model-entitlements";
@@ -52,16 +58,22 @@ import { MAIN_CODEX_ACCOUNT_ID } from "../main-account";
 export { CODEX_NATIVE_ALIAS_CATALOG_KIND } from "./kinds";
 export {
   NATIVE_DAYBREAK_BLUE_MODEL,
+  NATIVE_GPT6_ASTRA_MODEL,
   NATIVE_OPENAI_CAPABILITY_ALIAS_MODELS,
   NATIVE_OPENAI_MODELS,
+  SELF_DESCRIBED_NATIVE_OPENAI_MODELS,
   SUPPORTED_NATIVE_OPENAI_SLUGS,
+  hasNativeOpenAiCapabilityMetadata,
   isNativeOpenAiCapabilityAliasModel,
+  nativeOpenAiAliasPresentation,
   nativeOpenAiCapabilitySourceSlug,
 } from "./native-models";
 
 export const DOCUMENTED_NATIVE_OPENAI_ADDITIONS = [
   "gpt-5.3-codex-spark",
   "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna",
+  // The shipped pin also backfills older installed Codex catalogs that predate Astra.
+  NATIVE_GPT6_ASTRA_MODEL,
 ];
 
 export function configuredNativeAliasSlugs(
@@ -161,6 +173,12 @@ export const NATIVE_OPENAI_CONTEXT_OVERRIDES: Record<string, { contextWindow?: n
   // ChatGPT account."`), so the promotion rests on a report from an account that has
   // access rather than on a probe. Treat it as the weaker evidence of the four.
   [NATIVE_DAYBREAK_BLUE_MODEL]: { contextWindow: NATIVE_GPT56_CONTEXT_WINDOW, maxContextWindow: NATIVE_GPT56_MAX_INPUT_TOKENS, maxInputTokens: NATIVE_GPT56_MAX_INPUT_TOKENS },
+  // gpt-6-astra ships its own numbers (upstream models.json, #42607): a 272,000 default window
+  // against an 872,000 ceiling. It is NOT in NATIVE_GPT56_FAMILY, so it must not inherit that
+  // family's measured 922,000 clamp — advertising 922,000 here over-stated the ceiling by 50k.
+  // maxInputTokens is clamped to the resolved window by nativeOpenAiMaxInputTokens, so this reads
+  // 272,000 by default and 872,000 only under the long-window opt-in.
+  [NATIVE_GPT6_ASTRA_MODEL]: { contextWindow: 272_000, maxContextWindow: 872_000, maxInputTokens: 872_000 },
 };
 
 const PINNED_UPSTREAM_MODELS: Map<string, RawEntry> = new Map(
@@ -246,13 +264,36 @@ export function nativeContextLimits(
 }
 
 /** Apply the user levers to an authoritative value. */
+/**
+ * The ceiling a native slug may be RAISED to by a user lever, or undefined when it has no
+ * separate long window.
+ *
+ * This is what makes the dashboard's 1M opt-in work: without an opt-in ceiling a lever can only
+ * ever narrow the advertised window, so the toggle would appear to do nothing. The GPT-5.6 family
+ * shares one measured ceiling; a self-described native carries its own in
+ * `NATIVE_OPENAI_CONTEXT_OVERRIDES.maxContextWindow` (`gpt-6-astra` ships 872,000 against a
+ * 272,000 default), and reading it per-slug is what keeps the toggle honest for a model whose
+ * ceiling is not the family's.
+ */
+function longWindowOptInCeiling(slug: string): number | undefined {
+  if (NATIVE_GPT56_FAMILY.has(slug)) return NATIVE_GPT56_MAX_INPUT_TOKENS;
+  const override = NATIVE_OPENAI_CONTEXT_OVERRIDES[slug];
+  const defaultWindow = positiveInt(override?.contextWindow);
+  const longWindow = positiveInt(override?.maxContextWindow);
+  if (defaultWindow === undefined || longWindow === undefined || longWindow <= defaultWindow) {
+    return undefined;
+  }
+  return longWindow;
+}
+
 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);
-  if (NATIVE_GPT56_FAMILY.has(slug)) {
-    const ceiling = NATIVE_GPT56_MAX_INPUT_TOKENS;
+  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;
@@ -496,15 +537,23 @@ export function applyNativeVisibility(
 
 function upstreamNativeEntryForSlug(slug: string): RawEntry | undefined {
   const sourceSlug = nativeOpenAiCapabilitySourceSlug(slug);
-  if (!sourceSlug.startsWith("gpt-5.6-")) return undefined;
+  // A self-described native returns its OWN pinned row; the alias-cloning branch below stays
+  // reserved for slugs that genuinely borrow another model's identity. The allowlist is explicit
+  // rather than "has a pinned entry", which would also admit gpt-5.5/gpt-5.4/gpt-5.4-mini into
+  // the sync-replacement authority this map carries.
+  if (!sourceSlug.startsWith("gpt-5.6-") && !SELF_DESCRIBED_NATIVE_OPENAI_MODELS.has(slug)) {
+    return undefined;
+  }
   const source = PINNED_UPSTREAM_MODELS.get(sourceSlug);
   if (!source) return undefined;
-  if (slug === sourceSlug) return source;
+  if (slug === sourceSlug) return withDerivedBaseInstructions(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.";
+  const presentation = nativeOpenAiAliasPresentation(slug);
+  if (!presentation) return undefined; // an alias with no product identity must not ship a wrong one
+  alias.display_name = presentation.displayName;
+  alias.description = presentation.description;
   if (typeof alias.base_instructions === "string") {
     alias.base_instructions = identifyRoutedModel(alias.base_instructions, slug);
   }
@@ -521,6 +570,27 @@ function upstreamNativeEntryForSlug(slug: string): RawEntry | undefined {
   return alias;
 }
 
+/**
+ * Backfill `base_instructions` from `model_messages.instructions_template` when upstream ships
+ * only the latter.
+ *
+ * `gpt-6-astra` is the first pinned row to arrive without a top-level `base_instructions`; every
+ * other native carries both. That field is not decorative here — `hasNativeCatalogRowShape`,
+ * `findNativeTemplate` and `findSupportedNativeTemplate` all test for it, so a row missing it is
+ * not recognized as a native catalog row at all. The two fields hold the same prompt upstream, so
+ * deriving one from the other preserves upstream's content while keeping this codebase's row
+ * shape intact. The pinned JSON is left byte-identical to upstream; only the projection fills in.
+ */
+function withDerivedBaseInstructions(entry: RawEntry): RawEntry {
+  if (typeof entry.base_instructions === "string" && entry.base_instructions.length > 0) return entry;
+  const messages = entry.model_messages;
+  const template = messages && typeof messages === "object" && !Array.isArray(messages)
+    ? (messages as Record<string, unknown>).instructions_template
+    : undefined;
+  if (typeof template !== "string" || template.length === 0) return entry;
+  return { ...entry, base_instructions: template };
+}
+
 export const UPSTREAM_NATIVE_ENTRIES: Map<string, RawEntry> = new Map(
   [...NATIVE_OPENAI_MODELS, ...NATIVE_OPENAI_CAPABILITY_ALIAS_MODELS].flatMap(slug => {
     const entry = upstreamNativeEntryForSlug(slug);
@@ -536,10 +606,44 @@ export function upstreamNativeEntry(slug: string): RawEntry | null {
   return clone;
 }
 
+/**
+ * Product label for a native slug whose custom row inherits native metadata.
+ *
+ * An alias carries a hand-written presentation because upstream never described it. A
+ * self-described native gets its label from its own pinned row instead, so the two kinds answer
+ * through one accessor and no caller has to know which it holds.
+ */
+export function nativeOpenAiCapabilityDisplayName(slug: string): string | undefined {
+  const presentation = nativeOpenAiAliasPresentation(slug);
+  if (presentation) return presentation.displayName;
+  const pinned = UPSTREAM_NATIVE_ENTRIES.get(slug);
+  return typeof pinned?.display_name === "string" ? pinned.display_name : undefined;
+}
+
+/**
+ * Slugs whose persisted row may be replaced by the pinned snapshot even when it carries a real
+ * display name — because THIS codebase wrote that name from a guess.
+ *
+ * `shouldUpgradeToUpstreamEntry`'s normal rule ("upgrade only fallback-quality rows, where
+ * `display_name === slug`") assumes any row with a real label came from upstream and is therefore
+ * authoritative. That assumption broke for `gpt-6-astra`: opencodex shipped a speculative row with
+ * a hand-written "GPT-6 Astra" label and a provisional description while the slug was still a leak.
+ * Those rows are already on disk in every install that ran that release, and they look genuine, so
+ * without this list they would survive every future sync and permanently shadow the real shipped
+ * metadata — the wrong label, the wrong 922k ceiling, the wrong priority.
+ *
+ * Membership is a statement about opencodex's own history, not about upstream. Add a slug only
+ * when a released version of this project wrote a fabricated row for it.
+ */
+const SELF_AUTHORED_NATIVE_ROWS: ReadonlySet<string> = new Set([NATIVE_GPT6_ASTRA_MODEL]);
+
 export function shouldUpgradeToUpstreamEntry(entry: RawEntry): boolean {
-  return typeof entry.slug === "string"
-    && UPSTREAM_NATIVE_ENTRIES.has(entry.slug)
-    && entry.display_name === entry.slug;
+  if (typeof entry.slug !== "string" || !UPSTREAM_NATIVE_ENTRIES.has(entry.slug)) return false;
+  if (entry.display_name === entry.slug) return true;
+  // A row this project authored from a guess is not evidence of upstream truth, however genuine
+  // its display name looks. Replace it once, from the pin.
+  return SELF_AUTHORED_NATIVE_ROWS.has(entry.slug)
+    && entry.display_name !== UPSTREAM_NATIVE_ENTRIES.get(entry.slug)?.display_name;
 }
 
 export function nativeOpenAiSlugs(): string[] {
@@ -566,7 +670,7 @@ function isAccountBoundOpenAiNativeSlug(slug: string): boolean {
  * malformed and minimal hand-written rows. It cannot distinguish a genuine upstream observation
  * from a complete row typed by hand into `$CODEX_HOME/models_cache.json`: there is no signature,
  * source identity, or server attestation to check. A full-shape forged row is accepted, and
- * `observedFullShapeRowIsAccepted` in tests/native-model-toggle.test.ts pins that so nobody
+ * `observedFullShapeRowIsAccepted` in tests/codex-integration/native-model-toggle.test.ts pins that so nobody
  * later mistakes this predicate for a security boundary.
  *
  * That is acceptable here because the file is user-owned and written by Codex itself: anyone
@@ -595,14 +699,44 @@ function observedAccountBoundNativeSlug(entry: RawEntry): string | undefined {
   const accountBound = trustedAccountBoundNativeCatalogSlug(entry);
   const slug = accountBound ?? (typeof entry.slug === "string" ? entry.slug : "");
   if (!isAccountBoundOpenAiNativeSlug(slug)
-    || entry.supported_in_api !== true
+    || (entry.supported_in_api !== true && !(slug === NATIVE_RESERVE_MODEL && entry.supported_in_api === false))
+    || (slug === NATIVE_RESERVE_MODEL && entry[RESERVE_METADATA_SOURCE_FIELD] !== undefined
+      && entry[RESERVE_METADATA_SOURCE_FIELD] !== NATIVE_RESERVE_MODEL)
     || !hasNativeCatalogRowShape(entry)
-    || (entry.visibility !== "list" && entry[ACCOUNT_BOUND_OBSERVED_NATIVE_MARKER] !== true)) {
+    || (entry.visibility !== "list" && entry[ACCOUNT_BOUND_OBSERVED_NATIVE_MARKER] !== true
+      && !(slug === NATIVE_RESERVE_MODEL && entry.visibility === "hide"))) {
     return undefined;
   }
   return slug;
 }
 
+/** Prefer a genuine bare observation; an adapted OCX row must never become native evidence. */
+export function observedReserveCatalogSource(
+  entries: readonly RawEntry[],
+  mainSelectors: readonly string[],
+): RawEntry | null {
+  const actual = entries.filter(entry => observedAccountBoundNativeSlug(entry) === NATIVE_RESERVE_MODEL);
+  const bare = actual.find(entry => entry.slug === NATIVE_RESERVE_MODEL);
+  const qualified = actual.find(entry => entry[RESERVE_METADATA_SOURCE_FIELD] === NATIVE_RESERVE_MODEL
+    && typeof entry.slug === "string"
+    && mainSelectors.includes(entry.slug.slice(0, entry.slug.indexOf("/"))));
+  const selected = bare ?? qualified;
+  if (!selected) return null;
+  const source = structuredClone(selected);
+  if (!bare) {
+    const prefix = `${String(source.slug).split("/")[0]} / `;
+    if (typeof source.display_name === "string" && source.display_name.startsWith(prefix)) {
+      source.display_name = source.display_name.slice(prefix.length);
+    }
+  }
+  source.slug = NATIVE_RESERVE_MODEL;
+  delete source.opencodex_catalog_kind;
+  delete source[RESERVE_METADATA_SOURCE_FIELD];
+  delete source[ACCOUNT_BOUND_OBSERVED_NATIVE_MARKER];
+  delete source[ACCOUNT_BOUND_OBSERVED_SELECTORS_MARKER];
+  return source;
+}
+
 /**
  * Return exact, previously observed account-native rows that are not in the static release set.
  * The result is used only to carry a hidden observation across startup cache invalidation.
@@ -643,7 +777,8 @@ export function accountBoundNativeOpenAiSlugs(
 ): string[] {
   const observed = observedEntries.flatMap(entry => {
     const slug = observedAccountBoundNativeSlug(entry);
-    return slug === undefined ? [] : [slug];
+    // Reserve belongs only to the Codex-specific opt-in builder, not generic native exports.
+    return slug === undefined || slug === NATIVE_RESERVE_MODEL ? [] : [slug];
   });
   return unique([...NATIVE_OPENAI_MODELS, ...observed]);
 }
@@ -670,7 +805,7 @@ export function accountBoundNativeOpenAiSlugsBySelector(
   );
   for (const entry of observedEntries) {
     const slug = observedAccountBoundNativeSlug(entry);
-    if (slug === undefined || SUPPORTED_NATIVE_OPENAI_SLUGS.has(slug)) continue;
+    if (slug === undefined || slug === NATIVE_RESERVE_MODEL || SUPPORTED_NATIVE_OPENAI_SLUGS.has(slug)) continue;
     const generated = trustedAccountBoundNativeCatalogSlug(entry);
     const generatedSelector = generated === undefined || typeof entry.slug !== "string"
       ? undefined

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

@@ -1,11 +1,53 @@
+/** Reserve wire identity, not a globally available native catalog registration. */
+export const NATIVE_RESERVE_MODEL = "gpt-reserve";
+
 /** ChatGPT/Codex wire id observed for the account-native Daybreak Blue surface. */
 export const NATIVE_DAYBREAK_BLUE_MODEL = "gpt-daybreak-blue-latest";
 
-/** Native ChatGPT/Codex ids whose availability is proven per authenticated account. */
+/**
+ * SHIPPED as of 2026-09-03: openai/codex `ed391d4dd` (#42607, bundled model catalog) and
+ * `1f7b99922` (#42619, Amazon Bedrock catalogs). The registration is no longer speculative —
+ * `src/codex/data/upstream-models.json` now pins the real row, so this slug is SELF-DESCRIBED
+ * and must not borrow another model's capability metadata.
+ *
+ * Still NOT wire-normalized: unlike Daybreak the slug IS the wire id.
+ *
+ * Deliberately NOT account-gated (owner decision, 2026-09-04, reaffirmed during rollout).
+ * Upstream `available_in_plans` lists 23 plans including `free`, but the model is rolling out,
+ * so a given account's Codex surface may still answer
+ * `"The 'gpt-6-astra' model is not supported when using Codex with a ChatGPT account."`
+ * — the same refusal Daybreak returns. Gating on an entitlement roster would hide the row until
+ * that roster catches up; listing it means the request dispatches and the real upstream status
+ * is what the user sees. Evidence: devlog/_plan/260904_astra_release_alignment/021.
+ */
+export const NATIVE_GPT6_ASTRA_MODEL = "gpt-6-astra";
+
+/**
+ * Native ChatGPT/Codex ids whose availability is proven per authenticated account.
+ *
+ * Membership is expensive: it hides the row from the catalog, `/v1/models`, the dashboard and
+ * the desktop projection until an authenticated `/models` roster confirms it, AND it makes
+ * `auth-context.ts` refuse the request before it is sent. Both halves fail closed on ABSENCE of
+ * evidence, not on a denial.
+ *
+ * The flagship models are deliberately NOT here (owner decision, 2026-09-04). #3442 made
+ * discovery ask upstream under an adequate client version, which guarantees the QUESTION is
+ * fair but cannot guarantee an ANSWER: an unconfirmed account, a timed-out fetch, or a shard
+ * that has not caught up all produce the same silent disappearance, and a model vanishing from
+ * the picker reads as "opencodex lost my model" rather than "upstream did not confirm it".
+ * Listing them unconditionally means the request dispatches and the user sees the real upstream
+ * status. `disabledModels` remains the visibility lever.
+ *
+ * The cost, accepted knowingly: Pool routing no longer prefers an account that owns the model,
+ * so a multi-account user may take one upstream 400 and one alternate retry where they used to
+ * be routed straight to the owner. Nothing unsafe — each account still sends its own credential
+ * — and `gpt-6-astra` has shipped this way since 6f634eddc.
+ *
+ * `gpt-daybreak-blue-latest` stays gated. It has no shipped catalog row anywhere, so absence is
+ * the only signal that exists for it, and the ungating decision was scoped to the flagships.
+ * Evidence: devlog/_plan/260904_flagship_native_always_visible/.
+ */
 export const ACCOUNT_GATED_NATIVE_OPENAI_MODELS: ReadonlySet<string> = new Set([
-  "gpt-5.6-sol",
-  "gpt-5.6-terra",
-  "gpt-5.6-luna",
   NATIVE_DAYBREAK_BLUE_MODEL,
 ]);
 
@@ -25,6 +67,19 @@ const NATIVE_OPENAI_CAPABILITY_SOURCES: Readonly<Record<string, string>> = Objec
   [NATIVE_DAYBREAK_BLUE_MODEL]: "gpt-5.6-sol",
 });
 
+/**
+ * Native slugs that carry their OWN pinned upstream row rather than an alias's borrowed one.
+ *
+ * Membership authorizes `upstreamNativeEntryForSlug` to return the pinned entry directly. It is
+ * an explicit list, not a structural `PINNED_UPSTREAM_MODELS.has(slug)` predicate: the pin also
+ * holds `gpt-5.5`, `gpt-5.4` and `gpt-5.4-mini`, and admitting those into
+ * `UPSTREAM_NATIVE_ENTRIES` would newly authorize replacing their persisted catalog rows during
+ * sync — an invariant that map's own comment reserves for the GPT-5.6 family.
+ */
+export const SELF_DESCRIBED_NATIVE_OPENAI_MODELS: ReadonlySet<string> = new Set([
+  NATIVE_GPT6_ASTRA_MODEL,
+]);
+
 /**
  * Native ids whose capability metadata is inherited from another pinned native row.
  *
@@ -46,10 +101,41 @@ export function isNativeOpenAiCapabilityAliasModel(slug: string): boolean {
   return Object.hasOwn(NATIVE_OPENAI_CAPABILITY_SOURCES, slug);
 }
 
+/**
+ * Native slugs whose Codex-forward CUSTOM row inherits authoritative native metadata.
+ *
+ * Two shapes qualify and the distinction matters only to `upstreamNativeEntryForSlug`:
+ * a capability ALIAS borrows another model's pinned row, while a SELF-DESCRIBED native has its
+ * own. Every consumer that asks "does this custom row get real native capabilities and a real
+ * product label" wants both, which is why they call this rather than the alias check —
+ * `gpt-6-astra` stopped being an alias when its own row was pinned, and gating on
+ * `isNativeOpenAiCapabilityAliasModel` alone would have silently demoted it to a bare-slug label
+ * with no inherited ladder.
+ */
+export function hasNativeOpenAiCapabilityMetadata(slug: string): boolean {
+  return isNativeOpenAiCapabilityAliasModel(slug) || SELF_DESCRIBED_NATIVE_OPENAI_MODELS.has(slug);
+}
+
 export function nativeOpenAiCapabilitySourceSlug(slug: string): string {
   return NATIVE_OPENAI_CAPABILITY_SOURCES[slug] ?? slug;
 }
 
+/**
+ * Presentation identity per capability alias. Capability metadata (context, ladder, modalities)
+ * is inherited from the source model; the NAME and description are the alias's own product
+ * identity — hardcoding one alias's label would present every other alias as the wrong product.
+ */
+export const NATIVE_OPENAI_ALIAS_PRESENTATION: Readonly<Record<string, { displayName: string; description: string }>> = Object.freeze({
+  [NATIVE_DAYBREAK_BLUE_MODEL]: {
+    displayName: "Daybreak Blue",
+    description: "Frontier general-purpose model with safeguards for defensive cybersecurity work.",
+  },
+});
+
+export function nativeOpenAiAliasPresentation(slug: string): { displayName: string; description: string } | undefined {
+  return NATIVE_OPENAI_ALIAS_PRESENTATION[slug];
+}
+
 /**
  * Native OpenAI model ids that this release can route and restore with authoritative metadata.
  *
@@ -70,6 +156,32 @@ export const NATIVE_OPENAI_MODELS = [
   "gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex-spark",
   "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna",
   NATIVE_DAYBREAK_BLUE_MODEL,
+  NATIVE_GPT6_ASTRA_MODEL,
 ];
 
 export const SUPPORTED_NATIVE_OPENAI_SLUGS = new Set(NATIVE_OPENAI_MODELS);
+
+/**
+ * Natives that retain the physical main account as a read-free sentinel during a native-main
+ * drain, instead of reading as unavailable and letting the subagent fallback chain advance.
+ *
+ * This used to be spelled `ACCOUNT_GATED_NATIVE_OPENAI_MODELS`, which was never what it meant:
+ * the sentinel protects the atomic main claim so a routed fallback cannot bypass it, and that
+ * has nothing to do with entitlement. The two sets were identical in practice, so the accident
+ * went unnoticed until the flagships were ungated (2026-09-04) and the predicate would have
+ * flipped false — letting a drain silently rewrite the operator's configured subagent model.
+ *
+ * It is an explicit list rather than `SUPPORTED_NATIVE_OPENAI_SLUGS`, which would have widened
+ * the sentinel to `gpt-5.5`, `gpt-5.4`, `gpt-5.4-mini` and `gpt-5.3-codex-spark` as well. Those
+ * models were never covered, and widening would turn "fell back and answered" into a
+ * maintenance error for the most commonly configured fallback slug in the repo. Membership is
+ * the set the drain behaviour was actually reasoned about: the account-gated natives plus the
+ * flagships that just left that set.
+ */
+export const NATIVE_MAIN_DRAIN_SENTINEL_MODELS: ReadonlySet<string> = new Set([
+  ...ACCOUNT_GATED_NATIVE_OPENAI_MODELS,
+  "gpt-5.6-sol",
+  "gpt-5.6-terra",
+  "gpt-5.6-luna",
+  NATIVE_GPT6_ASTRA_MODEL,
+]);