@bitkyc08/opencodex 2.42.0 → 2.43.0

package/src/types/provider.ts

@@ -270,6 +270,12 @@ export interface OcxProviderConfig {
    * compaction blobs. Absent or false degrades foreign blobs to an opaque note.
    */
   decodesNativeCompactionBlobs?: boolean;
+  /**
+   * Trust this direct key-auth Responses provider to consume or relay opaque encrypted
+   * V2 agent tasks. OpenCodex does not decrypt, translate, or recover an eligible task.
+   * Absent or false keeps the existing recovery/fail-closed behavior.
+   */
+  allowEncryptedV2AgentTasks?: boolean;
   /**
    * Explicit opt-in for non-registry private-network destinations such as localhost, RFC1918,
    * link-local, or unique-local upstreams. Metadata endpoints remain blocked.
@@ -339,6 +345,13 @@ export interface OcxProviderConfig {
    * full set so the user can pick). See devlog issue_052_provider-model-allowlist.
    */
   selectedModels?: string[];
+  /** Registration-owned state. Absent means legacy or OAuth-exempt, not uninitialized. */
+  initialModelSelection?: {
+    version: 1;
+    registrationId: string;
+    status: "pending" | "ready" | "all-off";
+    modelCount?: number;
+  };
   /**
    * Per-provider retention allowlist for authoritative live discovery. When non-empty, any
    * model id in this list is preserved in the routed catalog even if the live `/models`
@@ -424,11 +437,13 @@ export interface OcxProviderConfig {
    */
   authMode?: "key" | "forward" | "oauth" | "local";
   /**
-   * Per-provider override for generic OAuth multi-account 429 failover (#2568).
+   * Per-provider override for the generic OAuth PROACTIVE account preference (#2568, #695).
    *
-   * Rotation is presence-driven by default — 2+ logged-in accounts activate it — so this exists
-   * for the operator who accepts rotation on one provider and refuses it on another. An explicit
-   * boolean here beats the global `oauthAccountFailover` and beats presence.
+   * Reactive 429 rotation is presence-driven and cannot be refused here — 2+ logged-in accounts
+   * activate it, and a 429 with an idle second account is a defect rather than a preference.
+   * What an explicit `false` still refuses is the pre-dispatch preference that steers a HEALTHY
+   * request toward the account with more known headroom. It beats the global
+   * `oauthAccountFailover` in either direction; reactive 429 rotation remains presence-driven.
    */
   oauthAccountFailover?: {
     enabled?: boolean;
@@ -506,6 +521,8 @@ export interface OcxProviderConfig {
    * from the web-search sidecar's `search.xSearch` options and never widens caller tool selectors.
    */
   xaiResponsesXSearch?: boolean;
+  /** One-time Grok subscription wire upgrade; later explicit Chat choices remain authoritative. */
+  xaiResponsesDefaultVersion?: number;
   /**
    * Whether the Responses upstream accepts native custom tools and custom_tool_call items.
    * Set false only for a provider whose native contract rejects them; absence preserves
@@ -518,9 +535,21 @@ export interface OcxProviderConfig {
    * SSE/JSON; raw inspection state remains authoritative.
    */
   responsesSnapshotRepair?: boolean;
-  /** Provider-wide mapping from Codex effort labels to upstream `reasoning_effort` values. */
+  /**
+   * Provider-wide mapping from Codex effort labels to upstream `reasoning_effort` values.
+   * Map a label to the reserved value `"__omit__"` to send no reasoning field at all for that
+   * effort, so the upstream model's own default applies. The sentinel is
+   * `REASONING_EFFORT_OMIT_SENTINEL` in `src/reasoning-effort.ts`; it suppresses
+   * `reasoning_effort` on an OpenAI-compatible wire and Ollama's native `think` field on the
+   * Ollama native adapter (#2356).
+   */
   reasoningEffortMap?: Record<string, string>;
-  /** Model-specific mapping from Codex effort labels to upstream `reasoning_effort` values. */
+  /**
+   * Model-specific mapping from Codex effort labels to upstream `reasoning_effort` values.
+   * Map a label to the reserved value `"__omit__"` to send no reasoning field at all for that
+   * effort, so the upstream model's own default applies. Same sentinel as
+   * `reasoningEffortMap`, resolved per model first.
+   */
   modelReasoningEffortMap?: Record<string, Record<string, string>>;
   /** OpenAI-compatible gateway reasoning wire shape. Default sends `reasoning_effort`. */
   reasoningWireFormat?: "gateway-object";
@@ -696,7 +725,7 @@ export interface OcxProviderConfig {
    * headless and cannot control a screen itself; provide commands here only when running on a host
    * that can. With no executor, these tools honestly report "not supported".
    */
-  desktopExecutor?: import("../adapters/cursor/native-exec-desktop").DesktopExecutorConfig;
+  desktopExecutor?: import("../adapters/cursor/desktop-executor-contract").DesktopExecutorConfig;
   /**
    * Cursor adapter only: unsafe opt-in escape hatch for Cursor server-driven built-in local
    * read/write/delete/ls/grep/shell/fetch execution. Prefer `nativeLocalExec: "on"` for new

package/src/types/tools.ts

@@ -31,6 +31,17 @@ export function namespacedToolName(namespace: string | undefined, name: string):
   return namespace ? `${namespace}__${name}` : name;
 }
 
+/**
+ * Dotted alias of a namespaced tool's wire name. Some routed providers (observed: muse-spark
+ * via opencode-go) echo a namespaced tool call as "<namespace>.<name>" instead of the flattened
+ * "<namespace>__<name>" form. It names the same tool identity+�u���T never a new grant"��y��y� so the
+ * undeclared-tool guard and the tool bridge maps accept it wherever the wire name is accepted
+ * (mirroring the second entry of `toolChoiceAliases`). See #3402.
+ */
+export function dottedToolName(namespace: string | undefined, name: string): string {
+  return namespace ? `${namespace}.${name}` : name;
+}
+
 /**
  * Codex unified-exec name normalization.
  *
@@ -73,9 +84,23 @@ export function normalizeDeclaredToolName(
     : name;
 }
 
+/**
+ * True when a declared catalog is the genuine Codex code-mode shape.
+ *
+ * `exec` is a name, not a guarantee. A catalog that lists `exec` NEXT TO a bare
+ * `exec_command` or `shell_command` is the flat-bridge shape: there `exec` may be an
+ * ordinary caller-defined tool, and nested `tools.*` helpers are not what it runs.
+ * `normalizeDeclaredToolName` already refuses to reinterpret helper names in that shape,
+ * and anything inferring code mode from the bare name owes the same check.
+ */
+export function declaresCodeModeExec(declared: ReadonlySet<string> | undefined): boolean {
+  if (!declared || !declared.has(CODE_MODE_EXEC_TOOL_NAME)) return false;
+  return !(LEGACY_SHELL_BRIDGE_TOOL_NAMES as readonly string[]).some(legacy => declared.has(legacy));
+}
+
 export function toolChoiceAliases(tool: Pick<OcxTool, "namespace" | "name">): string[] {
   const wireName = namespacedToolName(tool.namespace, tool.name);
-  return tool.namespace ? [wireName, `${tool.namespace}.${tool.name}`] : [wireName];
+  return tool.namespace ? [wireName, dottedToolName(tool.namespace, tool.name)] : [wireName];
 }
 
 function sameToolIdentity(

package/src/types.ts

@@ -4,6 +4,7 @@
 export type { OcxTool, OcxToolChoice } from "./types/tools";
 export {
   CODE_MODE_EXEC_TOOL_NAME,
+  dottedToolName,
   namespacedToolName,
   normalizeDeclaredToolName,
   toolChoiceAliases,
@@ -14,6 +15,7 @@ export {
   modelInList,
   isAllowedToolChoice,
   toolChoiceToolPredicate,
+  declaresCodeModeExec,
 } from "./types/tools";
 
 export type { UpstreamHttpVersion, ReasoningSummaryDelivery, CodexAccountMode } from "./types/wire";

package/src/update/notify.ts

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { isatty } from "node:tty";
 import { createInterface } from "node:readline/promises";
 import { atomicWriteFile, getConfigDir } from "../config";
 import { hasStarPromptRun } from "../cli/star-prompt";
@@ -122,8 +123,13 @@ export function isSourceBuildVersion(v: string): boolean {
 }
 
 /** The interactive/TTY + install-method gate shared with the star prompt. */
-function interactiveGuardOk(): boolean {
-  return !(process.env.OCX_SERVICE || !process.stdin.isTTY || !process.stdout.isTTY);
+export function interactiveGuardOk(): boolean {
+  try {
+    return !(process.env.OCX_SERVICE || !isatty(0) || !isatty(1));
+  } catch {
+    /* best-effort */
+    return false;
+  }
 }
 
 /**

package/src/usage/cost.ts

@@ -15,6 +15,7 @@ import {
   resolveMetadataProvider,
 } from "../generated/model-metadata";
 import type { AttemptTierOutcome, OcxUsage } from "../types";
+import { canonicalFastTierMarker } from "../providers/fastwire";
 import { baseProviderLabel, canonicalUsageProviderLabel } from "../providers/label";
 import type { PersistedUsageAttempt, UsageStatus } from "./log";
 import { canonicalAntigravityUsageModel } from "../providers/antigravity-models";
@@ -34,12 +35,18 @@ import {
 /** Published long-context pricing band (#908). */
 export type ContextTierName = "long";
 
+export interface PriceResolutionOptions {
+  /** False for unresolved slash selectors; exact provider/user rates still apply. */
+  allowModelLevelFallback?: boolean;
+}
+
+type AttemptCostInput = Pick<PersistedUsageAttempt, "ordinal" | "provider" | "model" | "usage" | "usageStatus" | "tierOutcome"> & PriceResolutionOptions;
+
 /**
  * Service-tier provenance. `effectiveServiceTier()` collapses these with `??`,
- * but long-context exclusivity needs to know WHICH source supplied "priority":
- * OpenAI does not serve long context in Fast mode, so a >272k request that was
- * merely TAGGED priority was necessarily downgraded and must still be priced at
- * the long rate. Only a response-confirmed Fast tier suppresses the context tier.
+ * but provider-specific long-context rules need to know WHICH source supplied Fast.
+ * Current API rows stack Fast and long rates; legacy exclusive rows and unknown
+ * vendor combinations still require response-confirmed provenance.
  */
 export interface ServiceTierContext {
   responseServiceTier?: string;
@@ -178,6 +185,7 @@ export function resolveMatchedPrice(
   modelId: string,
   overlays: readonly ExpectedPriceOverlay[] = EXPECTED_PRICE_OVERLAYS,
   userOverlays: readonly ExpectedPriceOverlay[] = activeUserCostOverlays(),
+  options: PriceResolutionOptions = {},
 ): MatchedPrice | null {
   // User-configured overlays are keyed by the EXACT configured provider name.
   // A provider that literally exists in config.providers keeps its own pricing
@@ -201,14 +209,14 @@ export function resolveMatchedPrice(
   // user overlays get a NEW array identity + version bump on every config refresh,
   // so memoized rows never go stale.
   if (overlays === EXPECTED_PRICE_OVERLAYS && userOverlays === activeUserCostOverlays()) {
-    const cacheKey = `${userCostOverlayVersion()} ${provider} ${modelId}`;
+    const cacheKey = `${userCostOverlayVersion()} ${options.allowModelLevelFallback !== false} ${provider} ${modelId}`;
     if (!priceMemo.has(cacheKey)) {
       if (priceMemo.size >= 512) priceMemo.clear();
-      priceMemo.set(cacheKey, resolveMatchedPriceInner(provider, modelId, overlays, userOverlays));
+      priceMemo.set(cacheKey, resolveMatchedPriceInner(provider, modelId, overlays, userOverlays, options));
     }
     return priceMemo.get(cacheKey)!;
   }
-  return resolveMatchedPriceInner(provider, modelId, overlays, userOverlays);
+  return resolveMatchedPriceInner(provider, modelId, overlays, userOverlays, options);
 }
 
 const priceMemo = new Map<string, MatchedPrice | null>();
@@ -223,14 +231,15 @@ function resolveMatchedPriceInner(
   modelId: string,
   overlays: readonly ExpectedPriceOverlay[],
   userOverlays: readonly ExpectedPriceOverlay[],
+  options: PriceResolutionOptions,
 ): MatchedPrice | null {
-  const direct = resolveMatchedPriceExact(provider, modelId, overlays, userOverlays);
+  const direct = resolveMatchedPriceExact(provider, modelId, overlays, userOverlays, options);
   if (direct) return direct;
   // Antigravity historical/wire ids often lack an exact overlay; fall back to the
   // picker/call base model so collapsed usage rows still get a price.
   if (provider === "google-antigravity" || provider.startsWith("google-antigravity")) {
     const base = canonicalAntigravityUsageModel(modelId);
-    if (base !== modelId) return resolveMatchedPriceExact(provider, base, overlays, userOverlays);
+    if (base !== modelId) return resolveMatchedPriceExact(provider, base, overlays, userOverlays, options);
   }
   return null;
 }
@@ -245,6 +254,7 @@ function resolveMatchedPriceExact(
   modelId: string,
   overlays: readonly ExpectedPriceOverlay[],
   userOverlays: readonly ExpectedPriceOverlay[],
+  options: PriceResolutionOptions,
 ): MatchedPrice | null {
   // User-configured provider overlay wins over every compiled catalog: the
   // operator's explicit price is authoritative for the ~$ estimate.
@@ -253,7 +263,7 @@ function resolveMatchedPriceExact(
   const verifiedOverride = overlays === EXPECTED_PRICE_OVERLAYS
     ? findVerifiedPriceOverride(provider, modelId)
     : undefined;
-  if (verifiedOverride && validCost4(verifiedOverride.cost4) && hasNonZeroCost(verifiedOverride.cost4)) {
+  if (verifiedOverride && verifiedOverride.status !== "unverified" && validCost4(verifiedOverride.cost4) && hasNonZeroCost(verifiedOverride.cost4)) {
     return {
       provider,
       modelId,
@@ -261,7 +271,7 @@ function resolveMatchedPriceExact(
       source: "expected",
       sourceRef: verifiedOverride.source,
       verifiedAt: verifiedOverride.verifiedAt,
-      status: "verified",
+      status: verifiedOverride.status,
     };
   }
   const metadataProvider = resolveMetadataProvider(provider);
@@ -280,7 +290,7 @@ function resolveMatchedPriceExact(
   }
   const overlay = findExpectedPriceOverlay(provider, modelId, overlays);
   if (!overlay || !validCost4(overlay.cost4) || !hasNonZeroCost(overlay.cost4)) {
-    return resolveModelLevelPrice(provider, modelId);
+    return options.allowModelLevelFallback === false ? null : resolveModelLevelPrice(provider, modelId);
   }
   if (overlay.status === "unverified") return null;
   return {
@@ -433,7 +443,7 @@ function tierScalar(tier?: ServiceTierInput): string | undefined {
 
 /** True only when the UPSTREAM RESPONSE confirmed the Fast tier (see ServiceTierContext). */
 function isConfirmedFast(tier?: ServiceTierInput): boolean {
-  return typeof tier === "object" && tier.responseServiceTier === "priority";
+  return typeof tier === "object" && canonicalFastTierMarker(tier.responseServiceTier) === "priority";
 }
 
 /**
@@ -445,7 +455,7 @@ function isConfirmedFast(tier?: ServiceTierInput): boolean {
  * cache-heavy long prompt would fall below the boundary and under-bill.
  *
  * A provider's declaration decides how a response-confirmed priority tier relates to this band.
- * OpenAI declares the bands exclusive. xAI publishes neither a combined rate nor an exclusion,
+ * API rows can stack the bands. xAI publishes neither a combined rate nor an exclusion,
  * so its long-context rate remains the known lower bound instead of inventing a stacked multiplier.
  */
 function applyContextTier(
@@ -481,9 +491,11 @@ function applyPriorityMultiplier(
   provider: string,
   modelId: string,
   serviceTier?: ServiceTierInput,
+  contextTier?: ContextTierName,
 ): [Cost4, number] {
-  if (tierScalar(serviceTier) !== "priority") return [cost4, 1];
+  if (canonicalFastTierMarker(tierScalar(serviceTier)) !== "priority") return [cost4, 1];
   const base = baseProviderLabel(provider);
+  if (contextTier && findContextTier(base, modelId)?.confirmedPriorityRelation !== "stack") return [cost4, 1];
   const rule = findPriorityPricingRule(base, modelId);
   if (rule?.requiresResponseConfirmation && !isConfirmedFast(serviceTier)) return [cost4, 1];
   const multiplier = rule?.multiplier ?? 1;
@@ -524,7 +536,7 @@ function isOpenRouterPriorityLowerBound(
  * missing so combos can fail closed.
  */
 export function estimateAttemptCost(
-  attempt: Pick<PersistedUsageAttempt, "ordinal" | "provider" | "model" | "usage" | "usageStatus" | "tierOutcome">,
+  attempt: AttemptCostInput,
   overlays: readonly ExpectedPriceOverlay[] = EXPECTED_PRICE_OVERLAYS,
   serviceTier?: ServiceTierInput,
   userOverlays: readonly ExpectedPriceOverlay[] = activeUserCostOverlays(),
@@ -532,7 +544,7 @@ export function estimateAttemptCost(
   if (!attempt.usage) return null;
   const tokens = normalizeCostTokens(attempt.usage);
   if (!tokens) return null;
-  const price = resolveMatchedPrice(attempt.provider, attempt.model, overlays, userOverlays);
+  const price = resolveMatchedPrice(attempt.provider, attempt.model, overlays, userOverlays, attempt);
   if (!price) return null;
   const attemptServiceTier = attempt.tierOutcome
     ? serviceTierContextFromOutcome(attempt.tierOutcome)
@@ -540,12 +552,9 @@ export function estimateAttemptCost(
   const [tieredCost4, contextTier, contextPriorityLowerBound] = applyContextTier(
     price.cost4, attempt.provider, attempt.model, attempt.usage.inputTokens, attemptServiceTier,
   );
-  // A published long-context row owns the numeric estimate. OpenAI declares that band
-  // exclusive with Fast; xAI's confirmed combination is deliberately left unmultiplied
-  // and marked as a lower bound because no combined price has been published.
-  const [effectiveCost4, multiplier] = contextTier
-    ? [tieredCost4, 1] as const
-    : applyPriorityMultiplier(tieredCost4, attempt.provider, attempt.model, attemptServiceTier);
+  const [effectiveCost4, multiplier] = applyPriorityMultiplier(
+    tieredCost4, attempt.provider, attempt.model, attemptServiceTier, contextTier,
+  );
   const priorityLowerBound = contextPriorityLowerBound
     || isOpenRouterPriorityLowerBound(attempt.provider, attempt.tierOutcome);
   return {
@@ -567,7 +576,7 @@ export function estimateAttemptCost(
  * attempt is unpriced or unnormalizable, return null rather than a partial sum.
  */
 export function estimateComboCost(
-  attempts: readonly Pick<PersistedUsageAttempt, "ordinal" | "provider" | "model" | "usage" | "usageStatus" | "tierOutcome">[],
+  attempts: readonly AttemptCostInput[],
   overlays: readonly ExpectedPriceOverlay[] = EXPECTED_PRICE_OVERLAYS,
   serviceTier?: ServiceTierInput,
   userOverlays: readonly ExpectedPriceOverlay[] = activeUserCostOverlays(),
@@ -615,6 +624,7 @@ export function estimateRequestCost(
     usage?: OcxUsage;
     usageStatus: UsageStatus;
     serviceTier?: ServiceTierInput;
+    allowModelLevelFallback?: boolean;
   },
   overlays: readonly ExpectedPriceOverlay[] = EXPECTED_PRICE_OVERLAYS,
   userOverlays: readonly ExpectedPriceOverlay[] = activeUserCostOverlays(),
@@ -622,14 +632,14 @@ export function estimateRequestCost(
   if (!input.usage) return null;
   const tokens = normalizeCostTokens(input.usage);
   if (!tokens) return null;
-  const price = resolveMatchedPrice(input.provider, input.model, overlays, userOverlays);
+  const price = resolveMatchedPrice(input.provider, input.model, overlays, userOverlays, input);
   if (!price) return null;
   const [tieredCost4, contextTier, contextPriorityLowerBound] = applyContextTier(
     price.cost4, input.provider, input.model, input.usage.inputTokens, input.serviceTier,
   );
-  const [effectiveCost4, multiplier] = contextTier
-    ? [tieredCost4, 1] as const
-    : applyPriorityMultiplier(tieredCost4, input.provider, input.model, input.serviceTier);
+  const [effectiveCost4, multiplier] = applyPriorityMultiplier(
+    tieredCost4, input.provider, input.model, input.serviceTier, contextTier,
+  );
   const priorityLowerBound = contextPriorityLowerBound || isOpenRouterPriorityLowerBound(
     input.provider,
     typeof input.serviceTier === "object" ? input.serviceTier.tierOutcome : undefined,

package/src/usage/expected-prices.ts

@@ -42,6 +42,8 @@ export interface ExpectedPriceOverlay {
 
 const GEMINI_31_PRO: Cost4 = { input: 2, output: 12, cacheRead: 0.2, cacheWrite: 0 };
 const GPT56_SOL: Cost4 = { input: 4, output: 20, cacheRead: 0.4, cacheWrite: 5 };
+const GPT6_ASTRA: Cost4 = { input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5 };
+const ASTRA_API_PRICING = "https://developers.openai.com/api/docs/models/gpt-6-astra";
 /**
  * Daybreak aliases. `daybreak-*-latest` never appears in the pricing table itself — only its
  * current snapshot does — so these tuples are the snapshot's published rates and carry
@@ -112,9 +114,14 @@ const KIMI_PRICING = "https://platform.kimi.ai/docs/pricing (official table; cac
 const QWEN38_MAX_PRICING = "https://qwen.ai/blog?id=qwen3.8 (Qwen release announcement; no Model Studio billing row yet; cache rates unpublished -> 0)";
 
 export const EXPECTED_PRICE_OVERLAYS: readonly ExpectedPriceOverlay[] = [
-  // claude-fable-5-1 has no jawcode row yet, so both Anthropic surfaces need their own
-  // overlay (the overlay lookup is keyed by the configured provider id; only the jawcode
-  // bundle collapses anthropic-apikey onto anthropic).
+  { provider: "openai-apikey", modelId: "gpt-6-astra", cost4: GPT6_ASTRA, source: ASTRA_API_PRICING, verifiedAt: "2026-09-05", status: "verified" },
+  // Display estimates use API prices for both login and API-key routes, including cache writes.
+  { provider: "openai", modelId: "gpt-6-astra", cost4: GPT6_ASTRA, source: `API-reference comparison estimate: ${ASTRA_API_PRICING}`, verifiedAt: "2026-09-05", status: "verified-derived" },
+  // claude-fable-5-1 now HAS a generated jawcode row, so the two Anthropic surfaces resolve
+  // from it and these overlays are the fallback rather than the primary source. They stay:
+  // the overlay lookup is keyed by the configured provider id, so an account-pool log label
+  // like anthropic-pb51d9b still needs them, and only the jawcode bundle collapses
+  // anthropic-apikey onto anthropic.
   { provider: "anthropic", modelId: "claude-fable-5-1", cost4: CLAUDE_FABLE_51, source: `anthropic official Claude Fable 5.1 ${ANTHROPIC_PRICING}; cache hit = 0.025x base input`, verifiedAt: "2026-09-02", status: "verified" },
   { provider: "anthropic-apikey", modelId: "claude-fable-5-1", cost4: CLAUDE_FABLE_51, source: `anthropic official Claude Fable 5.1 ${ANTHROPIC_PRICING}; cache hit = 0.025x base input`, verifiedAt: "2026-09-02", status: "verified" },
   // Cursor canonicalizes every Fable 5.1 spelling onto this sole overlay row.
@@ -237,6 +244,11 @@ export const EXPECTED_PRICE_OVERLAYS: readonly ExpectedPriceOverlay[] = [
  * therefore cannot reprice routed resellers that reuse the same model slug.
  */
 export const VERIFIED_PRICE_OVERRIDES: readonly ExpectedPriceOverlay[] = [
+  ...["openai", "openai-apikey"].map((provider): ExpectedPriceOverlay => ({
+    provider, modelId: "gpt-5.6-sol", cost4: GPT56_SOL,
+    source: provider === "openai" ? `API-reference comparison estimate: ${OPENAI_GPT56_PRICING}` : OPENAI_GPT56_PRICING,
+    verifiedAt: "2026-09-05", status: provider === "openai" ? "verified-derived" : "verified",
+  })),
   {
     provider: "xai",
     modelId: "grok-4.6",
@@ -278,6 +290,7 @@ export function findExpectedPriceOverlay(
 
 /** OpenAI Fast price multipliers retained as a compatibility export. */
 export const PRIORITY_MULTIPLIERS: Readonly<Record<string, number>> = {
+  "gpt-6-astra": 2,
   "gpt-5.6-sol": 2,
   "gpt-daybreak-blue-latest": 2,
   "daybreak-blue-latest": 2,
@@ -306,7 +319,6 @@ export interface PriorityPricingRule {
   verifiedAt: string;
 }
 
-const OPENAI_FAST_PRICING = "https://openai.com/api-fast-mode/";
 const XAI_PRIORITY_PRICING = "https://docs.x.ai/developers/advanced-api-usage/priority-processing";
 
 /**
@@ -325,10 +337,15 @@ export const PRIORITY_PRICING_RULES: readonly PriorityPricingRule[] = [
         provider,
         modelId,
         multiplier,
-        source: OPENAI_FAST_PRICING,
-        verifiedAt: "2026-08-05",
+        source: modelId === "gpt-6-astra" ? ASTRA_API_PRICING : "https://openai.com/api-fast-mode/",
+        verifiedAt: modelId === "gpt-6-astra" ? "2026-09-05" : "2026-08-05",
       })),
   ),
+  ...["gpt-5.6-sol-pro", "gpt-5.6-terra-pro", "gpt-5.6-luna-pro"].map((modelId): PriorityPricingRule => ({
+    provider: "openai-apikey", modelId, multiplier: 2,
+    source: "https://developers.openai.com/api/docs/pricing (derived from the virtual selection's base wire model)",
+    verifiedAt: "2026-09-05",
+  })),
   ...["grok-4.5", "grok-4.6"].map((modelId): PriorityPricingRule => ({
     provider: "xai",
     modelId,
@@ -374,7 +391,7 @@ export interface ContextTier {
   /** Per-field factor from the short rate to the published long rate. */
   multiplier: Cost4;
   /** Published relationship between confirmed priority and long-context bands. */
-  confirmedPriorityRelation?: "exclusive" | "lower-bound";
+  confirmedPriorityRelation?: "exclusive" | "lower-bound" | "stack";
   source: string;
   verifiedAt: string;
 }
@@ -389,7 +406,8 @@ const OPENAI_LONG_CONTEXT: Cost4 = { input: 2, output: 1.5, cacheRead: 2, cacheW
 const UNIFORM_DOUBLE: Cost4 = { input: 2, output: 2, cacheRead: 2, cacheWrite: 2 };
 
 const OPENAI_PRICING_DOC = "https://developers.openai.com/api/docs/pricing";
-const OPENAI_GPT56_CONTEXT_MODELS = [
+const OPENAI_CONTEXT_MODELS = [
+  "gpt-6-astra",
   "gpt-5.6-sol",
   "gpt-5.6-terra",
   "gpt-5.6-luna",
@@ -401,16 +419,17 @@ const OPENAI_GPT56_CONTEXT_MODELS = [
 ];
 
 export const CONTEXT_TIERS: readonly ContextTier[] = [
+  // API-reference estimates do not apply subscription-only exemptions or multipliers.
   ...["openai", "openai-apikey"].flatMap(provider =>
-    OPENAI_GPT56_CONTEXT_MODELS.map((modelId): ContextTier => ({
+    OPENAI_CONTEXT_MODELS.map((modelId): ContextTier => ({
       provider,
       modelId,
       thresholdInputTokens: 272_000,
       inclusive: false,
       multiplier: OPENAI_LONG_CONTEXT,
-      confirmedPriorityRelation: "exclusive",
+      confirmedPriorityRelation: "stack",
       source: OPENAI_PRICING_DOC,
-      verifiedAt: "2026-08-03",
+      verifiedAt: "2026-09-05",
     })),
   ),
   {
@@ -420,9 +439,9 @@ export const CONTEXT_TIERS: readonly ContextTier[] = [
     thresholdInputTokens: 272_000,
     inclusive: false,
     multiplier: OPENAI_LONG_CONTEXT,
-    confirmedPriorityRelation: "exclusive",
+    confirmedPriorityRelation: "stack",
     source: OPENAI_PRICING_DOC,
-    verifiedAt: "2026-08-11",
+    verifiedAt: "2026-09-05",
   },
   {
     // The bare selector is the separately billed API-key alias. Daybreak Red has no tier row:
@@ -432,9 +451,9 @@ export const CONTEXT_TIERS: readonly ContextTier[] = [
     thresholdInputTokens: 272_000,
     inclusive: false,
     multiplier: OPENAI_LONG_CONTEXT,
-    confirmedPriorityRelation: "exclusive",
+    confirmedPriorityRelation: "stack",
     source: OPENAI_PRICING_DOC,
-    verifiedAt: "2026-08-11",
+    verifiedAt: "2026-09-05",
   },
   {
     provider: "xai",

package/src/usage/log.ts

@@ -46,6 +46,7 @@ export type AttemptRecoveryKind =
   | "transient-5xx"
   | "connection-reset"
   | "oauth-401"
+  | "key-401"
   | "key-429"
   | "rate-limit-429"
   | "anthropic-oauth-429"
@@ -257,6 +258,7 @@ const ATTEMPT_RECOVERY_KINDS = new Set<AttemptRecoveryKind>([
   "transient-5xx",
   "connection-reset",
   "oauth-401",
+  "key-401",
   "key-429",
   "rate-limit-429",
   "anthropic-oauth-429",

package/src/usage/model-identity.ts

@@ -0,0 +1,26 @@
+import { baseProviderLabel } from "../providers/label";
+import type { PriceResolutionOptions } from "./cost";
+import type { PersistedUsageEntry } from "./log";
+
+type TraceSource = Pick<PersistedUsageEntry, "routeDecision">;
+type ModelTarget = Pick<PersistedUsageEntry, "provider" | "model">;
+
+/** Saved routing provenance, not a claim about the model a remote endpoint ran. */
+export function isUnresolvedRequestedModel(source: TraceSource, target: ModelTarget): boolean {
+  const trace = source.routeDecision;
+  return trace !== undefined
+    && trace.routeKind === "default-provider"
+    && trace.selected.reason === "default-provider"
+    && trace.truncated?.strings !== true
+    && trace.selected.model.length > 0
+    && trace.requestedModel === trace.selected.model
+    && target.model === trace.selected.model
+    && baseProviderLabel(target.provider) === baseProviderLabel(trace.selected.provider);
+}
+
+/** Bare fallback rates remain eligible; unresolved slash IDs need a provider-specific rate. */
+export function usageModelPriceOptions(source: TraceSource, target: ModelTarget): PriceResolutionOptions {
+  return {
+    allowModelLevelFallback: !target.model.includes("/") || !isUnresolvedRequestedModel(source, target),
+  };
+}

package/src/usage/summary.ts

@@ -1,6 +1,7 @@
 import { baseProviderLabel } from "../providers/label";
 import { canonicalAntigravityUsageModel } from "../providers/antigravity-models";
 import { usageDisplayTotalTokens } from "./totals";
+import { isUnresolvedRequestedModel, usageModelPriceOptions } from "./model-identity";
 import { isCodexUsageAccountLogLabel, type PersistedUsageEntry, type UsageStatus } from "./log";
 import { type AttemptCostEstimate, type CostEstimate, estimateAttemptCost, estimateRequestCost, serviceTierContext, type ServiceTierContext } from "./cost";
 
@@ -59,6 +60,8 @@ export interface UsageDay {
 export interface UsageDayModel {
   model: string;
   provider: string;
+  /** Includes trace-proven unresolved requested selectors; absence is not confirmation. */
+  hasUnresolvedRequestedModel?: true;
   requests: number;
   attemptCount: number;
   totalTokens: number;
@@ -73,6 +76,8 @@ export interface UsageDayModel {
 export interface UsageModel {
   provider: string;
   model: string;
+  /** Includes trace-proven unresolved requested selectors; absence is not confirmation. */
+  hasUnresolvedRequestedModel?: true;
   resolvedModel?: string;
   requests: number;
   attemptCount: number;
@@ -208,7 +213,7 @@ export function computeEntryCost(entry: PersistedUsageEntry): EntryCostInfo {
   const tier = serviceTierContext(entry);
   if (entry.attempts?.length) {
     const attemptEstimates = entry.attempts.map(attempt =>
-      estimateAttemptCost(attempt, undefined, tier)
+      estimateAttemptCost({ ...attempt, ...usageModelPriceOptions(entry, attempt) }, undefined, tier)
     );
     let costTotal = 0;
     let isPriced = false;
@@ -221,6 +226,7 @@ export function computeEntryCost(entry: PersistedUsageEntry): EntryCostInfo {
     return { tier, estimate: null, attemptEstimates, costTotal, isPriced };
   }
   const estimate = estimateRequestCost({
+    ...usageModelPriceOptions(entry, entry),
     provider: entry.provider,
     model: entry.model,
     usage: entry.usage,
@@ -324,6 +330,7 @@ interface UsageAttribution {
   provider: string;
   model: string;
   resolvedModel?: string;
+  hasUnresolvedRequestedModel?: true;
   accountLogLabel?: string;
   usageStatus: UsageStatus;
   usage?: PersistedUsageEntry["usage"];
@@ -366,6 +373,7 @@ function usageAttributions(entry: PersistedUsageEntry): UsageAttribution[] {
       requestId: entry.requestId,
       provider: entry.provider,
       ...usageModelIdentity(entry.provider, entry.model, entry.resolvedModel),
+      ...(isUnresolvedRequestedModel(entry, entry) ? { hasUnresolvedRequestedModel: true as const } : {}),
       ...(entry.accountLogLabel ? { accountLogLabel: entry.accountLogLabel } : {}),
       usageStatus: entry.usageStatus,
       ...(entry.usage ? { usage: entry.usage } : {}),
@@ -376,6 +384,7 @@ function usageAttributions(entry: PersistedUsageEntry): UsageAttribution[] {
     requestId: entry.requestId,
     provider: attempt.provider,
     ...usageModelIdentity(attempt.provider, attempt.model),
+    ...(isUnresolvedRequestedModel(entry, attempt) ? { hasUnresolvedRequestedModel: true as const } : {}),
     ...(attempt.accountLogLabel ? { accountLogLabel: attempt.accountLogLabel } : {}),
     usageStatus: attempt.usageStatus,
     ...(attempt.usage ? { usage: attempt.usage } : {}),
@@ -517,6 +526,7 @@ interface UsageModelAccumulator {
   provider: string;
   model: string;
   resolvedModel?: string;
+  hasUnresolvedRequestedModel?: true;
   firstSeen: number;
   attemptCount: number;
   dayTotalTokens: number;
@@ -704,6 +714,7 @@ function cloneModelAccumulator(source: UsageModelAccumulator): UsageModelAccumul
 }
 
 function mergeModelAccumulator(target: UsageModelAccumulator, source: UsageModelAccumulator): void {
+  if (source.hasUnresolvedRequestedModel) target.hasUnresolvedRequestedModel = true;
   if (source.firstSeen < target.firstSeen) {
     target.firstSeen = source.firstSeen;
     target.resolvedModel = source.resolvedModel;
@@ -874,6 +885,7 @@ function buildDayModels(
   return retainedModelAccumulators(sorted, overlaps).map(model => ({
     model: model.model,
     provider: model.provider,
+    ...(model.hasUnresolvedRequestedModel ? { hasUnresolvedRequestedModel: true as const } : {}),
     requests: requestCountsFor(model).requests,
     attemptCount: model.attemptCount,
     totalTokens: model.dayTotalTokens,
@@ -900,6 +912,7 @@ function buildUsageModels(
     return {
       provider: model.provider,
       model: model.model,
+      ...(model.hasUnresolvedRequestedModel ? { hasUnresolvedRequestedModel: true as const } : {}),
       ...(model.resolvedModel ? { resolvedModel: model.resolvedModel } : {}),
       requests,
       attemptCount: model.attemptCount,
@@ -1115,6 +1128,7 @@ class StreamingUsageSummaryAccumulator implements UsageSummaryAccumulator {
     attribution: UsageAttribution,
     estimate: AttemptCostEstimate | CostEstimate | null,
   ): void {
+    if (attribution.hasUnresolvedRequestedModel) breakdown.hasUnresolvedRequestedModel = true;
     breakdown.attemptCount += 1;
     if (attribution.usage) {
       breakdown.inputTokens += attribution.usage.inputTokens;