@bitkyc08/opencodex 2.11.0 → 2.11.1

package/src/codex/catalog/effort.ts

@@ -9,7 +9,7 @@ import { buildModelsRequest, resolveModelsAuthToken } from "../../oauth";
 import type { OcxConfig, OcxProviderConfig } from "../../types";
 import { modelInList } from "../../types";
 import { CODEX_REASONING_LEVELS, codexEffortRank, configuredReasoningEfforts, modelRecordValue, sanitizeCodexReasoningEfforts } from "../../reasoning-effort";
-import { getJawcodeModelMetadata, getJawcodeModelMetadataCaseInsensitive, listJawcodeModelMetadata, resolveJawcodeProvider } from "../../generated/jawcode-model-metadata";
+import { getModelMetadata, getModelMetadataCaseInsensitive, listModelMetadata, resolveMetadataProvider } from "../../generated/model-metadata";
 import { enrichProviderFromRegistry, shouldCaseFoldMetadataModelId } from "../../providers/derive";
 import { getProviderRegistryEntry } from "../../providers/registry";
 import { applyProviderContextCap, providerContextCap } from "../../providers/context-cap";
@@ -35,7 +35,7 @@ import { readCatalog, readCodexCatalogPath } from "./parsing";
 import type { CatalogModel, RawEntry } from "./parsing";
 import { UPSTREAM_NATIVE_ENTRIES } from "./metadata";
 import { loadBundledCodexCatalog } from "./bundled";
-import type { BundledCatalogDeps } from "./bundled";
+import type { BundledCatalogDeps, ReadonlyRawCatalog } from "./bundled";
 import { deriveEntry } from "./sync";
 import {
   formatClampLogLines,
@@ -116,10 +116,9 @@ export function applyCatalogModelMetadata(entry: RawEntry, model?: CatalogModel)
   if (model.provider === COMBO_NAMESPACE) entry.owned_by = model.owned_by ?? COMBO_NAMESPACE;
   // displayName is DISPLAY-ONLY: it relabels the picker row but never touches the routing
   // slug, alias, or provider. deriveEntry already stamped the slug as display_name; a
-  // configured displayName overrides just the label. The `/` separator is rejected at every
-  // input boundary (CLI `ocx models add`, management API), so the catalog trusts its source.
-  // Combos carry no displayName, and natives never reach here (no CatalogModel), so genuine
-  // upstream marketing names and combo alias labels are preserved untouched.
+  // configured displayName overrides just the label. Custom-model inputs reject `/`; combos
+  // validate their bounded display label independently. Natives never reach here (no CatalogModel),
+  // so genuine upstream marketing names are preserved untouched.
   const displayName = typeof model.displayName === "string" ? model.displayName.trim() : "";
   if (displayName) entry.display_name = displayName;
   if (typeof model.contextWindow === "number" && model.contextWindow > 0) {
@@ -214,11 +213,13 @@ export function ensureUltraReasoningLevel(entry: RawEntry): void {
   entry.supported_reasoning_levels = levels;
 }
 
-export function codexSupportedReasoningEfforts(deps: BundledCatalogDeps = {}): Set<string> | null {
-  const bundled = loadBundledCodexCatalog(deps);
-  if (!bundled) return null;
+/** Derive the installed Codex effort vocabulary from caller-observed bundled catalog bytes. */
+export function supportedCodexReasoningEffortsFromObservedCatalog(
+  catalog: ReadonlyRawCatalog | null,
+): ReadonlySet<string> | null {
+  if (!catalog) return null;
   const efforts = new Set<string>();
-  for (const model of bundled.models ?? []) {
+  for (const model of catalog.models ?? []) {
     if (typeof model.slug !== "string" || model.slug.includes("/")) continue;
     const levels = Array.isArray(model.supported_reasoning_levels) ? model.supported_reasoning_levels : [];
     for (const level of levels) {
@@ -230,6 +231,10 @@ export function codexSupportedReasoningEfforts(deps: BundledCatalogDeps = {}): S
   return efforts.size > 0 ? efforts : null;
 }
 
+export function codexSupportedReasoningEfforts(deps: BundledCatalogDeps = {}): ReadonlySet<string> | null {
+  return supportedCodexReasoningEffortsFromObservedCatalog(loadBundledCodexCatalog(deps));
+}
+
 export function clampedDefaultEffort(original: string, surviving: readonly string[]): string {
   if (surviving.length === 0) return "medium";
   const ranked = [...surviving]
@@ -240,7 +245,10 @@ export function clampedDefaultEffort(original: string, surviving: readonly strin
   return (atOrBelow.at(-1) ?? ranked[0]!).effort;
 }
 
-export function clampEntryToCodexSupportedEfforts(entry: RawEntry, supported: Set<string> | null): void {
+export function clampEntryToCodexSupportedEfforts(
+  entry: RawEntry,
+  supported: ReadonlySet<string> | null,
+): void {
   if (!supported) return;
   const levels = Array.isArray(entry.supported_reasoning_levels)
     ? entry.supported_reasoning_levels as Array<{ effort?: string }>
@@ -263,12 +271,17 @@ export function clampEntryToCodexSupportedEfforts(entry: RawEntry, supported: Se
   }
 }
 
-export function clampCatalogModelsToCodexSupport(models: RawEntry[], deps: BundledCatalogDeps = {}): RawEntry[] {
-  const supported = codexSupportedReasoningEfforts(deps);
-  if (!supported) {
-    if (!deps.commandCandidates) persistEffortClamp(null, { configDir: deps.configDir });
-    return models;
-  }
+export interface ObservedCatalogEffortClamp {
+  readonly removedEfforts: readonly string[];
+  readonly affectedModels: readonly string[];
+}
+
+/** Apply an already-observed runtime ladder without probing, logging, or writing diagnostics. */
+export function clampCatalogModelsToObservedCodexSupport(
+  models: RawEntry[],
+  supported: ReadonlySet<string> | null,
+): ObservedCatalogEffortClamp {
+  if (!supported) return { removedEfforts: [], affectedModels: [] };
 
   const removed = new Set<string>();
   const affected: string[] = [];
@@ -301,6 +314,20 @@ export function clampCatalogModelsToCodexSupport(models: RawEntry[], deps: Bundl
     }
   }
 
+  return {
+    removedEfforts: [...removed].sort(),
+    affectedModels: affected,
+  };
+}
+
+export function clampCatalogModelsToCodexSupport(models: RawEntry[], deps: BundledCatalogDeps = {}): RawEntry[] {
+  const supported = codexSupportedReasoningEfforts(deps);
+  if (!supported) {
+    if (!deps.commandCandidates) persistEffortClamp(null, { configDir: deps.configDir });
+    return models;
+  }
+  const clamp = clampCatalogModelsToObservedCodexSupport(models, supported);
+
   let runtimePath = "codex";
   let runtimeVersion: string | null = null;
   if (!deps.commandCandidates) {
@@ -337,12 +364,12 @@ export function clampCatalogModelsToCodexSupport(models: RawEntry[], deps: Bundl
     }
   }
 
-  if (removed.size > 0) {
+  if (clamp.removedEfforts.length > 0) {
     const diagnostic: EffortClampDiagnostic = {
       runtimePath,
       runtimeVersion,
-      removedEfforts: [...removed].sort(),
-      affectedModels: affected,
+      removedEfforts: [...clamp.removedEfforts],
+      affectedModels: [...clamp.affectedModels],
     };
     for (const line of formatClampLogLines(diagnostic)) console.warn(line);
     if (!deps.commandCandidates) persistEffortClamp(diagnostic, { configDir: deps.configDir });

package/src/codex/catalog/kinds.ts

@@ -0,0 +1,2 @@
+/** Stable ownership marker for a routed combo that deliberately owns a bare native slug. */
+export const CODEX_NATIVE_ALIAS_CATALOG_KIND = "combo-native-alias-v1";

package/src/codex/catalog/metadata.ts

@@ -9,7 +9,7 @@ import { buildModelsRequest, resolveModelsAuthToken } from "../../oauth";
 import type { OcxConfig, OcxProviderConfig } from "../../types";
 import { modelInList } from "../../types";
 import { CODEX_REASONING_LEVELS, codexEffortRank, configuredReasoningEfforts, modelRecordValue, sanitizeCodexReasoningEfforts } from "../../reasoning-effort";
-import { getJawcodeModelMetadata, getJawcodeModelMetadataCaseInsensitive, listJawcodeModelMetadata, resolveJawcodeProvider } from "../../generated/jawcode-model-metadata";
+import { getModelMetadata, getModelMetadataCaseInsensitive, listModelMetadata, resolveMetadataProvider } from "../../generated/model-metadata";
 import { enrichProviderFromRegistry, shouldCaseFoldMetadataModelId } from "../../providers/derive";
 import { getProviderRegistryEntry } from "../../providers/registry";
 import { applyProviderContextCap, providerContextCap } from "../../providers/context-cap";
@@ -22,6 +22,7 @@ import {
   COMBO_NAMESPACE,
   comboModelId,
   getCombo,
+  isNativeAliasCombo,
   listComboIds,
   targetKey,
 } from "../../combos";
@@ -34,18 +35,48 @@ import upstreamModelsSnapshot from "../data/upstream-models.json";
 import type { RawEntry } from "./parsing";
 import { readCurrentCatalogOrCache, unique } from "./bundled";
 import { trustedAccountBoundNativeCatalogSlug } from "./account-models";
-
-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",
-];
+import { CODEX_NATIVE_ALIAS_CATALOG_KIND } from "./kinds";
+import { NATIVE_OPENAI_MODELS, SUPPORTED_NATIVE_OPENAI_SLUGS } from "./native-models";
+export { CODEX_NATIVE_ALIAS_CATALOG_KIND } from "./kinds";
+export { NATIVE_OPENAI_MODELS, SUPPORTED_NATIVE_OPENAI_SLUGS } 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",
 ];
 
-export const SUPPORTED_NATIVE_OPENAI_SLUGS = new Set(NATIVE_OPENAI_MODELS);
+export function configuredNativeAliasSlugs(
+  config: Pick<OcxConfig, "combos">,
+): Set<string> {
+  const aliases = new Set<string>();
+  for (const raw of Object.values(config.combos ?? {})) {
+    if (!isNativeAliasCombo(raw)) continue;
+    const alias = raw.alias!.trim();
+    if (SUPPORTED_NATIVE_OPENAI_SLUGS.has(alias)) aliases.add(alias);
+  }
+  return aliases;
+}
+
+/**
+ * Bare native rows that must be absent, rather than merely hidden, while Desktop native-alias
+ * compatibility is active. Codex Desktop's remote allowlist can ignore `visibility: "hide"`;
+ * omitting disabled native rows is therefore part of the explicit native-alias opt-in.
+ */
+export function desktopAllowlistSuppressedNativeSlugs(
+  config: Pick<OcxConfig, "combos" | "disabledModels">,
+): Set<string> {
+  const suppressed = configuredNativeAliasSlugs(config);
+  if (suppressed.size === 0) return suppressed;
+  const disabled = disabledNativeSlugs(config);
+  for (const slug of NATIVE_OPENAI_MODELS) {
+    if (disabled.has(slug)) suppressed.add(slug);
+  }
+  return suppressed;
+}
+
+export function isNativeAliasCatalogEntry(entry: RawEntry): boolean {
+  return entry.opencodex_catalog_kind === CODEX_NATIVE_ALIAS_CATALOG_KIND;
+}
 
 export function isUnsupportedOpenAiNativeSlug(slug: string): boolean {
   if (slug.includes("/")) return false;
@@ -64,15 +95,27 @@ export const NATIVE_OPENAI_CONTEXT_OVERRIDES: Record<string, { contextWindow?: n
   "gpt-5.6-luna": { contextWindow: NATIVE_GPT56_CONTEXT_WINDOW, maxContextWindow: NATIVE_GPT56_CONTEXT_WINDOW },
 };
 
+/**
+ * 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]),
+);
+
 export function nativeOpenAiContextWindow(slug: string): number | undefined {
   return NATIVE_OPENAI_CONTEXT_OVERRIDES[slug]?.contextWindow
-    ?? (typeof UPSTREAM_NATIVE_ENTRIES.get(slug)?.context_window === "number"
-      ? UPSTREAM_NATIVE_ENTRIES.get(slug)!.context_window as number
+    ?? (typeof PINNED_NATIVE_CAPABILITY_ENTRIES.get(slug)?.context_window === "number"
+      ? PINNED_NATIVE_CAPABILITY_ENTRIES.get(slug)!.context_window as number
       : undefined);
 }
 
 export function nativeInputModalities(slug: string): string[] {
-  const upstream = UPSTREAM_NATIVE_ENTRIES.get(slug);
+  const upstream = PINNED_NATIVE_CAPABILITY_ENTRIES.get(slug);
   if (Array.isArray(upstream?.input_modalities) && upstream!.input_modalities!.length > 0) {
     return [...upstream!.input_modalities as string[]];
   }
@@ -82,7 +125,7 @@ export function nativeInputModalities(slug: string): string[] {
 }
 
 export function nativeReasoningEfforts(slug: string): string[] {
-  const upstream = UPSTREAM_NATIVE_ENTRIES.get(slug);
+  const upstream = PINNED_NATIVE_CAPABILITY_ENTRIES.get(slug);
   const levels = Array.isArray(upstream?.supported_reasoning_levels)
     ? upstream!.supported_reasoning_levels as Array<{ effort?: string }>
     : [];
@@ -97,12 +140,18 @@ export function nativeReasoningEfforts(slug: string): string[] {
 
 /** Upstream-pinned default for a native slug, when present and non-empty. */
 export function nativeDefaultReasoningEffort(slug: string): string | undefined {
-  const level = UPSTREAM_NATIVE_ENTRIES.get(slug)?.default_reasoning_level;
+  const level = PINNED_NATIVE_CAPABILITY_ENTRIES.get(slug)?.default_reasoning_level;
   return typeof level === "string" && level.length > 0 ? level : undefined;
 }
 
+/** Upstream-pinned multi-agent surface for a supported native slug, when present. */
+export function nativeMultiAgentVersion(slug: string): string | undefined {
+  const version = PINNED_NATIVE_CAPABILITY_ENTRIES.get(slug)?.multi_agent_version;
+  return typeof version === "string" && version.length > 0 ? version : undefined;
+}
+
 export function nativeParallelToolCalls(slug: string): boolean {
-  return UPSTREAM_NATIVE_ENTRIES.get(slug)?.supports_parallel_tool_calls === true
+  return PINNED_NATIVE_CAPABILITY_ENTRIES.get(slug)?.supports_parallel_tool_calls === true
     || false;
 }
 
@@ -116,9 +165,10 @@ export function disabledNativeSlugs(config: Pick<OcxConfig, "disabledModels">):
   return new Set((config.disabledModels ?? []).filter(id => !id.includes("/")));
 }
 
-export function visibleNativeSlugs(config: Pick<OcxConfig, "disabledModels">): string[] {
+export function visibleNativeSlugs(config: Pick<OcxConfig, "disabledModels" | "combos">): string[] {
   const disabled = disabledNativeSlugs(config);
-  return nativeOpenAiSlugs().filter(slug => !disabled.has(slug));
+  const shadowed = configuredNativeAliasSlugs(config);
+  return nativeOpenAiSlugs().filter(slug => !disabled.has(slug) && !shadowed.has(slug));
 }
 
 /** Whether an enabled canonical OpenAI provider can serve exact account-qualified routes. */
@@ -144,14 +194,15 @@ export function shouldIncludeNativeOpenAi(config: Pick<OcxConfig, "providers">):
 }
 
 /** Native slugs exposed to Claude Desktop show/export/apply (opt-out via claudeCode.desktopNativeModels). */
-export function desktopVisibleNativeSlugs(config: Pick<OcxConfig, "claudeCode" | "disabledModels">): string[] {
+export function desktopVisibleNativeSlugs(config: Pick<OcxConfig, "claudeCode" | "disabledModels" | "combos">): string[] {
   if (config.claudeCode?.desktopNativeModels === false) return [];
   return visibleNativeSlugs(config);
 }
 
-export function nativeModelRows(config: Pick<OcxConfig, "disabledModels">): Array<{ slug: string; disabled: boolean; contextWindow?: number }> {
+export function nativeModelRows(config: Pick<OcxConfig, "disabledModels" | "combos">): Array<{ slug: string; disabled: boolean; contextWindow?: number }> {
   const disabled = disabledNativeSlugs(config);
-  return NATIVE_OPENAI_MODELS.map(slug => {
+  const shadowed = configuredNativeAliasSlugs(config);
+  return NATIVE_OPENAI_MODELS.filter(slug => !shadowed.has(slug)).map(slug => {
     const contextWindow = nativeOpenAiContextWindow(slug);
     return { slug, disabled: disabled.has(slug), ...(contextWindow !== undefined ? { contextWindow } : {}) };
   });
@@ -163,6 +214,7 @@ export function applyNativeVisibility(
   hideBareNative = false,
 ): RawEntry[] {
   for (const entry of entries) {
+    if (isNativeAliasCatalogEntry(entry)) continue;
     const slug = typeof entry.slug === "string" ? entry.slug : "";
     const accountBoundSlug = trustedAccountBoundNativeCatalogSlug(entry);
     const nativeSlug = accountBoundSlug ?? slug;

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

@@ -0,0 +1,7 @@
+/** 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",
+  "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna",
+];
+
+export const SUPPORTED_NATIVE_OPENAI_SLUGS = new Set(NATIVE_OPENAI_MODELS);

package/src/codex/catalog/parsing.ts

@@ -9,7 +9,7 @@ import { buildModelsRequest, resolveModelsAuthToken } from "../../oauth";
 import type { OcxConfig, OcxProviderConfig } from "../../types";
 import { modelInList } from "../../types";
 import { CODEX_REASONING_LEVELS, codexEffortRank, configuredReasoningEfforts, modelRecordValue, sanitizeCodexReasoningEfforts } from "../../reasoning-effort";
-import { getJawcodeModelMetadata, getJawcodeModelMetadataCaseInsensitive, listJawcodeModelMetadata, resolveJawcodeProvider } from "../../generated/jawcode-model-metadata";
+import { getModelMetadata, getModelMetadataCaseInsensitive, listModelMetadata, resolveMetadataProvider } from "../../generated/model-metadata";
 import { enrichProviderFromRegistry, shouldCaseFoldMetadataModelId } from "../../providers/derive";
 import { getProviderRegistryEntry } from "../../providers/registry";
 import { applyProviderContextCap, providerContextCap } from "../../providers/context-cap";
@@ -31,8 +31,9 @@ import { redactSecretString } from "../../lib/redact";
 import upstreamModelsSnapshot from "../data/upstream-models.json";
 
 
-import { NATIVE_OPENAI_CONTEXT_OVERRIDES, SUPPORTED_NATIVE_OPENAI_SLUGS, UPSTREAM_NATIVE_ENTRIES } from "./metadata";
+import { NATIVE_OPENAI_CONTEXT_OVERRIDES, SUPPORTED_NATIVE_OPENAI_SLUGS, UPSTREAM_NATIVE_ENTRIES, nativeMultiAgentVersion } from "./metadata";
 import { trustedAccountBoundNativeCatalogSlug } from "./account-models";
+import { CODEX_NATIVE_ALIAS_CATALOG_KIND } from "./kinds";
 
 export function legacyCatalogBackupPath(): string {
   return join(getConfigDir(), "catalog-backup.json");
@@ -85,11 +86,18 @@ export function isDefaultCatalogPath(path: string): boolean {
   return samePath(path, activeDefaultCatalogPath());
 }
 
+/** Stable nonsemantic ownership marker for rows projected from config.customModels. */
+export const CODEX_CUSTOM_MODEL_CATALOG_KIND = "custom-model-v1";
+/** A formerly ambiguous slug was authoritatively observed as an ordinary provider row. */
+export const CODEX_PROVIDER_MODEL_CATALOG_KIND = "provider-model-v1";
+
 export interface CatalogModel {
   id: string;
   provider: string;
   /** Public Codex-facing slug override (used by combo aliases). */
   alias?: string;
+  /** Explicit combo takeover of a bare OpenAI-native catalog id. */
+  nativeAlias?: boolean;
   /**
    * Display-only Codex catalog `display_name` override. Relabels the picker row ONLY — it never
    * affects the routing slug, alias-collision order, native marketing-name precedence, or provider
@@ -113,13 +121,15 @@ export interface CatalogModel {
   supportsReasoningSummaries?: boolean;
   /** Normalized upstream capability names retained for management/API consumers (#485 follow-up). */
   capabilities?: string[];
+  /** OpenCodex-only catalog ownership marker; Codex ignores the serialized extension field. */
+  catalogKind?: typeof CODEX_CUSTOM_MODEL_CATALOG_KIND | typeof CODEX_PROVIDER_MODEL_CATALOG_KIND;
 }
 
 export type RawEntry = Record<string, unknown>;
 
 export type RawCatalog = { models?: RawEntry[]; [k: string]: unknown };
 
-export const JAWCODE_CATALOG_AUGMENT_PROVIDERS = new Set(["opencode-go"]);
+export const JAWCODE_CATALOG_AUGMENT_PROVIDERS = new Set(["opencode-go", "deepseek"]);
 
 export const ROUTED_MODEL_COMPATIBILITY_EXCLUSIONS = new Set([
   // Issue #82: Zen Go /models advertises HY3, but Console Go rejects it as outside the lite list.
@@ -193,7 +203,12 @@ export function readCatalog(path: string): RawCatalog | null {
 
 export function findNativeTemplate(catalog: RawCatalog | null): RawEntry | null {
   return catalog?.models?.find(
-    m => typeof m.slug === "string" && !m.slug.includes("/") && "base_instructions" in m,
+    m => typeof m.slug === "string"
+      && !m.slug.includes("/")
+      && "base_instructions" in m
+      && m.opencodex_catalog_kind !== CODEX_NATIVE_ALIAS_CATALOG_KIND
+      && m.owned_by !== COMBO_NAMESPACE
+      && !(typeof m.description === "string" && m.description.startsWith("Routed via opencodex → ")),
   ) ?? null;
 }
 
@@ -320,8 +335,10 @@ export function applyMultiAgentMode(entries: RawEntry[], mode: MultiAgentMode, v
     // re-apply upstream pins from the snapshot for native entries that have one.
     for (const entry of entries) {
       const slug = typeof entry.slug === "string" ? entry.slug : "";
-      const upstream = UPSTREAM_NATIVE_ENTRIES.get(trustedAccountBoundNativeCatalogSlug(entry) ?? slug);
-      const upstreamPin = upstream?.multi_agent_version;
+      const nativeAlias = entry.opencodex_catalog_kind === CODEX_NATIVE_ALIAS_CATALOG_KIND;
+      const upstreamPin = nativeAlias
+        ? nativeMultiAgentVersion(slug)
+        : UPSTREAM_NATIVE_ENTRIES.get(trustedAccountBoundNativeCatalogSlug(entry) ?? slug)?.multi_agent_version;
       if (typeof upstreamPin === "string") {
         entry.multi_agent_version = upstreamPin;
       } else if (v2FeatureEnabled) {
@@ -392,11 +409,11 @@ export function catalogModelSupportsReasoningSummaries(modelId: string): boolean
   return values.size === 1 ? values.values().next().value : undefined;
 }
 
-export function applyJawcodeCatalogMetadata(entry: RawEntry, provider: string, modelId: string, contextCap?: number): void {
-  const jawcodeProvider = resolveJawcodeProvider(provider);
+export function applyCatalogMetadata(entry: RawEntry, provider: string, modelId: string, contextCap?: number): void {
+  const jawcodeProvider = resolveMetadataProvider(provider);
   if (!jawcodeProvider) return;
-  const meta = getJawcodeModelMetadata(jawcodeProvider, modelId)
-    ?? (shouldCaseFoldMetadataModelId(provider) ? getJawcodeModelMetadataCaseInsensitive(jawcodeProvider, modelId) : undefined);
+  const meta = getModelMetadata(jawcodeProvider, modelId)
+    ?? (shouldCaseFoldMetadataModelId(provider) ? getModelMetadataCaseInsensitive(jawcodeProvider, modelId) : undefined);
   if (!meta) return;
   if (typeof meta.contextWindow === "number" && meta.contextWindow > 0) {
     const contextWindow = applyProviderContextCap(meta.contextWindow, contextCap) ?? meta.contextWindow;
@@ -425,7 +442,8 @@ export function readCatalogBackup(catalogPath: string): RawCatalog | null {
 }
 
 export function catalogHasRoutedEntries(catalog: RawCatalog | null): boolean {
-  return (catalog?.models ?? []).some(m => typeof m.slug === "string" && m.slug.includes("/"));
+  return (catalog?.models ?? []).some(m => typeof m.slug === "string"
+    && (m.slug.includes("/") || m.opencodex_catalog_kind === CODEX_NATIVE_ALIAS_CATALOG_KIND));
 }
 
 export function writePristineCatalogBackup(backupPath: string, catalogPath: string, catalog: RawCatalog): void {