@bitkyc08/opencodex 2.88.0 → 2.90.0

package/src/codex/auth-context.ts

@@ -69,7 +69,7 @@ import type { CodexCooldownSource, CodexQuotaScope } from "./routing";
 import { maskAccountId } from "../lib/privacy";
 import { formatErrorResponse, formatUsageLimitReachedResponse } from "../bridge";
 import { nextCodexPoolRecoveryAt } from "./routing/pool-recovery";
-import { CODEX_UNKNOWN_USAGE_SCORE, getAccountQuota, getMainPolicyQuota, parseUsageQuota, parseMainPolicyUsageQuota, setAccountQuotaFromParsed } from "./quota";
+import { CODEX_UNKNOWN_USAGE_SCORE, getAccountQuota, getMainPolicyQuota, isValidWhamHistoryObservation, parseUsageQuota, parseMainPolicyUsageQuota, setAccountQuotaFromParsed } from "./quota";
 import { codexAccountUsesCreditsAfterLimit, codexUsageLimitResetAt } from "./account-credit-use";
 import type { CodexAccountMode, OcxConfig, OcxProviderConfig } from "../types";
 import { FORWARD_HEADERS } from "../adapters/openai-responses";
@@ -97,6 +97,7 @@ import type { DataPlaneAdmission } from "../server/auth-cors";
 import { getMainReserveAuthorization, isMainReserveAuthorizationLive, nativeUserIdClaims, type MainReserveAuthorization } from "./reserve-availability";
 import { UpstreamRetryEvidenceError } from "../lib/upstream-retry";
 import { getEffectiveCodexAutoSwitchThreshold } from "./account-auto-switch";
+import { CODEX_MAIN_DUPLICATE_ACTION, configuredCodexMainDuplicate } from "./collision-identity";
 
 /**
  * A request-owned bearer cannot inspect the physical main credential for its plan, but cached
@@ -324,6 +325,8 @@ export type CodexAuthContext =
       writerGeneration: number;
       /** Captured before async credential work; never reconstructed after the upstream response. */
       mainQuotaWriter?: MainQuotaWriter;
+      /** Immutable credential proof captured while materializing this physical attempt's headers. */
+      mainQuotaDispatch?: MainQuotaDispatch;
       reserveAuthorization?: MainReserveAuthorization;
       accessToken: string;
       chatgptAccountId: string;
@@ -665,6 +668,7 @@ function assertReserveAdmission(config: CodexAuthPolicyConfig): void {
   }
 }
 
+/** Authorize a reserve request for the main credential, re-checking admission and writer liveness, and publish the ordinary quota observed during the capability read. */
 async function authorizeReserveCredential(
   token: { accessToken: string; chatgptAccountId: string },
   writer: MainQuotaWriter | undefined,
@@ -681,9 +685,11 @@ async function authorizeReserveCredential(
   const authorization = isMainReserveAuthorizationLive(existing, token) ? existing
     : await getMainReserveAuthorization({
       token, writer, signal,
+      /** Publish the ordinary usage observed during the reserve capability read: parse it once and reuse that observation as the advisory decision evidence when it is a valid history observation. */
       observeOrdinaryQuota(data, capturedWriter) {
-        setAccountQuotaFromParsed(MAIN_CODEX_ACCOUNT_ID, parseUsageQuota(data), writerGeneration,
-          capturedWriter, parseMainPolicyUsageQuota(data));
+        const parsed = parseUsageQuota(data);
+        setAccountQuotaFromParsed(MAIN_CODEX_ACCOUNT_ID, parsed, writerGeneration,
+          capturedWriter, parseMainPolicyUsageQuota(data), undefined, false, false, isValidWhamHistoryObservation(data) ? parsed : null);
       },
     });
   // The capability read also publishes ordinary quota. A new 99% reading or cooldown wins.
@@ -769,8 +775,10 @@ export function createCodexAuthDispatchGuard(
   terminalHelper = false,
 ): ((headers: Headers) => void) | undefined {
   const reserveGuard = createCodexReserveDispatchGuard(ctx, config, modelId, admission, terminalHelper);
-  if (ctx.kind !== "pool") return reserveGuard;
+  if (ctx.kind !== "pool" && ctx.kind !== "main-pool") return reserveGuard;
   return headers => {
+    if (config.pausedCodexAccountIds?.includes(ctx.accountId)) throw new CodexPoolAuthenticationError("Selected Codex account is paused; resume it in account settings");
+    if (ctx.kind === "main-pool") { reserveGuard?.(headers); return; }
     assertPoolAccountCredits(ctx.accountId, poolContextCreditHoldResetAt(ctx, config));
     reserveGuard?.(headers);
   };
@@ -1075,6 +1083,33 @@ async function awaitMainAccountPolicyBindingSettled(
   if (!settled) throw new CodexMainProfileDrainingError();
 }
 
+/** Memory-only ownership check shared by Direct admission and pre-auth hard-lock routing. */
+export async function mainAccountHardLockAppliesToCaller(
+  headers: Headers,
+  policy: CodexAuthPolicyConfig,
+  options: Pick<ResolveCodexAuthContextOptions,
+    "substituteMainCredentialForDirect" | "signal" | "mainAccountPolicyBindingWaitMs"> = {},
+): Promise<boolean> {
+  if (options.substituteMainCredentialForDirect === true) return true;
+  if (!hasCallerCodexBearer(headers)) return false;
+  if (isMainAccountHardLockEnabled(policy)) await awaitMainAccountPolicyBindingSettled(options);
+  return callerMatchesObservedMain(headers);
+}
+
+/**
+ * Resolve ownership once, then hand back a synchronous proof. Main identity or its observed bearer
+ * can change across the await; the hard-lock reroute rechecks the proof with no await between it
+ * and the body rewrite, so a replacement main's lock never reroutes the original caller.
+ */
+export async function mainAccountHardLockCallerProof(
+  headers: Headers,
+  policy: CodexAuthPolicyConfig,
+  options: Parameters<typeof mainAccountHardLockAppliesToCaller>[2] = {},
+): Promise<(() => boolean) | null> {
+  if (!await mainAccountHardLockAppliesToCaller(headers, policy, options)) return null;
+  return options.substituteMainCredentialForDirect === true ? () => true : () => callerMatchesObservedMain(headers);
+}
+
 /**
  * Resolve the credential for one Codex turn. A main hard-lock reached through unpinned pool
  * selection is annotated with the earliest known pool recovery, so the refusal can name a retry
@@ -1167,8 +1202,7 @@ async function resolveCodexAuthContextUnannotated(
     // Trusted substitution still has to claim and validate stored main below.
     if (!substituteStoredMain && !hasCallerCodexBearer(headers)) throw new CodexDirectAuthenticationError();
     if (!substituteStoredMain) {
-      if (isMainAccountHardLockEnabled(policy)) await awaitMainAccountPolicyBindingSettled(options);
-      if (callerMatchesObservedMain(headers)) assertMainAccountPolicy(policy);
+      if (await mainAccountHardLockAppliesToCaller(headers, policy, options)) assertMainAccountPolicy(policy);
       assertCallerOwnedMainPoolNotCooled();
       if (reserve) {
         const selected = materializeCodexUpstreamAuth(headers, { kind: "main", accountId: null }, { config: policy });
@@ -1417,7 +1451,9 @@ async function resolveCodexAuthContextUnannotated(
     // cool down. Hand back any trial first -- no Pool account is being sent to.
     if (selected === MAIN_CODEX_ACCOUNT_ID && requestScopedMainCredential) {
       releaseTransientProbeGrant();
-      return await resolveCallerOwnedMainContext();
+      const context = await resolveCallerOwnedMainContext();
+      console.info("[codex] Pool selected caller-owned main credential.");
+      return context;
     }
     if (!selected) {
       // A retry that excluded a failed Pool account may still use the validated caller-owned
@@ -1427,9 +1463,12 @@ async function resolveCodexAuthContextUnannotated(
       if (
         requestScopedMainCredential
         && fixedAccountId === undefined
+        && !(callerMatchesObservedMain(headers) && policy.pausedCodexAccountIds?.includes(MAIN_CODEX_ACCOUNT_ID))
         && options.excludeAccountId !== MAIN_CODEX_ACCOUNT_ID
       ) {
-        return await resolveCallerOwnedMainContext();
+        const context = await resolveCallerOwnedMainContext();
+        console.info("[codex] Pool used caller-owned main credential: no selectable stored account.");
+        return context;
       }
       if (fixedAccountId !== undefined) {
         if (modelEligibleAccountIds && !modelEligibleAccountIds.has(fixedAccountId)) {
@@ -1528,6 +1567,7 @@ async function resolveCodexAuthContextUnannotated(
   // deferred credential must never become request auth through that fallback.
   try {
     assertCodexAccountValidationReady(accountId);
+    if (configuredCodexMainDuplicate(config, accountId)) throw new CodexPoolAuthenticationError(CODEX_MAIN_DUPLICATE_ACTION);
     assertPoolAccountCredits(accountId, poolCreditHoldResetAt(policy, accountId, config));
   } catch (cause) {
     // Nothing will reach upstream, so give the trial back instead of leaving the held account
@@ -1585,9 +1625,12 @@ async function resolveCodexAuthContextUnannotated(
       // alternate is eligible. A validated caller may still serve this request,
       // just as it can after an upstream rejection, without changing Pool state.
       if (requestScopedMainCredential && fixedAccountId === undefined
+        && !(callerMatchesObservedMain(headers) && policy.pausedCodexAccountIds?.includes(MAIN_CODEX_ACCOUNT_ID))
         && options.excludeAccountId !== MAIN_CODEX_ACCOUNT_ID
         && !callerIsCooledPoolAccount(headers, config, accountId)) {
-        return await resolveCallerOwnedMainContext();
+        const context = await resolveCallerOwnedMainContext();
+        console.info("[codex] Pool used caller-owned main credential: stored account cooldown.");
+        return context;
       }
       throw new CodexAccountCooldownError(accountId, cooldownUntil, cooldown?.cooldownSource, cooldown?.quotaScope);
     }
@@ -1655,6 +1698,7 @@ async function resolveCodexAuthContextUnannotated(
   try {
     const token = await getValidCodexToken(accountId, { signal: options.signal });
     assertCodexAccountValidationReady(accountId);
+    if (configuredCodexMainDuplicate(config, accountId)) throw new CodexPoolAuthenticationError(CODEX_MAIN_DUPLICATE_ACTION);
     assertPoolAccountCredits(accountId, poolCreditHoldResetAt(policy, accountId, config));
     return bindPoolCreditPolicy({
       kind: "pool",
@@ -1676,7 +1720,8 @@ async function resolveCodexAuthContextUnannotated(
     releaseTransientProbeGrant();
     if (probeLeaseId && probeQuotaScope) releaseCodexQuotaScopeProbeLease(accountId, probeQuotaScope, probeLeaseId);
     else if (probeLeaseId) releaseCodexQuotaProbeLease(accountId, probeLeaseId);
-    if (cause instanceof CodexPoolAccountCreditsOffError) throw cause;
+    // Post-refresh eligibility refusals do not invalidate a healthy credential.
+    if (cause instanceof CodexPoolAccountCreditsOffError || cause instanceof CodexPoolAuthenticationError) throw cause;
     if (!options.signal?.aborted && shouldMarkAccountNeedsReauthForCodexAuthFailure(cause)) {
       markAccountNeedsReauth(accountId, writerGeneration);
     }
@@ -1761,6 +1806,8 @@ export function materializeCodexUpstreamAuth(
     if (ctx.kind === "main-pool") {
       ctx.mainQuotaWriter = observeSelectedMainCredential(ctx, ctx.mainQuotaWriter);
       assertMainAccountPolicy(options.config);
+      ctx.mainQuotaDispatch = ctx.mainQuotaWriter && isMainQuotaWriterLive(ctx.mainQuotaWriter)
+        ? selectedMainQuotaDispatch(selected) : undefined;
     }
     assertMaterializedReserve(selected, ctx, options);
     return selected;

package/src/codex/catalog/aggregation.ts

@@ -195,6 +195,7 @@ export function deriveComboCatalogModel(
     ...(combo.alias ? { alias: combo.alias } : {}),
     ...(combo.nativeAlias ? { nativeAlias: true } : {}),
     ...(combo.displayName ? { displayName: combo.displayName } : {}),
+    ...(combo.description ? { description: combo.description } : {}),
     ...(defaultReasoningEffort ? { defaultReasoningEffort } : {}),
     ...(members.every(member => member.parallelToolCalls === true)
       ? { parallelToolCalls: true }
@@ -401,6 +402,20 @@ export function exactComboCatalogSlugs(
   }));
 }
 
+/** Current combo row descriptions by public catalog slug, for retained-row re-projection (#7229). */
+export function comboCatalogDescriptions(
+  config: Pick<OcxConfig, "combos" | "disabledModels">,
+): Map<string, string> {
+  const current = exactComboCatalogSlugs(config);
+  return new Map(listComboIds(config).flatMap(id => {
+    const raw = config.combos?.[id];
+    const alias = typeof raw?.alias === "string" ? raw.alias.trim() : "";
+    const publicSlug = alias || comboModelId(id);
+    const description = typeof raw?.description === "string" ? raw.description.trim() : "";
+    return description && current.has(publicSlug) ? [[publicSlug, description] as const] : [];
+  }));
+}
+
 export function normalizedOpenAiApiSignature(model: CatalogModel): string {
   const normalized = {
     provider: model.provider,

package/src/codex/catalog/auto-review.ts

@@ -5,6 +5,7 @@ import { encodeRoutedModelId } from "../../providers/slug-codec";
 import { canonicalAutoReviewModelKey, isValidAutoReviewModel as isValidAutoReviewTarget } from "../../config/provider-validation";
 import { readConfiguredAutoReviewModel } from "./parsing";
 import type { RawEntry } from "./parsing";
+import { hasOcxRoutedAuthorship } from "./ownership";
 import { configuredCatalogEntry } from "./subagent-roster";
 
 const AUTO_REVIEW_ROOT_MARKER = "opencodex_auto_review_root";
@@ -38,7 +39,7 @@ function isRoutedCatalogEntry(entry: RawEntry): boolean {
   if (isCodexControlPlaneModel(entry.slug)) return false;
   const slug = typeof entry.slug === "string" ? entry.slug : "";
   return slug.includes("/")
-    || (typeof entry.description === "string" && entry.description.startsWith("Routed via opencodex → "));
+    || hasOcxRoutedAuthorship(entry);
 }
 
 /** Restore an owned native value, retaining provenance to avoid legacy reclassification. */

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

@@ -4,6 +4,7 @@ import { CODEX_REASONING_LEVELS, type CodexReasoningLevel } from "../../reasonin
 import { clearModelCache } from "../model-cache";
 import { routedSlug, slugEquivalenceKey } from "../../providers/slug-codec";
 import { COMBO_NAMESPACE } from "../../combos";
+import { hasOcxComboAuthorship, hasOcxRoutedAuthorship, reapplyRetainedComboDescription, ROUTED_DESCRIPTION_PREFIX } from "./ownership";
 import {
   CODEX_CUSTOM_MODEL_CATALOG_KIND,
   CODEX_PROVIDER_MODEL_CATALOG_KIND,
@@ -218,7 +219,7 @@ export function buildCatalogEntriesFromObservedState({
     const routed = deriveEntry(
       template,
       slug,
-      `Routed via opencodex → ${nativeAlias.provider} (${nativeAlias.owned_by ?? nativeAlias.provider}).`,
+      `${ROUTED_DESCRIPTION_PREFIX}${nativeAlias.provider} (${nativeAlias.owned_by ?? nativeAlias.provider}).`,
       5,
       nativeAlias,
       exactComboSlugs,
@@ -276,7 +277,7 @@ export function buildCatalogEntriesFromObservedState({
     const e = deriveEntry(
       template,
       slug,
-      `Routed via opencodex → ${m.provider} (${m.owned_by ?? m.provider}).`,
+      `${ROUTED_DESCRIPTION_PREFIX}${m.provider} (${m.owned_by ?? m.provider}).`,
       5,
       m,
       exactComboSlugs,
@@ -380,15 +381,15 @@ export function orderForModelPicker(
  * True when an existing catalog row was authored by OpenCodex routing (#855).
  * Every generated routed row — current full-slug form, the June–July 2026
  * provider-name form, and legacy combo aliases — carries the stable
- * description prefix `Routed via opencodex → `; foreign rows from Cursor or
+ * description prefix `Routed via opencodex → `, or — when a combo overrides its description
+ * (#7229) — the `opencodex_routed_origin` marker (./ownership); foreign rows from Cursor or
  * user tooling do not. `owned_by` describes upstream ownership, and `comp_hash`
  * describes history compatibility; neither is an authorship signal.
  */
 export function isOcxAuthoredRoutedEntry(entry: RawEntry): boolean {
   if (isNativeAliasCatalogEntry(entry)) return true;
-  const desc = typeof entry.description === "string" ? entry.description : "";
   const slug = typeof entry.slug === "string" ? entry.slug : "";
-  return slug.includes("/") && desc.startsWith("Routed via opencodex → ");
+  return slug.includes("/") && hasOcxRoutedAuthorship(entry);
 }
 
 function recoverableNativeSlug(entry: RawEntry): string | null {
@@ -503,6 +504,11 @@ export interface ObservedCatalogMergeInput {
   readonly multiAgentV2Enabled: boolean;
   readonly keepNativeChatGptOnV1?: boolean;
   readonly exactComboSlugs: ReadonlySet<string>;
+  /**
+   * Current combo row descriptions by public slug (#7229). When supplied, retained combo rows
+   * are re-projected onto it; absent means the caller has no config and leaves them unchanged.
+   */
+  readonly comboDescriptions?: ReadonlyMap<string, string>;
   readonly hasPhysicalComboProvider: boolean;
   readonly includeNativeOpenAi: boolean;
   readonly accountBoundEntries: readonly RawEntry[];
@@ -545,6 +551,7 @@ export function mergeCatalogEntriesFromObservedState({
   multiAgentV2Enabled,
   keepNativeChatGptOnV1,
   exactComboSlugs,
+  comboDescriptions,
   hasPhysicalComboProvider,
   includeNativeOpenAi,
   accountBoundEntries,
@@ -639,8 +646,7 @@ export function mergeCatalogEntriesFromObservedState({
   }
   const freshExactComboEntries = new Set(admittedRoutedEntries.filter(entry => (
     isExactComboCatalogEntry(entry, exactComboSlugs)
-    && typeof entry.description === "string"
-    && entry.description.startsWith(`Routed via opencodex → ${COMBO_NAMESPACE} (`)
+    && hasOcxComboAuthorship(entry)
   )));
   const rank = new Map(featured.map((slug, i) => [slug, i] as const));
   const freshEquivalentKeys = new Set(admittedRoutedEntries.flatMap(entry => (
@@ -802,6 +808,10 @@ export function mergeCatalogEntriesFromObservedState({
       delete entry[SPAWN_PRIORITY_FIELD];
     }
     const slug = String(entry.slug);
+    if (comboDescriptions !== undefined && exactComboSlugs.has(slug)
+      && (isNativeAliasCatalogEntry(entry) || (entry.owned_by === COMBO_NAMESPACE && hasOcxComboAuthorship(entry)))) {
+      reapplyRetainedComboDescription(entry, comboDescriptions.get(slug));
+    }
     if (!isOcxAuthoredRoutedEntry(entry)) continue;
     // The builder no longer copies a template's comp_hash onto routed rows (#5796), but a row
     // kept from disk may still carry one. Custom rows, Codex-forward aliases included, never

package/src/codex/catalog/derive-entry.ts

@@ -26,6 +26,7 @@ import {
   isGpt56NativeSlug,
 } from "./effort";
 import { CATALOG_INACTIVE_REASON_FIELD, SPAWN_PRIORITY_FIELD } from "./subagent-roster";
+import { applyRoutedDescription } from "./ownership";
 
 export function finishUpstreamNativeEntry(clone: RawEntry, priority: number, contextCap?: NativeContextLimitsInput): RawEntry {
   if (priority !== 9) clone.priority = priority;
@@ -128,7 +129,7 @@ export function deriveEntry(
     delete e[SPAWN_PRIORITY_FIELD];
     e.slug = slug;
     e.display_name = routedDisplayName(slug, model);
-    e.description = desc;
+    applyRoutedDescription(e, desc, model);
     e.priority = priority;
     e.visibility = "list";
     if ("upgrade" in e) e.upgrade = null;
@@ -212,6 +213,7 @@ export function deriveEntry(
         : { web_search_tool_type: "text_and_image", supports_search_tool: true }
       : {}),
   };
+  applyRoutedDescription(entry, desc, model);
   if (isRouted) {
     applyRoutedCodexToolMode(entry, model?.codexToolMode);
     applyReasoningLevels(

package/src/codex/catalog/metadata.ts

@@ -38,6 +38,7 @@ 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 { ROUTED_ORIGIN_FIELD } from "./ownership";
 import { RESERVE_METADATA_SOURCE_FIELD } from "./reserve";
 import {
   ACCOUNT_GATED_NATIVE_OPENAI_MODELS,
@@ -813,6 +814,7 @@ export function observedReserveCatalogSource(
   }
   source.slug = NATIVE_RESERVE_MODEL;
   delete source.opencodex_catalog_kind;
+  delete source[ROUTED_ORIGIN_FIELD];
   delete source[RESERVE_METADATA_SOURCE_FIELD];
   delete source[ACCOUNT_BOUND_OBSERVED_NATIVE_MARKER];
   delete source[ACCOUNT_BOUND_OBSERVED_SELECTORS_MARKER];

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

@@ -189,7 +189,6 @@ export function warnDroppedConfiguredIdsOnce(name: string, droppedConfiguredIds:
   );
 }
 export function shouldExposeProviderModel(providerName: string, modelId: string): boolean {
-  if (providerName === "opencode-free") return modelId === "big-pickle" || modelId.endsWith("-free");
   // xAI /models advertises both the dated deployment and this floating alias.
   // Keep only grok-4.20-multi-agent-0309; the alias is the same server-side id.
   if (providerName === "xai" && modelId === "grok-4.20-multi-agent-beta-latest") return false;
@@ -205,7 +204,6 @@ export function shouldRetainConfiguredProviderModel(
   prov?: OcxProviderConfig,
 ): boolean {
   if (CALLABLE_CONFIGURED_COMPATIBILITY_MODELS[providerName]?.has(modelId)) return true;
-  if (providerName === "opencode-free") return modelId === "big-pickle" || modelId.endsWith("-free");
   if (modelInList(prov?.retainModels, modelId)) return true;
   return false;
 }

package/src/codex/catalog/ownership.ts

@@ -0,0 +1,71 @@
+import { COMBO_NAMESPACE } from "../../combos/identifiers";
+import type { CatalogModel, RawEntry } from "./parsing";
+
+/**
+ * Authorship of OpenCodex-generated routed catalog rows (#855, #7229).
+ *
+ * A generated routed row normally carries the description prefix below, and that prefix is what
+ * removal, template selection, auto-review and residue detection have always recognized. A combo
+ * may replace its row description (#7229), so such a row carries a stable marker instead. Rows
+ * with the generated description stay byte-identical and keep prefix recognition; only an exact
+ * known marker value confers authorship.
+ */
+export const ROUTED_DESCRIPTION_PREFIX = "Routed via opencodex → ";
+export const ROUTED_ORIGIN_FIELD = "opencodex_routed_origin";
+export const COMBO_ROUTED_ORIGIN = "combo-v1";
+const COMBO_DESCRIPTION_PREFIX = `${ROUTED_DESCRIPTION_PREFIX}${COMBO_NAMESPACE} (`;
+
+function descriptionStartsWith(entry: RawEntry, prefix: string): boolean {
+  return typeof entry.description === "string" && entry.description.startsWith(prefix);
+}
+
+/** True for a row whose description was overridden by a combo and stamped by OpenCodex. */
+export function hasComboRoutedOriginMarker(entry: RawEntry): boolean {
+  return entry[ROUTED_ORIGIN_FIELD] === COMBO_ROUTED_ORIGIN;
+}
+
+/** Generated by OpenCodex routing: the stable marker, or the legacy generated description. */
+export function hasOcxRoutedAuthorship(entry: RawEntry): boolean {
+  return hasComboRoutedOriginMarker(entry) || descriptionStartsWith(entry, ROUTED_DESCRIPTION_PREFIX);
+}
+
+/** Generated for a combo: the stable marker, or the legacy generated combo description. */
+export function hasOcxComboAuthorship(entry: RawEntry): boolean {
+  return hasComboRoutedOriginMarker(entry) || descriptionStartsWith(entry, COMBO_DESCRIPTION_PREFIX);
+}
+
+/** The operator's combo description override, if this routed model has one. */
+export function comboDescriptionOverride(model: CatalogModel | undefined): string | undefined {
+  if (model?.provider !== COMBO_NAMESPACE) return undefined;
+  const description = typeof model.description === "string" ? model.description.trim() : "";
+  return description || undefined;
+}
+
+/**
+ * Set a routed row's description and its authorship marker together. A template clone may carry
+ * another row's marker, so the marker is always rewritten from this model's own override.
+ */
+export function applyRoutedDescription(entry: RawEntry, generated: string, model: CatalogModel | undefined): void {
+  const override = comboDescriptionOverride(model);
+  entry.description = override ?? generated;
+  if (override !== undefined) entry[ROUTED_ORIGIN_FIELD] = COMBO_ROUTED_ORIGIN;
+  else delete entry[ROUTED_ORIGIN_FIELD];
+}
+
+/**
+ * A combo row retained from the previous catalog (its fresh derivation failed, e.g. a member
+ * provider is temporarily unavailable) bypasses deriveEntry. Re-project the combo's CURRENT
+ * description onto it so clearing or changing the description in config still reaches the
+ * picker. A cleared override returns the row to the generated combo text without the marker;
+ * an unmarked row without a current override is left exactly as it was.
+ */
+export function reapplyRetainedComboDescription(entry: RawEntry, current: string | undefined): void {
+  const description = current?.trim();
+  if (description) {
+    entry.description = description;
+    entry[ROUTED_ORIGIN_FIELD] = COMBO_ROUTED_ORIGIN;
+  } else if (hasComboRoutedOriginMarker(entry)) {
+    entry.description = `${ROUTED_DESCRIPTION_PREFIX}${COMBO_NAMESPACE} (${COMBO_NAMESPACE}).`;
+    delete entry[ROUTED_ORIGIN_FIELD];
+  }
+}

package/src/codex/catalog/parsing.ts

@@ -43,6 +43,7 @@ import { NATIVE_OPENAI_CONTEXT_OVERRIDES, SUPPORTED_NATIVE_OPENAI_SLUGS, UPSTREA
 import { clampAutoCompactTokenLimit } from "../../providers/auto-compact-budget";
 import { trustedAccountBoundNativeCatalogSlug } from "./account-models";
 import { CODEX_NATIVE_ALIAS_CATALOG_KIND } from "./kinds";
+import { hasComboRoutedOriginMarker, hasOcxRoutedAuthorship } from "./ownership";
 import { NATIVE_GPT6_ASTRA_MODEL } from "./native-models";
 import { recordOwnedConfigPath } from "../../lib/config-ownership";
 
@@ -95,6 +96,12 @@ export interface CatalogModel {
    * which carries no CatalogModel, so a configured displayName can never override a native name.
    */
   displayName?: string;
+  /**
+   * Display-only Codex catalog `description` override, honored for combo rows only (#7229).
+   * Unset keeps the generated "Routed via opencodex → …" text; a set value stamps the row with
+   * the ownership marker in ./ownership so removal and template selection still recognize it.
+   */
+  description?: string;
   owned_by?: string;
   reasoningEfforts?: string[];
   /** Exact CCA family evidence, retained through the in-memory discovery cache. */
@@ -297,7 +304,7 @@ export function findNativeTemplate(catalog: RawCatalog | null): RawEntry | null
       && "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 → ")),
+      && !hasOcxRoutedAuthorship(m),
   ) ?? null;
 }
 
@@ -325,7 +332,7 @@ export function findSupportedNativeTemplate(catalog: RawCatalog | null): RawEntr
       && "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 → ")),
+      && !hasOcxRoutedAuthorship(m),
   ) ?? null;
 }
 
@@ -925,7 +932,9 @@ 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("/") || m.opencodex_catalog_kind === CODEX_NATIVE_ALIAS_CATALOG_KIND));
+    && (m.slug.includes("/")
+      || m.opencodex_catalog_kind === CODEX_NATIVE_ALIAS_CATALOG_KIND
+      || hasComboRoutedOriginMarker(m)));
 }
 
 export function writePristineCatalogBackup(backupPath: string, catalogPath: string, catalog: RawCatalog): void {

package/src/codex/catalog/retained-sync.ts

@@ -60,7 +60,7 @@ import { isMultiAgentV2Enabled } from "../features";
 import { clampCatalogModelsToCodexSupport } from "./effort";
 import { suppressedSyntheticMaxCatalogSlugs } from "./model-hints";
 import { filterCatalogVisibleModels, gatherRoutedModels, type CatalogGatherProviderModelOutcome } from "./provider-fetch";
-import { dedupeCatalogEntriesBySlug, enforceCatalogSlugUniqueness, exactComboCatalogSlugs, type ComboCatalogOmission } from "./aggregation";
+import { comboCatalogDescriptions, dedupeCatalogEntriesBySlug, enforceCatalogSlugUniqueness, exactComboCatalogSlugs, type ComboCatalogOmission } from "./aggregation";
 import {
   withCatalogWriteSerialization,
   type CatalogWritePermit,
@@ -530,6 +530,7 @@ function writeRetainedCatalogSync({
     multiAgentV2Enabled,
     keepNativeChatGptOnV1: config.keepNativeChatGptOnV1 === true,
     exactComboSlugs,
+    comboDescriptions: comboCatalogDescriptions(config),
     hasPhysicalComboProvider,
     includeNativeOpenAi,
     accountBoundEntries,

package/src/codex/catalog/routed-removal.ts

@@ -4,6 +4,7 @@ import type { OcxConfig } from "../../types";
 import { trustedAccountBoundNativeCatalogSlug } from "./account-models";
 import { isOcxAuthoredRoutedEntry } from "./build-entries";
 import { isNativeAliasCatalogEntry } from "./metadata";
+import { hasOcxRoutedAuthorship } from "./ownership";
 import type { RawCatalog, RawEntry } from "./parsing";
 
 /**
@@ -25,10 +26,9 @@ function routedNamespace(entry: RawEntry): string | null {
   if (trustedAccountBoundNativeCatalogSlug(entry) !== undefined) return null;
   if (isNativeAliasCatalogEntry(entry)) return COMBO_NAMESPACE;
   // Combo aliases may be bare or use an unrelated provider namespace. Ownership selects the
-  // combo namespace only with the same generated-description authorship signal as routed rows.
-  if (entry.owned_by === COMBO_NAMESPACE
-    && typeof entry.description === "string"
-    && entry.description.startsWith("Routed via opencodex → ")) return COMBO_NAMESPACE;
+  // combo namespace only with the same authorship signal as routed rows (generated description or
+  // the #7229 marker a custom combo description carries).
+  if (entry.owned_by === COMBO_NAMESPACE && hasOcxRoutedAuthorship(entry)) return COMBO_NAMESPACE;
   // Foreign rows (Cursor, user tooling) are never removed by the provider rule.
   if (!isOcxAuthoredRoutedEntry(entry)) return null;
   return entry.slug.slice(0, entry.slug.indexOf("/"));

package/src/codex/cli-update-plan.ts

@@ -213,9 +213,15 @@ function npmTarget(args: readonly string[], env?: NodeJS.ProcessEnv): NpmTarget
  * reverse: they are output paths, so ambient values would write Node artifacts to
  * arbitrary external directories on exit. ELF/Darwin loader controls (LD_* and
  * DYLD_*) are also removed: they can load code or redirect loader output before
- * npm runs. This is a denylist for process-startup/output channels, not a claim
- * that every ambient variable is allowlisted. Ordinary OS environment, proxy
- * settings and the supported NODE_EXTRA_CA_CERTS extension remain available.
+ * npm runs. OpenSSL's startup inputs are removed with them: OPENSSL_CONF names
+ * a configuration file the crypto library reads at startup, OPENSSL_CONF_INCLUDE
+ * resolves relative includes inside that configuration, and OPENSSL_MODULES /
+ * OPENSSL_ENGINES name the directories its provider and engine search loads
+ * shared modules from. None of these is input the updater child needs, so
+ * ambient values stay out of the spawned npm. This is a denylist for
+ * process-startup/output channels, not a claim that every ambient variable is
+ * allowlisted. Ordinary OS environment, proxy settings and the supported
+ * NODE_EXTRA_CA_CERTS extension remain available.
  */
 const NPM_ENV_DROP_KEYS: ReadonlySet<string> = new Set([
   "node_options",
@@ -227,6 +233,15 @@ const NPM_ENV_DROP_KEYS: ReadonlySet<string> = new Set([
   // escaping the owned temp root regardless of the isolated --cache.
   "node_v8_coverage",
   "node_redirect_warnings",
+  // OpenSSL startup inputs: OPENSSL_CONF points the library at an ambient
+  // startup configuration file (OPENSSL_CONF_INCLUDE resolves that config's
+  // relative includes); OPENSSL_MODULES and OPENSSL_ENGINES point its
+  // provider/engine search at ambient directories that supply loadable
+  // shared modules.
+  "openssl_conf",
+  "openssl_conf_include",
+  "openssl_modules",
+  "openssl_engines",
 ]);
 
 function codexCliUpdateNpmEnv(base: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {

package/src/codex/collision-identity.ts

@@ -0,0 +1,78 @@
+import { extractAccountIdClaims, extractEmail } from "../oauth/chatgpt";
+import type { CodexAccount, OcxConfig } from "../types";
+import { getCodexAccountCredential } from "./account-store";
+import type { CodexTokens } from "./auth-collision";
+import { captureMainAccountIdentityGeneration, isMainAccountIdentityGenerationLive } from "./main-account-cache";
+import { codexPlanKey, extractChatgptPlanType } from "./plan";
+
+export interface CodexCollisionIdentity {
+  accountId: string;
+  email?: string | null;
+  plan?: unknown;
+}
+
+function normalizedEmail(email: string | null | undefined): string | undefined {
+  return email?.trim().toLowerCase() || undefined;
+}
+
+function workspacePlan(plan: unknown): boolean {
+  return /team|business|enterprise|workspace|edu/.test(codexPlanKey(plan) ?? "");
+}
+
+/** Missing member evidence cannot establish a distinct subscription within one plan bucket. */
+export function sameCodexCollisionIdentity(a: CodexCollisionIdentity, b: CodexCollisionIdentity): boolean {
+  if (!a.accountId || a.accountId !== b.accountId || workspacePlan(a.plan) !== workspacePlan(b.plan)) return false;
+  const aEmail = normalizedEmail(a.email);
+  const bEmail = normalizedEmail(b.email);
+  return !aEmail || !bEmail || aEmail === bEmail;
+}
+
+// Ambient scope comparison is memory-only, including when the default-home resolver would probe WSL.
+function homeScope(): string {
+  return JSON.stringify([process.env.CODEX_HOME, process.env.HOME, process.env.USERPROFILE, process.env.OPENCODEX_HOME]);
+}
+
+let observed: { identity: CodexCollisionIdentity; homeScope: string; generation: number } | undefined;
+
+/** Only existing owned lifecycle observations may publish; never call with a request bearer. */
+export function observeMainCodexCollisionIdentity(tokens?: CodexTokens): void {
+  if (!tokens) { observed = undefined; return; }
+  if (typeof tokens.access_token !== "string" || typeof tokens.account_id !== "string"
+    || (tokens.id_token !== undefined && typeof tokens.id_token !== "string")) return;
+  const claims = [extractAccountIdClaims(tokens.id_token), extractAccountIdClaims(tokens.access_token)];
+  if (claims.some(claim => claim.conflict)) return;
+  const accountId = tokens.account_id || claims.find(claim => claim.accountId)?.accountId;
+  if (!accountId || claims.some(claim => claim.accountId && claim.accountId !== accountId)) return;
+  const emails = new Set([extractEmail(tokens.id_token), extractEmail(undefined, tokens.access_token)]
+    .flatMap(email => normalizedEmail(email) ? [normalizedEmail(email)!] : []));
+  if (emails.size > 1) return;
+  observed = { identity: { accountId, email: [...emails][0],
+    plan: extractChatgptPlanType(tokens.id_token, tokens.access_token) },
+    homeScope: homeScope(), generation: captureMainAccountIdentityGeneration() };
+}
+
+/** Compare known identity only. External logins become visible at the next owned observation. */
+export function getObservedMainCodexCollisionIdentity(): Readonly<CodexCollisionIdentity> | undefined {
+  return observed?.homeScope === homeScope() && isMainAccountIdentityGenerationLive(observed.generation)
+    ? observed.identity : undefined;
+}
+
+export function isStoredCodexMainDuplicate(account: CodexAccount): boolean {
+  const main = getObservedMainCodexCollisionIdentity();
+  if (account.isMain || !main) return false;
+  const credential = getCodexAccountCredential(account.id);
+  if (!credential?.chatgptAccountId) return false;
+  const storedEmail = normalizedEmail(account.email);
+  const email = storedEmail && storedEmail !== normalizedEmail(account.id)
+    ? storedEmail : extractEmail(undefined, credential.accessToken);
+  return sameCodexCollisionIdentity({ accountId: credential.chatgptAccountId, email,
+    plan: codexPlanKey(account.plan) ? account.plan : extractChatgptPlanType(undefined, credential.accessToken) }, main);
+}
+
+export const CODEX_MAIN_DUPLICATE_ACTION =
+  "Use the native Codex main account, or sign native Codex into a different account to use this stored Pool entry.";
+
+export function configuredCodexMainDuplicate(config: Pick<OcxConfig, "codexAccounts">, accountId: string): boolean {
+  const account = config.codexAccounts?.find(row => row.id === accountId);
+  return !!account && isStoredCodexMainDuplicate(account);
+}