@bitkyc08/opencodex 2.7.35 → 2.7.36

package/src/codex/inject.ts

@@ -1,13 +1,24 @@
 import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { atomicWriteFile, loadConfig, websocketsEnabled } from "../config";
-import { markJournalInjectedState, restoreJournalState, writeJournal } from "./journal";
+import { markJournalInjectedState, removeJournal, restoreJournalState, writeJournal } from "./journal";
 import { restoreCodexCatalog } from "./catalog";
 import { migrateHistoryToOpenai, syncCodexHistoryProvider } from "./history-provider";
 import { CODEX_CONFIG_PATH, CODEX_PROFILE_PATH, DEFAULT_CATALOG_PATH, parseTomlString, readRootTomlString, resolveCodexConfigPath, tomlString } from "./paths";
+import { resolveEffectiveProjectModelProvider } from "./project-config-warnings";
 import type { OcxConfig } from "../types";
 
 const OCX_SECTION_MARKER = "# Auto-injected by opencodex";
 
+export function externalCodexModelProvider(content: string): string | null {
+  const provider = resolveEffectiveProjectModelProvider(content).provider;
+  return provider && provider !== "openai" && provider !== "opencodex" ? provider : null;
+}
+
+export function currentExternalCodexModelProvider(): string | null {
+  if (!existsSync(CODEX_CONFIG_PATH)) return null;
+  return externalCodexModelProvider(readFileSync(CODEX_CONFIG_PATH, "utf8"));
+}
+
 /**
  * Detect the file's dominant line ending. Every transform in this module is LF-pure
  * (split("\n") + hard "\n" joins), so CRLF configs (Windows-edited config.toml) are
@@ -151,7 +162,7 @@ export function stripInjectedOpenaiBaseUrl(content: string): string {
   return lines.filter((_, i) => !drop.has(i)).join("\n");
 }
 
-function hasInjectedOpenaiBaseUrl(content: string): boolean {
+export function hasInjectedOpenaiBaseUrl(content: string): boolean {
   const lines = content.split("\n");
   const firstTable = lines.findIndex(l => /^\s*\[/.test(l));
   const rootEnd = firstTable === -1 ? lines.length : firstTable;
@@ -161,6 +172,137 @@ function hasInjectedOpenaiBaseUrl(content: string): boolean {
   return false;
 }
 
+export type CodexRoutingKind = "native" | "opencodex-local" | "custom-local" | "custom-remote" | "unknown";
+
+function tomlStringPattern(key: string): RegExp {
+  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const keyToken = `(?:${escaped}|\"${escaped}\"|'${escaped}')`;
+  return new RegExp(`^\\s*${keyToken}\\s*=\\s*[\"']([^\"']+)[\"']\\s*(?:#.*)?$`);
+}
+
+function rootTomlString(content: string, key: string): string | null {
+  const lines = content.split("\n");
+  const firstTable = lines.findIndex(line => /^\s*\[/.test(line));
+  const rootLines = lines.slice(0, firstTable === -1 ? lines.length : firstTable);
+  const pattern = tomlStringPattern(key);
+  for (const line of rootLines) {
+    const match = pattern.exec(line);
+    if (match?.[1]) return match[1].trim();
+  }
+  return null;
+}
+
+function providerTableStart(lines: string[], provider: string): number {
+  const escapedProvider = provider.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const providerToken = `(?:${escapedProvider}|\"${escapedProvider}\"|'${escapedProvider}')`;
+  const header = new RegExp(`^\\s*\\[\\s*(?:model_providers|\"model_providers\"|'model_providers')\\s*\\.\\s*${providerToken}\\s*\\]\\s*(?:#.*)?$`);
+  return lines.findIndex(line => header.test(line));
+}
+
+function providerTableString(content: string, provider: string, key: string): string | null {
+  const lines = content.split("\n");
+  const start = providerTableStart(lines, provider);
+  if (start === -1) return null;
+  const pattern = tomlStringPattern(key);
+  for (let index = start + 1; index < lines.length && !/^\s*\[/.test(lines[index]); index += 1) {
+    const match = pattern.exec(lines[index]);
+    if (match?.[1]) return match[1].trim();
+  }
+  return null;
+}
+
+type RoutingEndpointKind = "local" | "remote" | "unknown";
+
+function ipv4Octets(hostname: string): number[] | null {
+  const dotted = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(hostname);
+  if (dotted) {
+    const octets = dotted.slice(1).map(Number);
+    return octets.some(octet => octet > 255) ? null : octets;
+  }
+  const mapped = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i.exec(hostname);
+  if (!mapped) return null;
+  const high = Number.parseInt(mapped[1], 16);
+  const low = Number.parseInt(mapped[2], 16);
+  return [high >>> 8, high & 0xff, low >>> 8, low & 0xff];
+}
+
+function classifyRoutingEndpoint(value: string): RoutingEndpointKind {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return "unknown";
+    const hostname = url.hostname.toLowerCase().replace(/^\[|\]$/g, "").replace(/\.$/, "");
+    if (!hostname) return "unknown";
+    if (hostname === "localhost" || hostname.endsWith(".localhost")) return "local";
+    if (hostname === "::" || hostname === "::1" || hostname === "0.0.0.0") return "local";
+    const octets = ipv4Octets(hostname);
+    if (octets) {
+      if (octets.every(octet => octet === 0)) return "local";
+      if (octets[0] === 127) return "local";
+      return "remote";
+    }
+    if (/^::ffff:/i.test(hostname)) return "unknown";
+    return "remote";
+  } catch {
+    return "unknown";
+  }
+}
+
+/** Classify actual routing dependency separately from opencodex ownership. */
+export function classifyCodexRouting(content: string): CodexRoutingKind {
+  const rootBaseUrl = rootTomlString(content, "openai_base_url");
+  if (rootBaseUrl) {
+    const endpoint = classifyRoutingEndpoint(rootBaseUrl);
+    if (endpoint === "unknown") return "unknown";
+    if (hasInjectedOpenaiBaseUrl(content)) return "opencodex-local";
+    return endpoint === "local" ? "custom-local" : "custom-remote";
+  }
+  const rootProvider = rootTomlString(content, "model_provider");
+  if (rootProvider) {
+    const providerTableExists = providerTableStart(content.split("\n"), rootProvider) !== -1;
+    const providerBaseUrl = providerTableString(content, rootProvider, "base_url");
+    if (providerBaseUrl) {
+      const endpoint = classifyRoutingEndpoint(providerBaseUrl);
+      if (endpoint === "unknown") return "unknown";
+      if (rootProvider === "opencodex") return "opencodex-local";
+      return endpoint === "local" ? "custom-local" : "custom-remote";
+    }
+    if (rootProvider === "opencodex" || providerTableExists || rootProvider !== "openai") return "unknown";
+  }
+  return "native";
+}
+
+/**
+ * True when the active Codex config is owned by opencodex routing. Covers the
+ * loopback Design B root override and the legacy/non-loopback provider table.
+ * A user-owned `openai_base_url` is intentionally not classified as injected.
+ */
+export function hasInjectedCodexRouting(content: string): boolean {
+  if (hasInjectedOpenaiBaseUrl(content)) return true;
+  return rootTomlString(content, "model_provider") === "opencodex"
+    && providerTableString(content, "opencodex", "base_url") !== null;
+}
+
+/** Read-only probe used by status, doctor, and the dashboard. */
+export function isCodexRoutingInjected(): boolean {
+  const path = CODEX_CONFIG_PATH;
+  if (!existsSync(path)) return false;
+  try {
+    return hasInjectedCodexRouting(readFileSync(path, "utf8"));
+  } catch {
+    return false;
+  }
+}
+
+export function getCodexRoutingKind(): CodexRoutingKind {
+  const path = CODEX_CONFIG_PATH;
+  if (!existsSync(path)) return "native";
+  try {
+    return classifyCodexRouting(readFileSync(path, "utf8"));
+  } catch {
+    return "unknown";
+  }
+}
+
 /**
  * Strip every existing `model_provider` line that we must not duplicate: any line set to
  * "opencodex" (wherever it sits — including a previously mis-nested one under a table), plus any
@@ -365,8 +507,23 @@ export async function injectCodexConfig(port: number, config?: OcxConfig, option
     return { success: false, message: `Codex config not found at ${CODEX_CONFIG_PATH}. Is Codex installed?` };
   }
 
-  writeJournal();
   const rawContent = readFileSync(CODEX_CONFIG_PATH, "utf-8");
+  const activeProvider = externalCodexModelProvider(rawContent);
+  if (activeProvider) {
+    // A launcher may have journaled before the provider manager took ownership. Never let shutdown
+    // replay that stale snapshot over externally managed config.
+    removeJournal();
+    return {
+      success: true,
+      message: `⚠️ Codex routing NOT injected: config.toml selects the external model_provider ${tomlString(activeProvider)}.\n` +
+        `  OpenCodex preserves external provider configuration so existing ${tomlString(activeProvider)} session history stays visible.\n` +
+        `  Configure that provider for Responses passthrough at http://${providerBaseHost(config?.hostname)}:${port}/v1` +
+        `${shouldInjectApiAuthHeader(config) ? ` with x-opencodex-api-key from OPENCODEX_API_AUTH_TOKEN` : ""}.\n` +
+        `  For direct injection, switch to the built-in openai provider, remove any user-owned root openai_base_url, and rerun 'ocx start'.`,
+    };
+  }
+
+  writeJournal();
   // EOL boundary: transforms below are LF-pure; preserve the file's dominant ending on write.
   const eol = dominantEol(rawContent);
   let content = applyEol(rawContent, "\n");
@@ -543,6 +700,11 @@ export function removeCodexConfig(options: { preserveProfile?: boolean } = {}):
  * handler, and `ocx restore`. Idempotent + atomic.
  */
 export function restoreNativeCodex(): { success: boolean; message: string } {
+  const activeProvider = currentExternalCodexModelProvider();
+  if (activeProvider) {
+    removeJournal();
+    return { success: true, message: `External Codex provider ${tomlString(activeProvider)} preserved; no native restore was needed.` };
+  }
   const journal = restoreJournalState();
   const cfg = journal.configRestored
     ? { success: true, message: "Codex config restored from opencodex journal." }

package/src/codex/shim.ts

@@ -34,6 +34,23 @@ const CODEX_INTERNAL_COMMANDS = [
   "update",
 ];
 
+// Codex accepts global options before a subcommand. The shim must skip the value belonging to
+// these options before it decides which first positional token is the real subcommand. Keep this
+// list aligned with `codex --help`; `--option=value` and attached short forms stay one token.
+const CODEX_GLOBAL_OPTIONS_WITH_VALUE = [
+  "-c", "--config",
+  "--enable", "--disable",
+  "--remote", "--remote-auth-token-env",
+  "-i", "--image",
+  "-m", "--model",
+  "--local-provider",
+  "-p", "--profile",
+  "-s", "--sandbox",
+  "-C", "--cd",
+  "--add-dir",
+  "-a", "--ask-for-approval",
+];
+
 interface ShimState {
   platform: NodeJS.Platform;
   wrapperPath: string;
@@ -71,6 +88,17 @@ function isShim(path: string): boolean {
   }
 }
 
+function isHealthyShim(path: string, platform: NodeJS.Platform): boolean {
+  try {
+    const content = readFileSync(path, "utf8");
+    if (content.length < 180 || !content.includes(SHIM_MARKER) || !content.includes("ensure")) return false;
+    if (platform !== "win32" && (lstatSync(path).mode & 0o111) === 0) return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * A PATH entry that reaches Windows through WSL drive interop
  * (`<automount-root>/<drive>/...`; root defaults to /mnt, configurable via
@@ -190,13 +218,40 @@ function shQuote(value: string): string {
 
 export function buildUnixCodexShim(realCodexPath: string, bunPath: string, cliPath: string, tokenFile = serviceApiTokenFilePath()): string {
   const internalCommands = CODEX_INTERNAL_COMMANDS.join("|");
+  const valueOptions = CODEX_GLOBAL_OPTIONS_WITH_VALUE.join("|");
   return `#!/usr/bin/env sh
 # ${SHIM_MARKER}
 if [ -z "$OPENCODEX_API_AUTH_TOKEN" ] && [ -f ${shQuote(tokenFile)} ]; then
   OPENCODEX_API_AUTH_TOKEN="$(cat ${shQuote(tokenFile)})"
   export OPENCODEX_API_AUTH_TOKEN
 fi
-case "$1" in
+ocx_subcommand=""
+ocx_skip_next=0
+for ocx_arg in "$@"; do
+  if [ "$ocx_skip_next" -eq 1 ]; then
+    ocx_skip_next=0
+    continue
+  fi
+  case "$ocx_arg" in
+    --)
+      break
+      ;;
+    ${valueOptions})
+      ocx_skip_next=1
+      ;;
+    --help|-h|--version|-V)
+      ocx_subcommand="$ocx_arg"
+      break
+      ;;
+    -*)
+      ;;
+    *)
+      ocx_subcommand="$ocx_arg"
+      break
+      ;;
+  esac
+done
+case "$ocx_subcommand" in
   ${internalCommands}|--help|-h|--version|-V)
     ;;
   *)
@@ -228,6 +283,7 @@ function windowsBatchSet(name: string, value: string): string {
 
 export function buildWindowsCodexShim(realCodexPath: string, bunPath: string, cliPath: string): string {
   const internalCommandChecks = CODEX_INTERNAL_COMMANDS.map(command => `if /I "%~1"=="${command}" goto run_codex`).join("\r\n");
+  const valueOptionChecks = CODEX_GLOBAL_OPTIONS_WITH_VALUE.map(option => `if /I "%~1"=="${option}" goto skip_option_value`).join("\r\n");
   return `@echo off\r
 rem ${SHIM_MARKER}\r
 ${windowsBatchSet("OCX_REAL_CODEX", realCodexPath)}\r
@@ -236,11 +292,26 @@ ${windowsBatchSet("OCX_CLI", cliPath)}\r
 ${windowsBatchSet("OCX_API_TOKEN_FILE", serviceApiTokenFilePath())}\r
 if "%OPENCODEX_API_AUTH_TOKEN%"=="" if exist "%OCX_API_TOKEN_FILE%" set /p OPENCODEX_API_AUTH_TOKEN=<"%OCX_API_TOKEN_FILE%"\r
 if not "%OCX_SHIM_BYPASS%"=="" goto run_codex\r
+goto scan_codex_args\r
+:scan_codex_args\r
+if "%~1"=="" goto ensure_ocx\r
+if "%~1"=="--" goto ensure_ocx\r
+${valueOptionChecks}\r
 ${internalCommandChecks}\r
 if /I "%~1"=="--help" goto run_codex\r
 if /I "%~1"=="-h" goto run_codex\r
 if /I "%~1"=="--version" goto run_codex\r
 if /I "%~1"=="-V" goto run_codex\r
+set "OCX_SCAN_ARG=%~1"\r
+if "%OCX_SCAN_ARG:~0,1%"=="-" goto shift_codex_arg\r
+goto ensure_ocx\r
+:skip_option_value\r
+shift\r
+if "%~1"=="" goto ensure_ocx\r
+:shift_codex_arg\r
+shift\r
+goto scan_codex_args\r
+:ensure_ocx\r
 "%OCX_BUN%" "%OCX_CLI%" ensure >nul 2>nul\r
 :run_codex\r
 "%OCX_REAL_CODEX%" %*\r
@@ -253,6 +324,7 @@ function psString(value: string): string {
 
 export function buildWindowsPowerShellCodexShim(realCodexPath: string, bunPath: string, cliPath: string): string {
   const internalCommands = CODEX_INTERNAL_COMMANDS.map(command => psString(command)).join(", ");
+  const valueOptions = CODEX_GLOBAL_OPTIONS_WITH_VALUE.map(option => psString(option)).join(", ");
   const tokenFile = serviceApiTokenFilePath();
   return `#!/usr/bin/env pwsh
 # ${SHIM_MARKER}
@@ -260,8 +332,20 @@ if (-not $env:OPENCODEX_API_AUTH_TOKEN -and (Test-Path -LiteralPath ${psString(t
   $env:OPENCODEX_API_AUTH_TOKEN = (Get-Content -Raw -LiteralPath ${psString(tokenFile)}).Trim()
 }
 $internalCommands = @(${internalCommands})
-$firstArg = if ($args.Count -gt 0) { [string]$args[0] } else { "" }
-$skipEnsure = $env:OCX_SHIM_BYPASS -or $internalCommands -contains $firstArg -or @("--help", "-h", "--version", "-V") -contains $firstArg
+$valueOptions = @(${valueOptions})
+$subcommand = ""
+$skipNext = $false
+foreach ($argValue in $args) {
+  $argText = [string]$argValue
+  if ($skipNext) { $skipNext = $false; continue }
+  if ($argText -eq "--") { break }
+  if ($valueOptions -contains $argText) { $skipNext = $true; continue }
+  if (@("--help", "-h", "--version", "-V") -contains $argText) { $subcommand = $argText; break }
+  if ($argText.StartsWith("-")) { continue }
+  $subcommand = $argText
+  break
+}
+$skipEnsure = $env:OCX_SHIM_BYPASS -or $internalCommands -contains $subcommand -or @("--help", "-h", "--version", "-V") -contains $subcommand
 if (-not $skipEnsure) {
   & ${psString(bunPath)} ${psString(cliPath)} ensure *> $null
 }
@@ -272,7 +356,25 @@ exit $LASTEXITCODE
 
 function readState(): ShimState | null {
   try {
-    return JSON.parse(readFileSync(statePath(), "utf8")) as ShimState;
+    const value = JSON.parse(readFileSync(statePath(), "utf8")) as unknown;
+    if (!value || typeof value !== "object") return null;
+    const state = value as Record<string, unknown>;
+    if (typeof state.platform !== "string") return null;
+    const validFile = (item: unknown): item is ShimFileState => {
+      if (!item || typeof item !== "object") return false;
+      const file = item as Record<string, unknown>;
+      return typeof file.wrapperPath === "string"
+        && typeof file.originalPath === "string"
+        && typeof file.backupPath === "string"
+        && (file.realPath === undefined || typeof file.realPath === "string")
+        && (file.preserveOnly === undefined || typeof file.preserveOnly === "boolean");
+    };
+    if (state.wrappers !== undefined) {
+      if (!Array.isArray(state.wrappers) || state.wrappers.length === 0 || !state.wrappers.every(validFile)) return null;
+    } else if (!validFile(state)) {
+      return null;
+    }
+    return state as unknown as ShimState;
   } catch {
     return null;
   }
@@ -431,13 +533,39 @@ export function uninstallCodexShim(): { removed: boolean; message: string } {
 
 /** True if a Codex autostart shim is currently installed (state file present). */
 export function isCodexShimInstalled(): boolean {
-  return readState() !== null;
+  return diagnoseCodexShim().installed;
 }
 
-export function codexShimStatus(): string {
+export interface CodexShimDiagnostic {
+  installed: boolean;
+  healthy: boolean;
+  summary: string;
+}
+
+/** Structured, secret-free shim state for CLI/GUI lifecycle diagnostics. */
+export function diagnoseCodexShim(): CodexShimDiagnostic {
   const state = readState();
-  if (!state) return "Codex autostart shim is not installed.";
-  return stateFiles(state).map(file => {
+  if (!state) {
+    if (existsSync(statePath())) {
+      return {
+        installed: true,
+        healthy: false,
+        summary: `Codex autostart shim state is invalid or corrupt at ${statePath()}. Reinstall or remove the shim.`,
+      };
+    }
+    return {
+      installed: false,
+      healthy: false,
+      summary: "Codex autostart shim is not installed.",
+    };
+  }
+  const files = stateFiles(state);
+  const healthy = files.length > 0 && files.every(file => file.preserveOnly
+    ? existsSync(file.backupPath) && !existsSync(file.originalPath)
+    : existsSync(file.wrapperPath)
+      && (existsSync(file.backupPath) || (file.realPath ? existsSync(file.realPath) : false))
+      && isHealthyShim(file.wrapperPath, state.platform));
+  const summary = files.map(file => {
     const wrapper = existsSync(file.wrapperPath)
       ? isShim(file.wrapperPath)
         ? "shim present"
@@ -446,4 +574,9 @@ export function codexShimStatus(): string {
     const backup = existsSync(file.backupPath) ? "present" : "missing";
     return `Codex autostart shim: wrapper ${wrapper} at ${file.wrapperPath}; original backup ${backup} at ${file.backupPath}.`;
   }).join("\n");
+  return { installed: true, healthy, summary };
+}
+
+export function codexShimStatus(): string {
+  return diagnoseCodexShim().summary;
 }

package/src/codex/sync.ts

@@ -1,4 +1,4 @@
-import { injectCodexConfig } from "./inject";
+import { currentExternalCodexModelProvider, injectCodexConfig } from "./inject";
 import { printProjectCodexConfigWarnings, groupProjectCodexConfigWarningsByPath, type ProjectCodexConfigWarning } from "./project-config-warnings";
 import { refreshCodexModelCatalog } from "./refresh";
 import { applyProxyEnv, loadConfig } from "../config";
@@ -19,6 +19,7 @@ export interface CodexSyncResult {
 interface CodexSyncDeps {
   refreshCodexModelCatalog: typeof refreshCodexModelCatalog;
   injectCodexConfig: typeof injectCodexConfig;
+  currentExternalCodexModelProvider?: typeof currentExternalCodexModelProvider;
 }
 
 const defaultDeps: CodexSyncDeps = {
@@ -32,8 +33,22 @@ export async function syncModelsToCodex(
   log: Pick<Console, "log" | "error"> | null = console,
   deps: CodexSyncDeps = defaultDeps,
 ): Promise<CodexSyncResult> {
-  applyProxyEnv(config); // `ocx ensure`/`ocx sync` fetch provider models outside the server process
   const p = port ?? config.port ?? 10100;
+  const externalProvider = (deps.currentExternalCodexModelProvider ?? currentExternalCodexModelProvider)();
+  if (externalProvider) {
+    const result = await deps.injectCodexConfig(p, config, {});
+    log?.log(result.message);
+    return {
+      ok: result.success,
+      added: 0,
+      catalogPath: null,
+      catalogExists: false,
+      cacheSynced: false,
+      message: result.message,
+    };
+  }
+
+  applyProxyEnv(config); // `ocx ensure`/`ocx sync` fetch provider models outside the server process
   let added = 0;
   let catalogPath: string | null = null;
   let catalogPathForInjection: string | null | undefined;

package/src/config.ts

@@ -422,6 +422,18 @@ export function positiveIntegerConfigError(value: unknown, field: string): strin
   return null;
 }
 
+export function booleanRecordConfigError(value: unknown, field: string): string | null {
+  if (value === undefined) return null;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return `${field} must be a plain object`;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return `${field} must be a plain object with own properties`;
+  for (const [key, entry] of Object.entries(value)) {
+    if (!key.trim()) return `${field} keys must be nonblank model ids`;
+    if (typeof entry !== "boolean") return `${field}.${key} must be a boolean`;
+  }
+  return null;
+}
+
 const configSchema = z.object({
   port: z.number().int().min(0).max(65535).default(10100),
   providers: z.record(z.string(), providerConfigSchema),
@@ -505,6 +517,17 @@ const configSchema = z.object({
         message: maxInputError,
       });
     }
+    const reasoningSummariesError = booleanRecordConfigError(
+      (provider as { modelSupportsReasoningSummaries?: unknown }).modelSupportsReasoningSummaries,
+      "modelSupportsReasoningSummaries",
+    );
+    if (reasoningSummariesError) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["providers", name, "modelSupportsReasoningSummaries"],
+        message: reasoningSummariesError,
+      });
+    }
     const defaultMaxOutputError = positiveIntegerConfigError(
       (provider as { defaultMaxOutputTokens?: unknown }).defaultMaxOutputTokens,
       "defaultMaxOutputTokens",

package/src/lib/errors.ts

@@ -99,9 +99,18 @@ export function classifyError(status: number, type: string, message: string): Oc
   ) {
     return { message, type: "invalid_request_error", code: "context_length_exceeded" };
   }
+  // "Cursor resource limit exceeded" is emitted only for explicit request-size overflow
+  // details (isCursorRequestTooLargeDetail in cursor-errors.ts); quota-style resource
+  // exhaustion arrives as "Cursor rate limit exceeded" and falls through to 429 below.
   if (text.includes("cursor resource limit exceeded")) {
     return { message, type: "invalid_request_error", code: "tool_catalog_too_large" };
   }
+  // The Cursor adapter's classified rate-limit prefix is authoritative: its DETAIL may echo
+  // quota wording ("... quota exhausted") that would otherwise hit the insufficient_quota
+  // branch below and break the planned retry-with-backoff contract (WP3 review blocker 1).
+  if (text.includes("cursor rate limit exceeded")) {
+    return { message, type: "rate_limit_error", code: "rate_limit_exceeded" };
+  }
   if (
     text.includes("insufficient_quota") ||
     text.includes("exceeded your current quota") ||
@@ -202,6 +211,8 @@ export function inferHttpStatusFromAdapterMessage(message: string): number {
   const lower = message.toLowerCase();
   // Client aborts (e.g. mid web-search loop) must not look like upstream 502s in /api/logs.
   if (isClientClosedMessage(lower)) return 499;
+  // See classifyError: this prefix now only means explicit request-size overflow (400);
+  // quota-style Cursor resource exhaustion carries the rate-limit prefix and maps to 429.
   if (lower.includes("cursor resource limit exceeded")) return 400;
   if (
     lower.includes("resource_exhausted") ||

package/src/providers/antigravity-models.ts

@@ -167,3 +167,36 @@ export function resolveAntigravityEffortWireModel(
   // Rule 5: everything else.
   return { wireModelId: resolveAntigravityWireModelId(modelId) };
 }
+
+
+// ── Usage aggregation reverse map (picker/call base identity) ──
+// Effort wire IDs and compatibility aliases must collapse to the same picker-visible
+// base model that users invoke after effort routing. Historical logs store suffix IDs;
+// summary aggregation consults this reverse map so one call model = one usage row.
+const ANTIGRAVITY_USAGE_BASE_BY_ID: Record<string, string> = (() => {
+  const rev: Record<string, string> = {};
+  for (const base of ANTIGRAVITY_MODELS) rev[base] = base;
+  for (const [base, effortMap] of Object.entries(ANTIGRAVITY_EFFORT_WIRE_MAP)) {
+    rev[base] = base;
+    for (const wire of Object.values(effortMap)) rev[wire] = base;
+  }
+  for (const [alias, wire] of Object.entries(ANTIGRAVITY_MODEL_ALIASES)) {
+    const base = rev[wire] ?? rev[alias];
+    if (base) rev[alias] = base;
+    // If alias is itself a base/wire already mapped, keep that mapping.
+    else if (rev[wire]) rev[alias] = rev[wire]!;
+  }
+  // Visible aliases that only appear in ANTIGRAVITY_VISIBLE_MODEL_ALIASES are already
+  // included via ANTIGRAVITY_MODEL_ALIASES. Identity bases without effort maps remain.
+  return rev;
+})();
+
+/**
+ * Canonical picker/call model id for usage aggregation.
+ * Unknown ids stay identity so future CCA models do not invent mappings.
+ */
+export function canonicalAntigravityUsageModel(modelId: string): string {
+  const id = modelId.trim();
+  if (!id) return modelId;
+  return ANTIGRAVITY_USAGE_BASE_BY_ID[id] ?? id;
+}

package/src/providers/kiro-models.ts

@@ -5,6 +5,7 @@ export const KIRO_MODELS = [
   "gpt-5.6-terra",
   "gpt-5.6-luna",
   "claude-sonnet-5",
+  "claude-opus-5",
   "claude-opus-4.8",
   "claude-opus-4.7",
   "claude-opus-4.6",
@@ -28,6 +29,7 @@ export const KIRO_MODEL_CONTEXT_WINDOWS: Record<string, number> = {
   "gpt-5.6-terra": 272_000,
   "gpt-5.6-luna": 272_000,
   "claude-sonnet-5": 1_000_000,
+  "claude-opus-5": 1_000_000,
   "claude-opus-4.8": 1_000_000,
   "claude-opus-4.7": 1_000_000,
   "claude-opus-4.6": 1_000_000,

package/src/providers/registry.ts

@@ -100,8 +100,8 @@ export type ProviderConfigSeed = Pick<
 // same static model seed.
 // 260710 context refresh: Tier-2 evidence in
 // devlog/_plan/260710_provider_hardening/001_research_frontier.md.
-const ANTHROPIC_MODELS = ["claude-fable-5", "claude-sonnet-5", "claude-opus-4-8", "claude-opus-4-7", "claude-opus-4-6", "claude-sonnet-4-6", "claude-haiku-4-5"];
-const ANTHROPIC_MODEL_CONTEXT_WINDOWS: Record<string, number> = { "claude-sonnet-5": 1_000_000, "claude-fable-5": 1_000_000, "claude-opus-4-8": 1_000_000, "claude-haiku-4-5": 200_000 };
+const ANTHROPIC_MODELS = ["claude-fable-5", "claude-sonnet-5", "claude-opus-5", "claude-opus-4-8", "claude-opus-4-7", "claude-opus-4-6", "claude-sonnet-4-6", "claude-haiku-4-5"];
+const ANTHROPIC_MODEL_CONTEXT_WINDOWS: Record<string, number> = { "claude-sonnet-5": 1_000_000, "claude-fable-5": 1_000_000, "claude-opus-5": 1_000_000, "claude-opus-4-8": 1_000_000, "claude-haiku-4-5": 200_000 };
 
 const ZAI_GLM_52_MODELS = ["glm-5.2", "glm-5.2[1m]"];
 const ZAI_GLM_52_REASONING_EFFORTS = ["low", "medium", "high", "xhigh", "max"];