@bitkyc08/opencodex 2.24.1 → 2.25.0-preview.20260818

package/src/lab/projection/rebuild.ts

@@ -122,6 +122,20 @@ export function rebuildLabProjection(configDir?: string): RebuildResult {
 
   const db = new Database(paths.sqlitePath);
   let transactionOpen = false;
+  // Every statement prepared below, so they can be finalized before the close.
+  //
+  // Bun keeps a prepared statement alive until it is finalized or garbage collected,
+  // and on Windows an unfinalized statement holds the database file open: `close()`
+  // leaves the handle, and `close(true)` throws "database is locked". A second
+  // rebuild then failed to unlink the previous projection with EBUSY, and the retry
+  // loop in `wipeSqlite` could only turn that into a slower failure. POSIX allows
+  // unlinking an open file, which is why this never surfaced there.
+  const prepared: Array<{ finalize(): void }> = [];
+  const prepare = (sql: string) => {
+    const statement = db.prepare(sql);
+    prepared.push(statement);
+    return statement;
+  };
   try {
     db.exec("PRAGMA journal_mode=DELETE;");
     db.exec("PRAGMA foreign_keys=OFF;");
@@ -129,50 +143,45 @@ export function rebuildLabProjection(configDir?: string): RebuildResult {
     transactionOpen = true;
     resetProjectionSchema(db);
 
-    db.prepare(
-      "INSERT OR REPLACE INTO schema_meta(key, value) VALUES (?, ?)",
-    ).run("schema_version", String(LAB_SQLITE_SCHEMA_VERSION));
-    db.prepare(
-      "INSERT OR REPLACE INTO schema_meta(key, value) VALUES (?, ?)",
-    ).run("projection_spec_version", LAB_PROJECTION_SPEC_VERSION);
-    db.prepare(
-      "INSERT OR REPLACE INTO schema_meta(key, value) VALUES (?, ?)",
-    ).run("built_at_ms", String(Date.now()));
+    const insertMeta = prepare("INSERT OR REPLACE INTO schema_meta(key, value) VALUES (?, ?)");
+    insertMeta.run("schema_version", String(LAB_SQLITE_SCHEMA_VERSION));
+    insertMeta.run("projection_spec_version", LAB_PROJECTION_SPEC_VERSION);
+    insertMeta.run("built_at_ms", String(Date.now()));
 
-    const insertCorruption = db.prepare(
+    const insertCorruption = prepare(
       "INSERT INTO corruption(kind, line_number, event_id, detail) VALUES (?, ?, ?, ?)",
     );
     for (const c of corruptions) {
       insertCorruption.run(c.kind, c.lineNumber ?? null, c.eventId ?? null, c.detail);
     }
 
-    const insertEvent = db.prepare(
+    const insertEvent = prepare(
       `INSERT INTO events(event_id, event_kind, recorded_at, producer, producer_version, payload_json, excluded, exclusion_reason)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
     );
-    const insertSubject = db.prepare(
+    const insertSubject = prepare(
       `INSERT OR IGNORE INTO subjects(subject_id, subject_kind, subject_json) VALUES (?, ?, ?)`,
     );
-    const insertObs = db.prepare(
+    const insertObs = prepare(
       `INSERT INTO observations(
          event_id, subject_id, evidence_layer, suite_id, suite_version, suite_manifest_digest,
          scenario_id, scenario_version, scenario_manifest_digest, outcome, completed_at, execution_mode
        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
     );
-    const insertClaim = db.prepare(
+    const insertClaim = prepare(
       `INSERT INTO claims(
          event_id, subject_id, capability, polarity, source_manifest_digest,
          effective_at, recorded_at, supersedes_json, current, usable
        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
     );
-    const insertInv = db.prepare(
+    const insertInv = prepare(
       `INSERT INTO invalidations(event_id, reason, targets_json, recorded_at, applied) VALUES (?, ?, ?, ?, ?)`,
     );
-    const insertPurge = db.prepare(
+    const insertPurge = prepare(
       `INSERT INTO purges(event_id, target_event_ids_json, target_artifact_digests_json, purge_actions_json, recorded_at)
        VALUES (?, ?, ?, ?, ?)`,
     );
-    const insertArtifact = db.prepare(
+    const insertArtifact = prepare(
       `INSERT INTO artifacts(digest, artifact_class, media_type, byte_count, status, last_error)
        VALUES (?, ?, ?, ?, ?, ?)
        ON CONFLICT(digest) DO UPDATE SET
@@ -319,7 +328,7 @@ export function rebuildLabProjection(configDir?: string): RebuildResult {
       }
     }
 
-    const insertVerdict = db.prepare(
+    const insertVerdict = prepare(
       `INSERT INTO verdicts(
          projection_key, subject_id, evidence_layer, suite_id, suite_version, suite_manifest_digest,
          projection_spec_version, verdict, as_of, scenario_manifest_digests_json, claim_source_digest,
@@ -369,6 +378,15 @@ export function rebuildLabProjection(configDir?: string): RebuildResult {
     } catch {
       // Closing the disposable DB is still safe if pragma restoration fails.
     }
+    // Finalize before closing: an outstanding statement keeps the file open on
+    // Windows, and the next rebuild cannot unlink the projection it is replacing.
+    for (const statement of prepared) {
+      try {
+        statement.finalize();
+      } catch {
+        // A statement already finalized by an error path is not a rebuild failure.
+      }
+    }
     db.close();
     artifactStore.close();
   }

package/src/lib/windows-elevation.ts

@@ -175,7 +175,7 @@ export function assertTrustedSystemExecutableForTests(candidate: string, label:
   return assertTrustedSystemExecutable(candidate, label);
 }
 
-type ElevationExeOverrides = { powershell?: string; schtasks?: string; taskkill?: string };
+type ElevationExeOverrides = { powershell?: string; schtasks?: string; taskkill?: string; icacls?: string };
 let elevationExeOverridesForTests: ElevationExeOverrides | null = null;
 
 /**
@@ -220,6 +220,15 @@ export function resolveTrustedWindowsTaskkillExe(): string {
   return assertTrustedSystemExecutable(candidate, "taskkill.exe");
 }
 
+/** Absolute path to System32\\icacls.exe from a trusted system directory. */
+export function resolveTrustedWindowsIcaclsExe(): string {
+  if (elevationExeOverridesForTests?.icacls) {
+    return elevationExeOverridesForTests.icacls;
+  }
+  const candidate = join(resolveTrustedWindowsSystemDirectory(), "icacls.exe");
+  return assertTrustedSystemExecutable(candidate, "icacls.exe");
+}
+
 /** Stable machine-readable marker for a denied `schtasks /create`. Crosses the CLI→proxy boundary. */
 export const WINDOWS_SCHTASKS_CREATE_ACCESS_DENIED_MARKER =
   "OCX_ERROR_CODE=WINDOWS_SCHTASKS_CREATE_ACCESS_DENIED";
@@ -631,15 +640,21 @@ export function runWindowsElevatedScheduledTaskRegistration(
   xml: string,
 ): Promise<number> {
   const xmlBase64 = Buffer.from(xml, "utf16le").toString("base64");
+  const powerShellPath = windowsPowerShell();
+  const powerShellDirectory = powerShellPath.replace(/[\\/][^\\/]+$/, "");
+  const scheduledTasksModule = `${powerShellDirectory}\\Modules\\ScheduledTasks\\ScheduledTasks.psd1`;
   const inner = [
     `$taskName = ${psSingleQuote(taskName)}`,
     `$xmlBase64 = ${psSingleQuote(xmlBase64)}`,
     "$xml = [Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($xmlBase64))",
-    "Register-ScheduledTask -TaskName $taskName -Xml $xml -Force -ErrorAction Stop | Out-Null",
+    `$module = Microsoft.PowerShell.Core\\Import-Module -Name ${psSingleQuote(scheduledTasksModule)} -PassThru -Force -ErrorAction Stop`,
+    "$registerTask = $module.ExportedCommands['Register-ScheduledTask']",
+    "if ($null -eq $registerTask) { throw 'Trusted ScheduledTasks module does not export Register-ScheduledTask.' }",
+    "& $registerTask -TaskName $taskName -Xml $xml -Force -ErrorAction Stop | Out-Null",
   ].join("; ");
   const encodedCommand = Buffer.from(inner, "utf16le").toString("base64");
   const script = [
-    `$p = Start-Process -FilePath ${psSingleQuote(windowsPowerShell())}`,
+    `$p = Start-Process -FilePath ${psSingleQuote(powerShellPath)}`,
     ` -ArgumentList ${psSingleQuote(buildWindowsElevatedArgumentList([
       "-NoProfile",
       "-NonInteractive",

package/src/lib/windows-secret-acl.ts

@@ -31,6 +31,7 @@
 
 import { existsSync, statSync } from "node:fs";
 import { env, platform } from "node:process";
+import { resolveTrustedWindowsIcaclsExe } from "./windows-elevation";
 import {
   resolveCurrentWindowsPrincipal,
   resolveCurrentWindowsPrincipalAsync,
@@ -273,22 +274,55 @@ export interface IcaclsResult {
 type IcaclsRunner = (args: string[], timeoutMs: number) => IcaclsResult;
 type AsyncIcaclsRunner = (args: string[], timeoutMs: number) => Promise<IcaclsResult>;
 
+function resolveIcaclsExecutable(): string {
+  // Same authority as schtasks/powershell: never take icacls from PATH.
+  // A bun-shim or stripped PATH makes `icacls.exe` throw ENOENT, which used to
+  // surface as "filesystem may not support per-user NTFS ACLs".
+  return resolveTrustedWindowsIcaclsExe();
+}
+
+function spawnFailedResult(): IcaclsResult {
+  return { success: false, exitCode: null, timedOut: false, stdout: "" };
+}
+
+/**
+ * Spawn icacls asynchronously, or return null when the executable cannot be
+ * launched. The pipe/ignore stdio literals stay inferred here so `stdout` keeps
+ * its `ReadableStream` type instead of widening to the generic default.
+ */
+function trySpawnIcacls(args: string[]) {
+  try {
+    return Bun.spawn([resolveIcaclsExecutable(), ...args], {
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "ignore",
+      windowsHide: true,
+    });
+  } catch {
+    return null;
+  }
+}
+
 function defaultIcaclsRunner(args: string[], timeoutMs: number): IcaclsResult {
   // Bun.spawnSync with windowsHide: Node execFileSync has hung under the GUI/proxy even
   // with windowsHide, and console-subsystem tools flash a visible window otherwise.
-  const result = Bun.spawnSync(["icacls.exe", ...args], {
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "ignore",
-    timeout: timeoutMs,
-    windowsHide: true,
-  });
-  return {
-    success: result.success,
-    exitCode: result.exitCode,
-    timedOut: result.exitedDueToTimeout ?? false,
-    stdout: result.stdout ? result.stdout.toString() : "",
-  };
+  try {
+    const result = Bun.spawnSync([resolveIcaclsExecutable(), ...args], {
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "ignore",
+      timeout: timeoutMs,
+      windowsHide: true,
+    });
+    return {
+      success: result.success,
+      exitCode: result.exitCode,
+      timedOut: result.exitedDueToTimeout ?? false,
+      stdout: result.stdout ? result.stdout.toString() : "",
+    };
+  } catch {
+    return spawnFailedResult();
+  }
 }
 
 /**
@@ -297,12 +331,8 @@ function defaultIcaclsRunner(args: string[], timeoutMs: number): IcaclsResult {
  * we still await process exit before classifying so settlement is confirmed.
  */
 async function defaultAsyncIcaclsRunner(args: string[], timeoutMs: number): Promise<IcaclsResult> {
-  const proc = Bun.spawn(["icacls.exe", ...args], {
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "ignore",
-    windowsHide: true,
-  });
+  const proc = trySpawnIcacls(args);
+  if (!proc) return spawnFailedResult();
   let timedOutByUs = false;
   const timer = setTimeout(() => {
     timedOutByUs = true;

package/src/oauth/google-antigravity.ts

@@ -12,7 +12,7 @@
 import { OAuthCallbackFlow, type OAuthCallbackFlowOptions } from "./callback-server";
 import { generatePKCE } from "./pkce";
 import type { OAuthController, OAuthCredentials } from "./types";
-import { antigravityUserAgent, ANTIGRAVITY_GOOG_API_CLIENT_UA } from "../adapters/client-fingerprint";
+import { antigravityUserAgent, ANTIGRAVITY_GOOG_API_CLIENT_UA, ANTIGRAVITY_IDE_VERSION } from "../adapters/client-fingerprint";
 
 const CLIENT_ID = process.env.GOOGLE_ANTIGRAVITY_CLIENT_ID
   || "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
@@ -111,7 +111,12 @@ async function onboardProject(accessToken: string, signal?: AbortSignal): Promis
     const response = await fetch(`${DAILY_API}/${API_VERSION}:onboardUser`, {
       method: "POST",
       headers: { Authorization: `Bearer ${accessToken}`, Accept: "*/*", "Content-Type": "application/json", "User-Agent": antigravityUserAgent(), "x-goog-api-client": ANTIGRAVITY_GOOG_API_CLIENT_UA },
-      body: JSON.stringify({ tier_id: "free-tier", metadata: { ide_type: "ANTIGRAVITY", ide_name: "antigravity", ide_version: antigravityUserAgent() } }),
+      // `ide_version` is a version, not a User-Agent. `antigravityUserAgent()` returns the whole
+      // header — `antigravity/ide/2.5.5 (aidev_client; os_type=...; arch=...)` — so onboarding was
+      // sending a parenthesized UA string in a field the real client fills with `2.5.5`. It is a
+      // fingerprint mismatch rather than a crash, which is why nothing failed: the request still
+      // succeeds, it just does not look like Antigravity.
+      body: JSON.stringify({ tier_id: "free-tier", metadata: { ide_type: "ANTIGRAVITY", ide_name: "antigravity", ide_version: ANTIGRAVITY_IDE_VERSION } }),
       signal: requestSignal(signal),
     });
     if (!response.ok) {

package/src/providers/antigravity-models.ts

@@ -1,4 +1,5 @@
 import { isValidModelDiscoveryModelId, MODEL_DISCOVERY_MAX_MODELS } from "./model-discovery-limits";
+import { isModelCacheGenerationCurrent } from "../codex/model-cache";
 
 // Google Antigravity (Cloud Code Assist) bundled model list.
 //
@@ -74,8 +75,12 @@ const ANTIGRAVITY_DISCOVERY_EFFORTS = ["low", "medium", "high"] as const;
 
 function pickerModelIdForDiscoveredWireId(
   wireId: string,
+  info: Record<string, unknown>,
   available: ReadonlyMap<string, Record<string, unknown>>,
 ): string {
+  const displayModelId = antigravityDisplayModelId(info.displayName, wireId);
+  if (displayModelId) return displayModelId;
+
   const explicitPickerId = Object.hasOwn(ANTIGRAVITY_PICKER_MODEL_BY_WIRE_ID, wireId)
     ? ANTIGRAVITY_PICKER_MODEL_BY_WIRE_ID[wireId]
     : undefined;
@@ -240,6 +245,8 @@ export const ANTIGRAVITY_MODEL_INPUT_MODALITIES: Record<string, string[]> = {
 
 export interface AntigravityAvailableModel {
   id: string;
+  /** CCA model id used by the agent envelope when `id` comes from display metadata. */
+  wireModelId: string;
   contextWindow?: number;
   inputModalities?: string[];
 }
@@ -254,6 +261,100 @@ function antigravityPositiveInteger(value: unknown): number | undefined {
   return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
 }
 
+interface DiscoveredWireModelMapping {
+  readonly models: ReadonlyMap<string, string>;
+  readonly generation?: { provider: string; cacheGeneration: string };
+}
+
+const discoveredWireModelsByBaseUrl = new Map<string, DiscoveredWireModelMapping>();
+
+/**
+ * Strip trailing slashes without a backtracking regex.
+ *
+ * `/\/+$/` is polynomial-ReDoS on attacker-influenceable input (CodeQL js/polynomial-redos):
+ * a long run of slashes makes the engine retry every suffix. The base URL comes from provider
+ * config, which is not hostile in the ordinary case — but "not hostile today" is a property of
+ * the caller, not of this function, and a linear scan costs nothing.
+ */
+function stripTrailingSlashes(value: string): string {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) end -= 1;
+  return end === value.length ? value : value.slice(0, end);
+}
+
+function antigravityBaseUrlKey(baseUrl: string | undefined): string | undefined {
+  if (typeof baseUrl !== "string" || !baseUrl.trim()) return undefined;
+  const trimmed = stripTrailingSlashes(baseUrl.trim());
+  try {
+    const url = new URL(trimmed);
+    url.hash = "";
+    url.search = "";
+    return stripTrailingSlashes(url.toString()).toLowerCase();
+  } catch {
+    return trimmed.toLowerCase();
+  }
+}
+
+/** Remember the wire ids returned by one live CCA discovery for request routing. */
+export function registerAntigravityDiscoveredWireModels(
+  baseUrl: string | undefined,
+  models: readonly AntigravityAvailableModel[],
+  generation?: { provider: string; cacheGeneration: string },
+): void {
+  const key = antigravityBaseUrlKey(baseUrl);
+  if (!key) return;
+  const wireModels = new Map<string, string>();
+  for (const model of models) wireModels.set(model.id, model.wireModelId);
+  discoveredWireModelsByBaseUrl.set(key, {
+    models: wireModels,
+    ...(generation ? { generation } : {}),
+  });
+}
+
+function discoveredAntigravityWireModelId(
+  modelId: string,
+  baseUrl: string | undefined,
+): string | undefined {
+  const key = antigravityBaseUrlKey(baseUrl);
+  if (!key) return undefined;
+  const mapping = discoveredWireModelsByBaseUrl.get(key);
+  if (!mapping) return undefined;
+  if (mapping.generation
+    && !isModelCacheGenerationCurrent(mapping.generation.provider, mapping.generation.cacheGeneration)) {
+    discoveredWireModelsByBaseUrl.delete(key);
+    return undefined;
+  }
+  return mapping.models.get(modelId);
+}
+
+/**
+ * Convert the CCA display label used by `agy` into its public model selector.
+ *
+ * The wire id is authoritative for requests, while the label is authoritative for the
+ * user-facing selector when Google has renamed or re-tiered a model. Keep both instead
+ * of maintaining a provider-specific list of known model names.
+ */
+function antigravityDisplayModelId(displayName: unknown, wireId: string): string | undefined {
+  if (typeof displayName !== "string") return undefined;
+  const label = displayName.trim();
+  if (!label || label.length > 512) return undefined;
+  const slug = (replaceDots: boolean): string => label
+    .normalize("NFKC")
+    .toLowerCase()
+    .replace(replaceDots ? /\./g : /\s+/g, replaceDots ? "-" : " ")
+    .replace(/[^a-z0-9.-]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+  const preserved = slug(false);
+  const compact = slug(true);
+  if (!isValidModelDiscoveryModelId(preserved) && !isValidModelDiscoveryModelId(compact)) return undefined;
+  if (preserved === wireId || compact === wireId
+    || preserved === `${wireId}-thinking` || compact === `${wireId}-thinking`) {
+    return wireId;
+  }
+  return isValidModelDiscoveryModelId(preserved) ? preserved : compact;
+}
+
 /**
  * Extract the CCA models that are valid for agent requests. The endpoint also returns tab,
  * command, commit-message, transcription, and standalone image-generation models; those are not
@@ -288,13 +389,6 @@ export function parseAntigravityAvailableModels(
       }
     }
   }
-  // This model is exposed by Antigravity's agent chat surface even though it is grouped under
-  // image generation in the discovery response.
-  if (Array.isArray(body.imageGenerationModelIds)
-    && body.imageGenerationModelIds.includes("gemini-3.1-flash-image")) {
-    if (ids.length >= limit) return null;
-    ids.push("gemini-3.1-flash-image");
-  }
   // Newer CCA responses identify tiered Flash models through this index instead of
   // adding their synthetic wire ids to agentModelSorts.
   const tieredModelIds = antigravityRecord(body.tieredModelIds);
@@ -305,6 +399,12 @@ export function parseAntigravityAvailableModels(
         || !Object.hasOwn(models, id)
         || !antigravityRecord(models[id])
         || ids.length >= limit) return null;
+      const baseId = id.endsWith("-tiered") ? id.slice(0, -"-tiered".length) : id;
+      if (ids.some(agentId =>
+        agentId === id
+        || agentId === baseId
+        || ANTIGRAVITY_DISCOVERY_EFFORTS.some(effort => agentId === `${baseId}-${effort}`)
+      )) continue;
       ids.push(id);
     }
   }
@@ -313,23 +413,18 @@ export function parseAntigravityAvailableModels(
   for (const wireId of ids) {
     const info = antigravityRecord(models[wireId]);
     if (!info || available.has(wireId)) continue;
-    // Legacy compatibility aliases are deliberately routed to newer wire ids for saved
-    // selections. They are not safe as independently discovered picker rows.
-    const alias = Object.hasOwn(ANTIGRAVITY_MODEL_ALIASES, wireId)
-      ? ANTIGRAVITY_MODEL_ALIASES[wireId]
-      : undefined;
-    if (alias && alias !== wireId) continue;
     available.set(wireId, info);
   }
 
   const out: AntigravityAvailableModel[] = [];
   const seen = new Set<string>();
   for (const [wireId, info] of available) {
-    const id = pickerModelIdForDiscoveredWireId(wireId, available);
+    const id = pickerModelIdForDiscoveredWireId(wireId, info, available);
     if (seen.has(id)) continue;
     seen.add(id);
     out.push({
       id,
+      wireModelId: wireId,
       ...(antigravityPositiveInteger(info.maxTokens) ? { contextWindow: antigravityPositiveInteger(info.maxTokens) } : {}),
       // Tri-state, deliberately not a ternary: `true` asserts image support,
       // `false` asserts against it, and ABSENT is unknown. Collapsing absent into
@@ -347,7 +442,9 @@ export function parseAntigravityAvailableModels(
   return out;
 }
 
-export function resolveAntigravityWireModelId(modelId: string): string {
+export function resolveAntigravityWireModelId(modelId: string, baseUrl?: string): string {
+  const discovered = discoveredAntigravityWireModelId(modelId, baseUrl);
+  if (discovered) return discovered;
   return Object.hasOwn(ANTIGRAVITY_MODEL_ALIASES, modelId)
     ? ANTIGRAVITY_MODEL_ALIASES[modelId]
     : modelId;
@@ -380,7 +477,19 @@ export function retiredAntigravityFlashTier(modelId: string): string | undefined
 export function resolveAntigravityEffortWireModel(
   modelId: string,
   effort?: string,
+  baseUrl?: string,
 ): { wireModelId: string; thinkingLevel?: string } {
+  const discoveredWireModelId = discoveredAntigravityWireModelId(modelId, baseUrl);
+  if (discoveredWireModelId && (discoveredWireModelId !== modelId || isAntigravitySuffixModelId(modelId))) {
+    const defaultLevel = ANTIGRAVITY_THINKING_LEVEL_MODELS[modelId];
+    return {
+      wireModelId: discoveredWireModelId,
+      ...(defaultLevel
+        ? { thinkingLevel: effort ? resolveAntigravityThinkingLevel(effort) ?? defaultLevel : defaultLevel }
+        : {}),
+    };
+  }
+
   // Rule 0: retired Flash id — Google has taken the wire id offline, so route to the
   // current generation and carry the tier the retired id encoded. This runs BEFORE the
   // suffix check because those ids are aliases, and rule 1 would drop the tier.
@@ -394,7 +503,7 @@ export function resolveAntigravityEffortWireModel(
 
   // Rule 1: suffix/compat alias — suffix IS the effort.
   if (isAntigravitySuffixModelId(modelId)) {
-    return { wireModelId: resolveAntigravityWireModelId(modelId) };
+    return { wireModelId: resolveAntigravityWireModelId(modelId, baseUrl) };
   }
 
   // Rule 1b: single-wire-id Gemini model whose tiers ride on thinkingLevel. Without
@@ -424,7 +533,7 @@ export function resolveAntigravityEffortWireModel(
   }
 
   // Rule 5: everything else.
-  return { wireModelId: resolveAntigravityWireModelId(modelId) };
+  return { wireModelId: resolveAntigravityWireModelId(modelId, baseUrl) };
 }
 
 

package/src/providers/derive.ts

@@ -393,6 +393,14 @@ function enrichReasoningSummariesByDestination(prov: OcxProviderConfig): void {
   applyReasoningSummaryDefaults(prov, destination?.modelSupportsReasoningSummaries);
 }
 
+/** Repair the exact low-only ClinePass ladder generated by older key-login presets. */
+export function hasLegacyClinePassReasoningEfforts(name: string, prov: OcxProviderConfig): boolean {
+  return name === "cline-pass"
+    && prov.reasoningWireFormat === "gateway-object"
+    && prov.reasoningEfforts?.length === 1
+    && prov.reasoningEfforts[0] === "low";
+}
+
 export function enrichProviderFromRegistry(name: string, prov: OcxProviderConfig): void {
   const entry = PROVIDER_REGISTRY.find(row => row.id === name);
   if (!entry || !providerMatchesRegistryTransportWithStaticGuards(name, prov)) {
@@ -426,7 +434,9 @@ export function enrichProviderFromRegistry(name: string, prov: OcxProviderConfig
   if (seed.modelInputModalities) prov.modelInputModalities = fillRecordOfArrays(seed.modelInputModalities, prov.modelInputModalities);
   if (prov.defaultMaxOutputTokens === undefined && seed.defaultMaxOutputTokens !== undefined) prov.defaultMaxOutputTokens = seed.defaultMaxOutputTokens;
   if (!prov.modelMaxOutputTokens && seed.modelMaxOutputTokens) prov.modelMaxOutputTokens = { ...seed.modelMaxOutputTokens };
-  if (!prov.reasoningEfforts && seed.reasoningEfforts) prov.reasoningEfforts = [...seed.reasoningEfforts];
+  if ((!prov.reasoningEfforts || hasLegacyClinePassReasoningEfforts(name, prov)) && seed.reasoningEfforts) {
+    prov.reasoningEfforts = [...seed.reasoningEfforts];
+  }
   if (!prov.modelReasoningEfforts && seed.modelReasoningEfforts) prov.modelReasoningEfforts = cloneRecordOfArrays(seed.modelReasoningEfforts);
   if (!prov.modelDefaultReasoningEfforts && seed.modelDefaultReasoningEfforts) prov.modelDefaultReasoningEfforts = { ...seed.modelDefaultReasoningEfforts };
   if (!prov.reasoningEffortMap && seed.reasoningEffortMap) prov.reasoningEffortMap = { ...seed.reasoningEffortMap };

package/src/responses/parser.ts

@@ -171,6 +171,10 @@ function buildTools(tools: unknown[] | undefined): OcxTool[] | undefined {
   };
   for (const t of tools) {
     if (!isObj(t)) continue;
+    if (t.type === "function" && isObj(t.function) && typeof t.function.name === "string" && t.function.name.length > 0) {
+      pushFn(t.function as Record<string, unknown>);
+      continue;
+    }
     if (t.type === "function" && typeof t.name === "string") {
       pushFn(t);
     } else if (t.type === "namespace" && Array.isArray(t.tools)) {

package/src/responses/reasoning-replay-cache.ts

@@ -19,7 +19,7 @@
  * long-lived proxy cannot grow without limit.
  */
 
-import { createHmac, randomBytes } from "node:crypto";
+import { createHash, createHmac, randomBytes } from "node:crypto";
 import type {
   OcxProviderConfig,
   OcxReasoningReplayIdentity,
@@ -108,6 +108,21 @@ export function reasoningReplayDestinationIdentity(baseUrl: string | undefined):
   return `destination:${processLocalIdentity("destination", canonical)}`;
 }
 
+/**
+ * The same destination identity, but stable across restarts.
+ *
+ * The process-local form above is keyed by `randomBytes(32)` minted at module load, which
+ * is correct for an in-memory cache and fatal for a durable one: every key would change on
+ * restart and the store would silently stop matching anything. A plain digest of the same
+ * canonical URL is equally non-reversible for this purpose — the input is a configured
+ * endpoint, not a secret — and needs no persisted salt or new on-disk state.
+ */
+export function durableReplayDestinationIdentity(baseUrl: string | undefined): string | undefined {
+  if (!nonEmpty(baseUrl)) return undefined;
+  const canonical = baseUrl.trim().replace(/\/+$/, "");
+  return `destination:${createHash("sha256").update("destination\0").update(canonical).digest("hex")}`;
+}
+
 /** Produce a non-reversible process-local identity for credential material. */
 export function reasoningReplayCredentialIdentity(
   kind: "key" | "oauth" | "codex",

package/src/responses/thought-signature-replay.ts

@@ -27,6 +27,11 @@ import type { OcxProviderOpaqueToolCallMetadata, OcxReasoningReplayScopeRef } fr
 import { isCarryableSignature, responsesExtraContentFromProviderMetadata } from "./provider-opaque-metadata";
 
 const STORE_FILE_NAME = "thought-signature-replay.json";
+/**
+ * Bumped whenever `keyFor` changes shape. v3 added the durable destination identity, so a
+ * v2 file's keys can never match and are dropped on load instead of aging out invisibly.
+ */
+const STORE_VERSION = 3;
 
 /** Bound on remembered entries; real signatures are a few hundred bytes, so this stays small. */
 const MAX_ENTRIES = 16_384;
@@ -83,6 +88,11 @@ function keyFor(callId: string, scope: OcxReasoningReplayScopeRef | undefined):
   return JSON.stringify([
     scope.clientThreadId,
     identity.providerName,
+    // Destination, unlike the credential identity, has a restart-stable form: it is a
+    // configured endpoint rather than a secret, so a plain digest works where the
+    // reasoning cache's randomBytes-keyed HMAC cannot. Without it, one provider NAME
+    // serving two endpoints shares signatures across both.
+    identity.providerDestinationDurableIdentity ?? "destination:unknown",
     identity.adapterName,
     identity.modelId,
     callId,
@@ -103,6 +113,12 @@ function load(): void {
     if (typeof parsed !== "object" || parsed === null || !Array.isArray((parsed as { entries?: unknown }).entries)) {
       return;
     }
+    // The version was written but never read, so a key-shape change could not be
+    // announced — old entries simply went dead and aged out on TTL, which is silent and
+    // indistinguishable from a store that is not working. Reading it makes a shape change
+    // an explicit drop: entries keyed by an older scheme are discarded on load rather than
+    // lingering as permanent misses.
+    if ((parsed as { version?: unknown }).version !== STORE_VERSION) return;
     const nowMs = Date.now();
     for (const entry of (parsed as { entries: unknown[] }).entries) {
       if (typeof entry !== "object" || entry === null) continue;
@@ -141,7 +157,7 @@ function persist(): Promise<void> {
   persistChain = persistChain
     .then(async () => {
       const snapshot = JSON.stringify({
-        version: 2,
+        version: STORE_VERSION,
         entries: [...entries].map(([key, entry]) => ({ key, sig: entry.sig, savedAt: entry.savedAt })),
       });
       await atomicWriteFileAsync(storePath(), snapshot);