codex-multi-auth 2.9.2 → 2.11.0

package/dist/lib/synthetic-response.js

@@ -0,0 +1,79 @@
+/**
+ * Shared builder for locally-answered Responses API replies.
+ *
+ * Both the reactive context-overflow handler (`lib/context-overflow.ts`) and
+ * the proactive context budget guard (`lib/context-budget-response.ts`) need
+ * to hand the caller a plugin-authored notice instead of forwarding to
+ * upstream, in the exact SSE dialect the Codex CLI / Responses client
+ * expects. Extracted here so both answer with one audited SSE shape rather
+ * than two independently-maintained copies of it.
+ */
+function randomSuffix() {
+    return Math.random().toString(36).slice(2, 8);
+}
+/**
+ * Build a synthetic OpenAI Responses API SSE stream carrying a single
+ * assistant text message, then a terminal `response.completed`.
+ *
+ * Emits `response.*` events — the dialect the Codex CLI client and this
+ * package's own `convertSseToJson` parser speak, not the Anthropic Messages
+ * API dialect. Returns 200 OK so the host session never locks on a 4xx for a
+ * notice the plugin itself generated.
+ */
+export function createSyntheticSseResponse(options) {
+    const { model, message, idPrefix, errorType } = options;
+    const messageId = `msg_${idPrefix}_${Date.now()}_${randomSuffix()}`;
+    const responseId = `resp_${idPrefix}_${Date.now()}_${randomSuffix()}`;
+    const events = [];
+    const push = (type, payload) => {
+        events.push(`event: ${type}\ndata: ${JSON.stringify({ type, ...payload })}\n\n`);
+    };
+    const baseResponse = {
+        id: responseId,
+        object: "response",
+        model,
+    };
+    push("response.created", { response: { ...baseResponse, status: "in_progress" } });
+    push("response.output_item.added", {
+        output_index: 0,
+        item: {
+            id: messageId,
+            type: "message",
+            role: "assistant",
+            content: [],
+        },
+    });
+    push("response.output_text.delta", {
+        output_index: 0,
+        content_index: 0,
+        delta: message,
+    });
+    push("response.output_text.done", {
+        output_index: 0,
+        content_index: 0,
+        text: message,
+    });
+    push("response.completed", {
+        response: {
+            ...baseResponse,
+            status: "completed",
+            output: [
+                {
+                    id: messageId,
+                    type: "message",
+                    role: "assistant",
+                    content: [{ type: "output_text", text: message }],
+                },
+            ],
+            usage: { input_tokens: 0, output_tokens: 0, total_tokens: 0 },
+        },
+    });
+    return new Response(events.join(""), {
+        status: 200,
+        headers: {
+            "Content-Type": "text/event-stream",
+            "X-Codex-Plugin-Synthetic": "true",
+            "X-Codex-Plugin-Error-Type": errorType,
+        },
+    });
+}

package/dist/lib/ui/ui-copy.d.ts

@@ -91,7 +91,7 @@ export declare const UI_COPY: {
         readonly experimental: "Experimental";
         readonly experimentalTitle: "Experimental";
         readonly experimentalSubtitle: "Preview sync and backup actions before they become stable";
-        readonly experimentalHelpMenu: "Enter Select | 1 Sync | 2 Backup | 3 Guard | [ - Down | ] + Up | S Save | Q Back";
+        readonly experimentalHelpMenu: "Enter Select | 1 Sync | 2 Backup | 3 Guard | 4 Budget | [ - Down | ] + Up | S Save | Q Back";
         readonly experimentalHelpPreview: "Enter Select | A Apply | Q Back";
         readonly experimentalHelpStatus: "Enter Select | Q Back";
         readonly experimentalSync: "Sync Accounts to oc-chatgpt-multi-auth";
@@ -102,6 +102,7 @@ export declare const UI_COPY: {
         readonly experimentalRefreshInterval: "Refresh Guard Interval";
         readonly experimentalDecreaseInterval: "Decrease Refresh Interval";
         readonly experimentalIncreaseInterval: "Increase Refresh Interval";
+        readonly experimentalContextBudgetGuard: "Enable Context Budget Guard";
         readonly backend: "Backend Controls";
         readonly back: "Back";
         readonly previewHeading: "Live Preview";

package/dist/lib/ui/ui-copy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ui-copy.d.ts","sourceRoot":"","sources":["../../../lib/ui/ui-copy.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAqDP,MAAM,gBACF,MAAM,WACX,MAAM;kDAGiB,MAAM,WAAW,MAAM;kDAEvB,MAAM,gBAAgB,MAAM;iDAE7B,MAAM,gBAAgB,MAAM;;;;;;;;;;;;;;;;;;;;uCAyBtC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CA+EA,MAAM;;;;CAM1B,CAAC;AAEX;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAIpE"}
+{"version":3,"file":"ui-copy.d.ts","sourceRoot":"","sources":["../../../lib/ui/ui-copy.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAqDP,MAAM,gBACF,MAAM,WACX,MAAM;kDAGiB,MAAM,WAAW,MAAM;kDAEvB,MAAM,gBAAgB,MAAM;iDAE7B,MAAM,gBAAgB,MAAM;;;;;;;;;;;;;;;;;;;;uCAyBtC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CAgFA,MAAM;;;;CAM1B,CAAC;AAEX;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAIpE"}

package/dist/lib/ui/ui-copy.js

@@ -92,7 +92,7 @@ export const UI_COPY = {
         experimental: "Experimental",
         experimentalTitle: "Experimental",
         experimentalSubtitle: "Preview sync and backup actions before they become stable",
-        experimentalHelpMenu: "Enter Select | 1 Sync | 2 Backup | 3 Guard | [ - Down | ] + Up | S Save | Q Back",
+        experimentalHelpMenu: "Enter Select | 1 Sync | 2 Backup | 3 Guard | 4 Budget | [ - Down | ] + Up | S Save | Q Back",
         experimentalHelpPreview: "Enter Select | A Apply | Q Back",
         experimentalHelpStatus: "Enter Select | Q Back",
         experimentalSync: "Sync Accounts to oc-chatgpt-multi-auth",
@@ -103,6 +103,7 @@ export const UI_COPY = {
         experimentalRefreshInterval: "Refresh Guard Interval",
         experimentalDecreaseInterval: "Decrease Refresh Interval",
         experimentalIncreaseInterval: "Increase Refresh Interval",
+        experimentalContextBudgetGuard: "Enable Context Budget Guard",
         backend: "Backend Controls",
         back: "Back",
         previewHeading: "Live Preview",

package/dist/lib/usage/pricing.d.ts

@@ -19,7 +19,7 @@ export interface UsageModelPricing {
  * `test/usage-pricing-coverage.test.ts` fails if a NEW routable model appears
  * in neither list.
  */
-export declare const UNPRICED_ROUTABLE_MODELS: readonly ["gpt-5.1", "gpt-5.2-pro", "gpt-5.4-mini", "gpt-5.4-nano", "gpt-5.4-pro", "gpt-5.5-pro", "gpt-5-mini", "gpt-5-nano"];
+export declare const UNPRICED_ROUTABLE_MODELS: readonly ["gpt-6-astra-aeon", "gpt-daybreak-blue-latest", "gpt-daybreak-red-latest", "gpt-5.1", "gpt-5.2-pro", "gpt-5.4-mini", "gpt-5.4-nano", "gpt-5.4-pro", "gpt-5.5-pro", "gpt-5-mini", "gpt-5-nano"];
 export declare function getUsageModelPricing(model: string | null | undefined): UsageModelPricing | null;
 export declare function estimateUsageCostUsd(model: string | null | undefined, tokens: UsageTokenCounts): number | null;
 export declare function listUsageModelPricing(): Record<string, UsageModelPricing>;

package/dist/lib/usage/pricing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pricing.d.ts","sourceRoot":"","sources":["../../../lib/usage/pricing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,MAAM,WAAW,iBAAiB;IACjC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,sBAAsB,CAAC,EAAE,MAAM,CAAC;CAChC;AA2DD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,+HAS3B,CAAC;AAOX,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC9B,iBAAiB,GAAG,IAAI,CAM1B;AAED,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,MAAM,EAAE,gBAAgB,GACtB,MAAM,GAAG,IAAI,CAqBf;AAED,wBAAgB,qBAAqB,IAAI,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAEzE"}
+{"version":3,"file":"pricing.d.ts","sourceRoot":"","sources":["../../../lib/usage/pricing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,MAAM,WAAW,iBAAiB;IACjC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,sBAAsB,CAAC,EAAE,MAAM,CAAC;CAChC;AAwED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,0MAkB3B,CAAC;AAOX,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC9B,iBAAiB,GAAG,IAAI,CAiB1B;AAED,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,MAAM,EAAE,gBAAgB,GACtB,MAAM,GAAG,IAAI,CAqBf;AAED,wBAAgB,qBAAqB,IAAI,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAEzE"}

package/dist/lib/usage/pricing.js

@@ -1,4 +1,17 @@
 const MODEL_PRICING = {
+    // GPT-6 Astra, published at the 2026-09-03 launch: $10 / 1M input,
+    // $50 / 1M output on the standard service tier. Fast mode is 2x standard
+    // ($20 / $100); this table has no service-tier dimension, so it prices the
+    // standard tier and a Fast-mode session is under-counted by half. No cached
+    // input rate was published, so `cachedInputUsdPerMillion` is deliberately
+    // absent: `estimateUsageCostUsd` then bills cached tokens at the full input
+    // rate, which over-states cost. That is the safe direction for a
+    // `maxCostUsd` budget — it trips early, never late.
+    "gpt-6-astra": {
+        inputUsdPerMillion: 10,
+        outputUsdPerMillion: 50,
+        reasoningUsdPerMillion: 50,
+    },
     "gpt-5-codex": {
         inputUsdPerMillion: 1.25,
         outputUsdPerMillion: 10,
@@ -69,6 +82,15 @@ const MODEL_PRICING = {
  * in neither list.
  */
 export const UNPRICED_ROUTABLE_MODELS = [
+    // OpenAI published a rate for the Astra flagship at launch but not for the
+    // long-horizon `aeon` variant, and the Daybreak cyber models are sold under
+    // a separate controlled-access agreement with no public per-token rate.
+    // Pricing `aeon` off the flagship would be a guess on the model whose whole
+    // purpose is running for days, which is exactly where a wrong rate does the
+    // most damage.
+    "gpt-6-astra-aeon",
+    "gpt-daybreak-blue-latest",
+    "gpt-daybreak-red-latest",
     "gpt-5.1",
     "gpt-5.2-pro",
     "gpt-5.4-mini",
@@ -87,6 +109,17 @@ export function getUsageModelPricing(model) {
     if (!normalized) {
         return null;
     }
+    // `Object.hasOwn`, not a bare index. The model string arrives raw from the
+    // client (`createUsageLedgerRow` only trims it), so `constructor`,
+    // `toString` and friends reach this lookup and a bare index hands back the
+    // matching `Object.prototype` member. That object is truthy, so it is
+    // returned as a rate, and every field on it is undefined: the cost comes out
+    // `NaN` instead of `null`. A NaN cost is worse than an unknown one, because
+    // `NaN >= limit` is false, so it silently makes a `maxCostUsd` budget
+    // unenforceable rather than failing closed the way an unpriced model does.
+    if (!Object.hasOwn(MODEL_PRICING, normalized)) {
+        return null;
+    }
     return MODEL_PRICING[normalized] ?? null;
 }
 export function estimateUsageCostUsd(model, tokens) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "codex-multi-auth",
-	"version": "2.9.2",
+	"version": "2.11.0",
 	"description": "Codex CLI multi-account OAuth manager with account switching, health checks, runtime rotation, diagnostics, and recovery tools for @openai/codex",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",

package/scripts/codex.js

@@ -574,7 +574,27 @@ async function applyForcedAccountSelection(rawArgs, env = process.env) {
 }
 
 function resolveModelFamilyForStatus(model) {
-	const normalized = typeof model === "string" ? model.trim().toLowerCase() : "";
+	// `resolveStatusModel` hands over the raw `--model` / `-m` value or the
+	// config value verbatim, so a provider-qualified id arrives intact. Every
+	// branch below is a `startsWith`, so `openai/gpt-6` used to match none of
+	// them and return null, dropping status routing back to `activeIndex`
+	// instead of the family index. Strip the prefix once, for all of them.
+	const normalized =
+		typeof model === "string"
+			? stripProviderPrefix(model.trim()).toLowerCase()
+			: "";
+	// GPT-6 Astra and the Daybreak cyber models share the gpt-5.2 prompt family
+	// with the GPT-5.6 general tiers (see lib/request/helpers/model-map.ts
+	// MODEL_PROFILES). Daybreak has to be checked explicitly: its slug matches
+	// none of the branches below, so it used to fall through to `null` and get
+	// bucketed against no family at all.
+	if (
+		(normalized.startsWith("gpt-6") || normalized.startsWith("astra")) &&
+		!normalized.includes("codex")
+	) {
+		return "gpt-5.2";
+	}
+	if (normalized.includes("daybreak")) return "gpt-5.2";
 	// GPT-5.6 general tiers share the gpt-5.2 prompt family (see
 	// lib/request/helpers/model-map.ts MODEL_PROFILES). Check before the generic
 	// gpt-5 catch-all, which would otherwise mis-bucket them as codex.
@@ -1259,7 +1279,18 @@ const DIRECT_UNSUPPORTED_MODEL_PATTERN =
 	/['"]([^'"]+)['"]\s+model is not supported when using codex with a chatgpt account/i;
 const CURRENT_CODEX_MODEL = "gpt-5.3-codex";
 const LEGACY_CODEX_MODEL = "gpt-5-codex";
+// Mirrors the GPT-6 rows of lib/request/error-classification.ts
+// `DEFAULT_UNSUPPORTED_CODEX_FALLBACK_CHAIN`. This table is walked differently
+// from lib's: `resolveUnsupportedModelRetryTarget` keys on the model named in
+// the error output and falls back to the original requested model, with
+// `attemptedModels` accumulating, so a row's later entries ARE reachable here.
+// The two tables are not identical today (`gpt-5.3-codex` has a row in lib and
+// not here), which predates GPT-6 and is left alone; the GPT-6 rows are pinned
+// in parity by test/codex-model-resolution.test.ts.
 const WRAPPER_UNSUPPORTED_MODEL_FALLBACK_CHAIN = {
+	"gpt-6-astra": ["gpt-5.6-sol", "gpt-5.5"],
+	"gpt-6-astra-aeon": ["gpt-6-astra", "gpt-5.6-sol"],
+	"gpt-5.6-sol": ["gpt-5.5"],
 	"gpt-5": ["gpt-5.5"],
 	"gpt-5-pro": ["gpt-5.5-pro"],
 	"gpt-5-chat-latest": ["gpt-5.5"],
@@ -1901,6 +1932,10 @@ function hasCliAuthCredentialsStoreOverride(args) {
 // This wrapper runs before the TypeScript build, so it cannot import that source.
 const SUPPORTED_REASONING_EFFORTS_BY_MODEL = {
 	[CURRENT_CODEX_MODEL]: ["low", "medium", "high", "xhigh"],
+	"gpt-6-astra": ["low", "medium", "high", "xhigh", "max", "ultra"],
+	"gpt-6-astra-aeon": ["low", "medium", "high", "xhigh", "max", "ultra"],
+	"gpt-daybreak-blue-latest": ["low", "medium", "high", "xhigh", "max", "ultra"],
+	"gpt-daybreak-red-latest": ["low", "medium", "high", "xhigh", "max", "ultra"],
 	"gpt-5.6-sol": ["low", "medium", "high", "xhigh", "max", "ultra"],
 	"gpt-5.6-terra": ["low", "medium", "high", "xhigh", "max", "ultra"],
 	"gpt-5.6-luna": ["low", "medium", "high", "xhigh", "max"],
@@ -1960,6 +1995,18 @@ const GPT_5_6_LUNA_MODEL = "gpt-5.6-luna";
 const GPT_5_6_FLAGSHIP_ALIAS = "gpt-5.6";
 const GPT_5_6_SOL_TERRA_EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultra"];
 const GPT_5_6_LUNA_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+// GPT-6 Astra (2026-09-03). No Sol/Terra/Luna split this generation: the
+// flagship plus `aeon`, a long-horizon variant. Same frontier effort ladder as
+// 5.6 (no `none`/`minimal`, `ultra` at the top). Bare `gpt-6` -> flagship.
+const GPT_6_ASTRA_MODEL = "gpt-6-astra";
+const GPT_6_ASTRA_AEON_MODEL = "gpt-6-astra-aeon";
+const GPT_6_FLAGSHIP_ALIAS = "gpt-6";
+const GPT_6_ASTRA_EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultra"];
+// Daybreak cyber models from the upstream Codex catalog. `red` is the
+// cyber-permissive variant, `blue` the defensive one.
+const DAYBREAK_BLUE_MODEL = "gpt-daybreak-blue-latest";
+const DAYBREAK_RED_MODEL = "gpt-daybreak-red-latest";
+const DAYBREAK_EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultra"];
 const GENERAL_GPT5_VERSION_CATALOG = {
 	1: {
 		base: "gpt-5.1",
@@ -2163,6 +2210,47 @@ function seedRequestedModelAliases() {
 		GPT_5_6_SOL_MODEL,
 		GPT_5_6_SOL_TERRA_EFFORTS,
 	);
+	addRequestedModelEffortAliases(
+		GPT_6_ASTRA_MODEL,
+		GPT_6_ASTRA_MODEL,
+		GPT_6_ASTRA_EFFORTS,
+	);
+	addRequestedModelEffortAliases(
+		GPT_6_ASTRA_AEON_MODEL,
+		GPT_6_ASTRA_AEON_MODEL,
+		GPT_6_ASTRA_EFFORTS,
+	);
+	addRequestedModelEffortAliases(
+		GPT_6_FLAGSHIP_ALIAS,
+		GPT_6_ASTRA_MODEL,
+		GPT_6_ASTRA_EFFORTS,
+	);
+	addRequestedModelEffortAliases("astra", GPT_6_ASTRA_MODEL, GPT_6_ASTRA_EFFORTS);
+	addRequestedModelEffortAliases(
+		"astra-aeon",
+		GPT_6_ASTRA_AEON_MODEL,
+		GPT_6_ASTRA_EFFORTS,
+	);
+	addRequestedModelEffortAliases(
+		DAYBREAK_BLUE_MODEL,
+		DAYBREAK_BLUE_MODEL,
+		DAYBREAK_EFFORTS,
+	);
+	addRequestedModelEffortAliases(
+		DAYBREAK_RED_MODEL,
+		DAYBREAK_RED_MODEL,
+		DAYBREAK_EFFORTS,
+	);
+	addRequestedModelEffortAliases(
+		"daybreak-blue",
+		DAYBREAK_BLUE_MODEL,
+		DAYBREAK_EFFORTS,
+	);
+	addRequestedModelEffortAliases(
+		"daybreak-red",
+		DAYBREAK_RED_MODEL,
+		DAYBREAK_EFFORTS,
+	);
 	addRequestedModelReasoningAliases(CURRENT_CODEX_MODEL, CURRENT_CODEX_MODEL);
 	addRequestedModelReasoningAliases("gpt-5.3-codex-spark", CURRENT_CODEX_MODEL);
 	addRequestedModelReasoningAliases(LEGACY_CODEX_MODEL, CURRENT_CODEX_MODEL);
@@ -2218,6 +2306,13 @@ function resolveStableGeneralGpt5Variant(variant) {
 	return fallback;
 }
 
+// The final clause is a catch-all on the `codex` substring, matching
+// `resolveCodexCatalogModel` in lib/request/helpers/model-map.ts. It used to be
+// an exact `normalized === "codex"` check, so any codex id the explicit list
+// above did not name (`gpt-6-codex`, `gpt-5.7-codex`, …) resolved to nothing in
+// the wrapper while lib resolved it to the current codex model — a silent drift
+// between the two, which is exactly what test/codex-model-resolution.test.ts
+// exists to prevent.
 function resolveCodexRequestedModel(normalized) {
 	if (
 		normalized.includes("gpt-5.1-codex-max") ||
@@ -2246,7 +2341,7 @@ function resolveCodexRequestedModel(normalized) {
 		normalized.includes("gpt 5.1 codex") ||
 		normalized.includes("gpt-5-codex") ||
 		normalized.includes("gpt 5 codex") ||
-		normalized === "codex"
+		normalized.includes("codex")
 	) {
 		return CURRENT_CODEX_MODEL;
 	}
@@ -2258,6 +2353,51 @@ function resolveCodexRequestedModel(normalized) {
 // future `gpt-5.6-terra-fast`). Without this the general GPT-5 resolver sees
 // minor `6`, finds no catalog entry, and silently falls back to 5.5. Unknown
 // tiers resolve to Sol, matching OpenAI's bare `gpt-5.6` alias.
+// Resolve GPT-6 identifiers that are not exact aliases (a dated snapshot, the
+// `gpt-6-astra-pro` plan tier, or a tier OpenAI adds later). Without this the
+// general GPT-5 resolver never matches (it needs a `gpt 5` token pair) and the
+// id falls through to 5.5 — running GPT-5.5 for a caller who asked for the
+// frontier model. `aeon` keeps its own id because it is a behaviourally
+// different model, not a rename. Mirrors lib/request/helpers/model-map.ts.
+function resolveGpt6RequestedModel(stripped) {
+	const tokens = tokenizeRequestedModel(stripped);
+	const gptIndex = tokens.indexOf("gpt");
+	// `gpt6` with no separator tokenizes as one token, so the `gpt` + `6` pair
+	// never forms; mirror lib and claim it here.
+	const versionToken = gptIndex === -1 ? undefined : tokens[gptIndex + 1];
+	// `gpt6` with no separator tokenizes as one token, so the `gpt` + `6` pair
+	// never forms; mirror lib and claim it here.
+	const isGpt6 = versionToken === "6" || tokens.includes("gpt6");
+	// A bare `astra` token counts too: picker labels and OpenAI's own material
+	// say "Astra" with no `gpt-6` prefix, so `Astra Pro` arrives with no version
+	// tokens and would otherwise miss every branch and land on 5.5. Anchored so
+	// an id naming a different GPT major version, `gpt-4-astra-x`, is not
+	// claimed for the frontier model.
+	const namesOtherGptVersion =
+		versionToken !== undefined &&
+		/^\d+$/.test(versionToken) &&
+		versionToken !== "6";
+	const isAstra = tokens.includes("astra") && !namesOtherGptVersion;
+	if ((!isGpt6 && !isAstra) || tokens.includes("codex")) {
+		return "";
+	}
+	if (tokens.includes("aeon")) return GPT_6_ASTRA_AEON_MODEL;
+	return GPT_6_ASTRA_MODEL;
+}
+
+// Daybreak slugs carry neither a `codex` nor a `gpt 5` token, so every other
+// resolver declines them and they would reach the 5.5 default. An unrecognised
+// Daybreak id resolves to `blue`, the more restricted of the two, so a typo
+// cannot silently upgrade a caller into the cyber-permissive model.
+function resolveDaybreakRequestedModel(stripped) {
+	const tokens = tokenizeRequestedModel(stripped);
+	if (!tokens.includes("daybreak")) {
+		return "";
+	}
+	if (tokens.includes("red")) return DAYBREAK_RED_MODEL;
+	return DAYBREAK_BLUE_MODEL;
+}
+
 function resolveGpt56RequestedModel(stripped) {
 	const tokens = tokenizeRequestedModel(stripped);
 	const gptIndex = tokens.indexOf("gpt");
@@ -2316,11 +2456,21 @@ function normalizeRequestedModel(model) {
 		return exactMatch;
 	}
 
+	const daybreakModel = resolveDaybreakRequestedModel(stripped);
+	if (daybreakModel) {
+		return daybreakModel;
+	}
+
 	const codexModel = resolveCodexRequestedModel(normalized);
 	if (codexModel) {
 		return codexModel;
 	}
 
+	const gpt6Model = resolveGpt6RequestedModel(stripped);
+	if (gpt6Model) {
+		return gpt6Model;
+	}
+
 	const gpt56Model = resolveGpt56RequestedModel(stripped);
 	if (gpt56Model) {
 		return gpt56Model;
@@ -6240,6 +6390,7 @@ export {
 	coerceReasoningEffortForModel,
 	resolveModelFamilyForStatus,
 	canonicalizeRequestedModelName,
+	WRAPPER_UNSUPPORTED_MODEL_FALLBACK_CHAIN,
 };
 
 // Run the wrapper only when actually launched (as the `codex-multi-auth-codex`