@bitkyc08/opencodex 2.11.1 → 2.12.0

package/src/lab/subject/behavior-fingerprint.ts

@@ -0,0 +1,77 @@
+import { createHash } from "node:crypto";
+import { jcsStringify } from "../digest";
+import type { LabBehaviorSource, LabBehaviorValues } from "../live/types";
+
+const CLOSED_KEYS = new Set([
+  "wire.adapter", "wire.upstreamProtocol", "wire.responsesPath", "wire.commandCodeVersion", "wire.modelSuffixMode",
+  "auth.mode", "auth.transport",
+  "responses.stateful", "responses.upstreamStreaming", "responses.serviceTier", "responses.snapshotRepair", "responses.itemIdRepair",
+  "limits.contextWindow", "limits.maxInputTokens", "limits.maxOutputTokens",
+  "modalities.input",
+  "sampling.omitTemperature", "sampling.omitTopP", "sampling.omitPenalties",
+  "reasoning.supported", "reasoning.efforts", "reasoning.defaultEffort", "reasoning.effortMap", "reasoning.wireFormat",
+  "reasoning.summaryMode", "reasoning.replayMode", "reasoning.splitMode", "reasoning.toggleMode", "reasoning.budgetMode",
+  "tools.choiceRestrictions", "tools.parallel", "tools.hostedPreference", "tools.customFreeform", "tools.builtinNameEscaping",
+  "cache.forwarding", "cache.retention", "anthropic.eofPolicy",
+  "google.mode", "google.projectFingerprint", "google.locationFingerprint",
+  "openrouter.order", "openrouter.only", "openrouter.allowFallbacks",
+  "sidecars.vision", "sidecars.webSearch",
+  "mcp.maxTools", "mcp.maxSchemaBytes", "mcp.maxResultBytes", "mcp.nativeLocalExec",
+  "runtime.bunVersion", "runtime.platform", "runtime.arch", "runtime.streamMode", "runtime.fastMode", "runtime.effortCap",
+  "headers.nonCredentialBehaviorDigest",
+] as const);
+
+const SOURCES = new Set<LabBehaviorSource>([
+  "request", "model_override", "provider_config", "registry_runtime_default", "generated_model_metadata",
+  "global_config", "adapter_default", "lab_forced",
+]);
+
+const SET_ARRAY_KEYS = new Set(["modalities.input", "reasoning.efforts", "tools.choiceRestrictions", "openrouter.only"]);
+const ORDERED_ARRAY_KEYS = new Set(["openrouter.order"]);
+const REQUIRED_KEYS = [
+  "wire.adapter", "wire.upstreamProtocol", "auth.mode", "auth.transport", "mcp.nativeLocalExec",
+  "runtime.bunVersion", "runtime.platform", "runtime.arch", "runtime.streamMode", "runtime.fastMode", "runtime.effortCap",
+] as const;
+
+function canonicalArray(key: string, value: unknown[]): unknown[] {
+  if (SET_ARRAY_KEYS.has(key)) {
+    const byBytes = value.map((item) => ({ item, bytes: jcsStringify(item) }));
+    const seen = new Set<string>();
+    for (const row of byBytes) {
+      if (seen.has(row.bytes)) throw new Error(`harness_failure: duplicate behavior array value for ${key}`);
+      seen.add(row.bytes);
+    }
+    byBytes.sort((a, b) => a.bytes < b.bytes ? -1 : a.bytes > b.bytes ? 1 : 0);
+    return byBytes.map((row) => row.item);
+  }
+  if (ORDERED_ARRAY_KEYS.has(key)) return [...value];
+  throw new Error(`harness_failure: unclassified_behavior_input array for ${key}`);
+}
+
+export function normalizeBehaviorValues(values: LabBehaviorValues): LabBehaviorValues {
+  if (!values || typeof values !== "object" || Array.isArray(values)) {
+    throw new Error("harness_failure: behavior resolver output is required");
+  }
+  for (const key of REQUIRED_KEYS) {
+    if (!(key in values)) throw new Error(`harness_failure: unclassified_behavior_input missing ${key}`);
+  }
+  const normalized: LabBehaviorValues = {};
+  for (const key of Object.keys(values).sort()) {
+    if (!CLOSED_KEYS.has(key as never)) throw new Error(`harness_failure: unclassified_behavior_input ${key}`);
+    const row = values[key];
+    if (!row || typeof row !== "object" || Array.isArray(row) || !SOURCES.has(row.source)) {
+      throw new Error(`harness_failure: invalid behavior source for ${key}`);
+    }
+    normalized[key] = {
+      source: row.source,
+      value: Array.isArray(row.value) ? canonicalArray(key, row.value) : row.value,
+    };
+  }
+  return normalized;
+}
+
+/** Hash the authoritative production resolver output; Lab performs validation/canonicalization only. */
+export function buildBehaviorFingerprintV1(values: LabBehaviorValues): string {
+  const payload = { schemaVersion: 1, resolverVersion: 1, values: normalizeBehaviorValues(values) };
+  return createHash("sha256").update(jcsStringify(payload)).digest("hex");
+}

package/src/lab/subject/installation-salt.ts

@@ -0,0 +1,81 @@
+import { closeSync, fsyncSync, linkSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { dirname } from "node:path";
+import { labInstallationSaltPath, labRoot } from "../paths";
+
+const SALT_BYTES = 32;
+const UNSUPPORTED_DIRECTORY_FSYNC_CODES = new Set(["EINVAL", "ENOTSUP", "EOPNOTSUPP", "ENOSYS"]);
+
+function readSaltFile(path: string): Uint8Array {
+  const bytes = readFileSync(path);
+  if (bytes.byteLength !== SALT_BYTES) {
+    throw new Error("harness_failure: invalid installation salt length");
+  }
+  return new Uint8Array(bytes);
+}
+
+function removeStagingFile(path: string): void {
+  try { unlinkSync(path); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+  }
+}
+
+function fsyncDirectory(path: string): void {
+  // Windows has no portable directory-fsync primitive. Some POSIX-backed
+  // filesystems (notably virtual/shared filesystems) report directory fsync as
+  // unsupported. In those cases the fsync'd staging inode plus atomic same-dir
+  // hard-link publication is the supported durability fallback. Unexpected I/O
+  // errors remain fatal.
+  if (process.platform === "win32") return;
+  const dirFd = openSync(path, "r");
+  try {
+    try { fsyncSync(dirFd); }
+    catch (error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (code && UNSUPPORTED_DIRECTORY_FSYNC_CODES.has(code)) return;
+      throw error;
+    }
+  } finally { closeSync(dirFd); }
+}
+
+/** Read or atomically publish the per-installation salt used for local fingerprinting. */
+export function readInstallationSalt(configDir?: string): Uint8Array {
+  const path = labInstallationSaltPath(configDir);
+  const root = labRoot(configDir);
+  mkdirSync(root, { recursive: true, mode: 0o700 });
+
+  try { return readSaltFile(path); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+  }
+
+  // The final pathname must never become visible before all 32 bytes are durable in the
+  // staging inode. A hard-link publish is atomic and fails with EEXIST when another process won.
+  const stagingPath = `${path}.tmp-${process.pid}-${randomBytes(8).toString("hex")}`;
+  if (dirname(stagingPath) !== dirname(path)) throw new Error("harness_failure: installation salt staging path escaped directory");
+  const salt = randomBytes(SALT_BYTES);
+  let fd: number | undefined;
+  try {
+    fd = openSync(stagingPath, "wx", 0o600);
+    writeFileSync(fd, salt);
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = undefined;
+
+    try {
+      linkSync(stagingPath, path);
+      try { fsyncDirectory(dirname(path)); }
+      catch { throw new Error("harness_failure: installation salt directory fsync failed"); }
+      return new Uint8Array(salt);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+      return readSaltFile(path);
+    }
+  } finally {
+    if (fd !== undefined) {
+      try { closeSync(fd); } catch { /* best-effort close before cleanup */ }
+    }
+    removeStagingFile(stagingPath);
+  }
+}

package/src/lab/subject/route-subject.ts

@@ -0,0 +1,73 @@
+import { localFingerprint } from "../digest";
+import type { RouteDependencyV1, RouteSubjectV1 } from "../events/types";
+import type { LabDestinationV1, LabRouteContext } from "../live/types";
+import { buildBehaviorFingerprintV1 } from "./behavior-fingerprint";
+import { readInstallationSalt } from "./installation-salt";
+
+function compareDependency(a: RouteDependencyV1, b: RouteDependencyV1): number {
+  const fields: Array<keyof RouteDependencyV1> = [
+    "role", "providerId", "providerInstanceFingerprint", "upstreamModelId", "endpointFingerprint",
+    "clientModelId", "effectiveAdapter", "upstreamProtocol", "behaviorFingerprint",
+  ];
+  for (const field of fields) {
+    const av = a[field];
+    const bv = b[field];
+    if (av < bv) return -1;
+    if (av > bv) return 1;
+  }
+  return 0;
+}
+
+function canonicalDependencies(dependencies: RouteDependencyV1[] | undefined): RouteDependencyV1[] {
+  const rows = (dependencies ?? []).map((row) => Object.freeze({ ...row }));
+  rows.sort(compareDependency);
+  for (let i = 1; i < rows.length; i++) {
+    if (compareDependency(rows[i - 1]!, rows[i]!) === 0) {
+      throw new Error("harness_failure: duplicate route dependency");
+    }
+  }
+  return rows;
+}
+
+/** Build RouteSubjectV1 only from an approved immutable destination and authoritative effective resolver inputs. */
+export function buildRouteSubjectV1(
+  routeContext: LabRouteContext,
+  destination: LabDestinationV1,
+  configDir?: string,
+): RouteSubjectV1 {
+  if (!routeContext.providerInstanceKey) throw new Error("harness_failure: provider instance identity is required");
+  if (!/^[0-9a-f]{64}$/.test(routeContext.opencodexCompatibilityVersion)) {
+    throw new Error("harness_failure: invalid opencodexCompatibilityVersion");
+  }
+  const adapterValue = routeContext.behaviorValues["wire.adapter"]?.value;
+  const protocolValue = routeContext.behaviorValues["wire.upstreamProtocol"]?.value;
+  if (adapterValue !== routeContext.effectiveAdapter || protocolValue !== routeContext.upstreamProtocol) {
+    throw new Error("harness_failure: behavior resolver output does not match exact route");
+  }
+  const salt = readInstallationSalt(configDir);
+  const providerInstanceFingerprint = localFingerprint("providerInstance", routeContext.providerInstanceKey, salt);
+  const dependencies = canonicalDependencies(routeContext.dependencies);
+  const subject: RouteSubjectV1 = {
+    subjectSchemaVersion: 1,
+    subjectKind: "route",
+    providerId: routeContext.providerId,
+    providerInstanceFingerprint,
+    clientModelId: routeContext.clientModelId,
+    upstreamModelId: routeContext.upstreamModelId,
+    effectiveAdapter: routeContext.effectiveAdapter,
+    inboundProtocol: routeContext.inboundProtocol,
+    upstreamProtocol: routeContext.upstreamProtocol,
+    surface: routeContext.surface,
+    opencodexCompatibilityVersion: routeContext.opencodexCompatibilityVersion,
+    behaviorFingerprint: buildBehaviorFingerprintV1(routeContext.behaviorValues),
+    endpointFingerprint: destination.fingerprint,
+    dependencies,
+  };
+  return freezeRouteSubject(subject);
+}
+
+/** Deep-freeze route dependencies as well as the subject shell. */
+export function freezeRouteSubject(subject: RouteSubjectV1): RouteSubjectV1 {
+  const dependencies = subject.dependencies.map((row) => Object.freeze({ ...row }));
+  return Object.freeze({ ...subject, dependencies: Object.freeze(dependencies) as unknown as RouteDependencyV1[] });
+}

package/src/lib/bounded-body.ts

@@ -44,6 +44,26 @@ export interface BoundedBodyResult {
 	displaySafe: boolean;
 }
 
+export interface BoundedBytesOptions {
+	/** Abort the read with this signal. Its reason is rethrown by identity. */
+	signal?: AbortSignal;
+	/** Maximum number of raw bytes retained from the response body. */
+	maxBytes: number;
+}
+
+export interface BoundedBytesResult {
+	/**
+	 * Exact raw bytes retained from the response. Empty when the cap was exceeded.
+	 *
+	 * This is a view over internal storage, so `bytes.buffer.byteLength` can exceed
+	 * `bytes.byteLength`. Consumers must honor the view's byteOffset and byteLength
+	 * instead of reading or transferring the backing buffer directly.
+	 */
+	bytes: Uint8Array<ArrayBuffer>;
+	/** True when the body was observed to exceed the byte cap. */
+	oversized: boolean;
+}
+
 const TOTAL_TIMEOUT = Symbol("bounded body total timeout");
 const INACTIVITY_TIMEOUT = Symbol("bounded body inactivity timeout");
 
@@ -83,6 +103,90 @@ function cancelWithoutWaiting(reader: ReadableStreamDefaultReader<Uint8Array>, r
 	}
 }
 
+/**
+ * Consume the original response body as raw bytes under a strict memory ceiling.
+ *
+ * The caller owns any wall-clock deadline through `signal`, which lets one budget
+ * cover both response headers and body consumption. No decoding, cloning, or teeing
+ * occurs, so arbitrary upstream bytes remain unchanged.
+ */
+export async function readBoundedResponseBytes(
+	response: Response,
+	options: BoundedBytesOptions,
+): Promise<BoundedBytesResult> {
+	const signal = options.signal;
+	if (signal?.aborted) throw signal.reason;
+
+	const body = response.body;
+	if (!body) return { bytes: new Uint8Array(0), oversized: false };
+
+	const reader = body.getReader();
+	const maxBytes = options.maxBytes;
+	let retained = new Uint8Array(Math.min(maxBytes, 64 * 1024));
+	let retainedBytes = 0;
+	let mustCancel = false;
+	let cancelReason: unknown;
+
+	let rejectForAbort: ((reason: unknown) => void) | undefined;
+	const aborted = new Promise<never>((_resolve, reject) => {
+		rejectForAbort = reject;
+	});
+	const onAbort = () => rejectForAbort?.(signal?.reason);
+	signal?.addEventListener("abort", onAbort, { once: true });
+	// Close the narrow race between the preflight check and listener install.
+	if (signal?.aborted) onAbort();
+
+	try {
+		while (true) {
+			const read = reader.read();
+			// Observe a late read rejection when abort/cancellation wins the race.
+			void read.catch(() => undefined);
+			const outcome = await Promise.race([read, aborted]);
+			if (signal?.aborted) {
+				mustCancel = true;
+				cancelReason = signal.reason;
+				throw signal.reason;
+			}
+
+			const { value, done } = outcome;
+			if (done) {
+				return { bytes: retained.subarray(0, retainedBytes), oversized: false };
+			}
+			if (!value || value.byteLength === 0) continue;
+
+			if (value.byteLength > maxBytes - retainedBytes) {
+				mustCancel = true;
+				cancelReason = new DOMException("Response body size limit reached", "QuotaExceededError");
+				retained = new Uint8Array(0);
+				retainedBytes = 0;
+				return { bytes: retained, oversized: true };
+			}
+
+			if (retainedBytes + value.byteLength > retained.length) {
+				const grown = new Uint8Array(
+					Math.min(maxBytes, Math.max(retained.length * 2, retainedBytes + value.byteLength)),
+				);
+				grown.set(retained.subarray(0, retainedBytes));
+				retained = grown;
+			}
+			retained.set(value, retainedBytes);
+			retainedBytes += value.byteLength;
+		}
+	} catch (error) {
+		mustCancel = true;
+		cancelReason = error;
+		throw error;
+	} finally {
+		signal?.removeEventListener("abort", onAbort);
+		if (mustCancel) cancelWithoutWaiting(reader, cancelReason);
+		try {
+			reader.releaseLock();
+		} catch {
+			// A pending read can keep the lock briefly while cancel settles.
+		}
+	}
+}
+
 function decodeUtf8(chunks: readonly Uint8Array[], fatal: boolean): string {
 	const decoder = new TextDecoder("utf-8", { fatal });
 	let text = "";

package/src/lib/lab-live-execution-authority.ts

@@ -0,0 +1,13 @@
+import type { TrustedLabRouteExecutor } from "../lab/live/types";
+import { isHostIssuedLabRouteExecutor } from "./lab-live-host";
+
+/**
+ * Read-only trust check used by the Lab executor.
+ *
+ * Capability issuance intentionally does not live in this authority module: callers cannot
+ * self-attest sandbox boundary names here. Only the dedicated trusted host integration may
+ * construct and register an evidence-eligible route executor.
+ */
+export function isTrustedLabRouteExecutor(value: unknown): value is TrustedLabRouteExecutor {
+  return isHostIssuedLabRouteExecutor(value);
+}

package/src/lib/lab-live-host.ts

@@ -0,0 +1,30 @@
+import type { LabRouteExecutor, TrustedLabRouteExecutor } from "../lab/live/types";
+import { REQUIRED_LAB_SANDBOX_BOUNDARIES } from "../lab/live/types";
+
+const HOST_ISSUED_EXECUTORS = new WeakSet<object>();
+
+/**
+ * Trusted host integration boundary for CL-03 exact-route execution.
+ *
+ * This module is intentionally not re-exported from the Lab public surface. The host owns
+ * enforcement of every mandatory sandbox boundary and therefore supplies no caller-controlled
+ * boundary list. Adapters/providers receive only the resulting opaque capability.
+ *
+ * @internal host integration only
+ */
+export function createHostIssuedLabRouteExecutor(execute: LabRouteExecutor): TrustedLabRouteExecutor {
+  const capability: TrustedLabRouteExecutor = Object.freeze({
+    execute,
+    enforcedBoundaries: Object.freeze([...REQUIRED_LAB_SANDBOX_BOUNDARIES]),
+  });
+  HOST_ISSUED_EXECUTORS.add(capability);
+  return capability;
+}
+
+/** Internal recognition check consumed by the read-only authority facade. */
+export function isHostIssuedLabRouteExecutor(value: unknown): value is TrustedLabRouteExecutor {
+  if (typeof value !== "object" || value === null || !HOST_ISSUED_EXECUTORS.has(value as object)) return false;
+  const capability = value as TrustedLabRouteExecutor;
+  return capability.enforcedBoundaries.length === REQUIRED_LAB_SANDBOX_BOUNDARIES.length
+    && REQUIRED_LAB_SANDBOX_BOUNDARIES.every((boundary, index) => capability.enforcedBoundaries[index] === boundary);
+}

package/src/lib/lab-live-pinned-sender.ts

@@ -0,0 +1,45 @@
+import { PinnedHttpError, pinnedHttpGet, pinnedHttpPost } from "./pinned-http";
+import { TransportError } from "../lab/live/transport";
+import type { LabCredentialLeaseV1, LabPinnedSender } from "../lab/live/types";
+
+/** Only response metadata required by current live assertions crosses into Lab. */
+const LAB_RESPONSE_HEADER_ALLOWLIST = ["content-type"] as const;
+
+/**
+ * Trusted credential/transport owner. Secret headers exist only in this non-Lab module and are
+ * consumed directly by the pinned HTTP primitive; they are never returned to Lab code.
+ */
+export function createLabAuthorizedPinnedSender(
+  authorize: (lease: LabCredentialLeaseV1) => Promise<HeadersInit> | HeadersInit,
+): LabPinnedSender {
+  return async (lease, destination, pinned, request, signal, limits) => {
+    const headers = await authorize(lease);
+    const url = `${destination.scheme}://${destination.host}:${destination.port}${destination.basePath}${request.path}`;
+    const options = {
+      headers,
+      maxBytes: limits.maxOutputBytes,
+      connectTimeoutMs: limits.connectTimeoutMs,
+      idleTimeoutMs: Math.min(limits.firstByteTimeoutMs, limits.inactivityTimeoutMs),
+      rejectUnauthorized: true,
+      context: "Lab provider response",
+    };
+    let response: Response;
+    try {
+      response = request.method === "POST"
+        ? await pinnedHttpPost(url, pinned, request.body ?? "", signal, options)
+        : await pinnedHttpGet(url, pinned, signal, options);
+    } catch (error) {
+      if (error instanceof PinnedHttpError && error.code === "connect_timeout") {
+        throw new TransportError("connect_timeout", "pinned provider connection timed out");
+      }
+      throw error;
+    }
+    const body = await response.text();
+    const responseHeaders: Record<string, string> = {};
+    for (const headerName of LAB_RESPONSE_HEADER_ALLOWLIST) {
+      const value = response.headers.get(headerName);
+      if (value !== null) responseHeaders[headerName] = value;
+    }
+    return { status: response.status, headers: responseHeaders, body };
+  };
+}

package/src/lib/pinned-http.ts

@@ -1,11 +1,20 @@
-import http, { type IncomingMessage, type RequestOptions } from "node:http";
+import http, { type ClientRequest, type IncomingMessage, type RequestOptions } from "node:http";
 import https from "node:https";
 
 export type PinnedAddress = { address: string; family: number };
 
+export type PinnedHttpErrorCode = "connect_timeout";
+
+export class PinnedHttpError extends Error {
+  override readonly name = "PinnedHttpError";
+  constructor(readonly code: PinnedHttpErrorCode, message: string) { super(message); }
+}
+
 export interface PinnedHttpRequestOptions {
   headers?: HeadersInit;
   maxBytes?: number;
+  /** Optional deadline for establishing the TCP connection and, for HTTPS, completing TLS. */
+  connectTimeoutMs?: number;
   idleTimeoutMs?: number;
   rejectUnauthorized?: boolean;
   context?: string;
@@ -27,6 +36,7 @@ function pinnedHttpRequest(
     throw new Error(`${options?.context ?? "request"} must use HTTP or HTTPS, got ${parsed.protocol}`);
   }
   const context = options?.context ?? "request";
+  const connectTimeoutMs = options?.connectTimeoutMs;
   const idleTimeoutMs = options?.idleTimeoutMs ?? 60_000;
   const maxBytes = options?.maxBytes;
   const headers = new Headers(options?.headers);
@@ -44,8 +54,15 @@ function pinnedHttpRequest(
     }
 
     let settled = false;
+    let req: ClientRequest | undefined;
+    let connectTimer: ReturnType<typeof setTimeout> | undefined;
+    const clearConnectTimer = () => {
+      if (connectTimer !== undefined) clearTimeout(connectTimer);
+      connectTimer = undefined;
+    };
     const fail = (error: unknown) => {
-      try { req.destroy(); } catch { /* ignore */ }
+      clearConnectTimer();
+      try { req?.destroy(); } catch { /* ignore */ }
       if (settled) return;
       settled = true;
       reject(error instanceof Error ? error : new Error(String(error)));
@@ -83,6 +100,7 @@ function pinnedHttpRequest(
     };
 
     const onResponse = (response: IncomingMessage) => {
+      clearConnectTimer();
       const status = response.statusCode ?? 0;
       const responseHeaders = new Headers();
       for (const [key, value] of Object.entries(response.headers)) {
@@ -96,7 +114,7 @@ function pinnedHttpRequest(
 
       if (status < 200 || status >= 300) {
         try { response.destroy(); } catch { /* ignore */ }
-        try { req.destroy(); } catch { /* ignore */ }
+        try { req?.destroy(); } catch { /* ignore */ }
         if (settled) return;
         settled = true;
         resolve(new Response(null, { status, headers: responseHeaders }));
@@ -131,7 +149,7 @@ function pinnedHttpRequest(
           });
         },
         cancel() {
-          req.destroy();
+          req?.destroy();
         },
       });
 
@@ -141,15 +159,26 @@ function pinnedHttpRequest(
     };
 
     const requestFn = parsed.protocol === "https:" ? https.request : http.request;
-    const req = requestFn(requestOptions, onResponse);
+    req = requestFn(requestOptions, onResponse);
     const onAbort = () => fail(signal?.reason instanceof Error ? signal.reason : new Error("aborted"));
     signal?.addEventListener("abort", onAbort, { once: true });
+    req.on("socket", (socket) => {
+      if (!socket.connecting || connectTimeoutMs === undefined) return;
+      const connectedEvent = parsed.protocol === "https:" ? "secureConnect" : "connect";
+      connectTimer = setTimeout(() => fail(new PinnedHttpError("connect_timeout", `${context} connect timed out`)), connectTimeoutMs);
+      socket.once(connectedEvent, clearConnectTimer);
+      socket.once("error", clearConnectTimer);
+      socket.once("close", clearConnectTimer);
+    });
     req.setTimeout(idleTimeoutMs, () => fail(new Error(`${context} timed out`)));
     req.on("error", error => {
       signal?.removeEventListener("abort", onAbort);
       fail(error);
     });
-    req.on("close", () => signal?.removeEventListener("abort", onAbort));
+    req.on("close", () => {
+      clearConnectTimer();
+      signal?.removeEventListener("abort", onAbort);
+    });
     req.end(body);
   });
 }
@@ -179,4 +208,4 @@ export function pinnedHttpPost(
   options?: PinnedHttpRequestOptions,
 ): Promise<Response> {
   return pinnedHttpRequest(url, pinned, "POST", body, signal, options);
-}
+}

package/src/oauth/index.ts

@@ -740,6 +740,11 @@ const OAUTH_RECONCILE_FIELDS: (keyof OcxProviderConfig)[] = [
   "autoToolChoiceOnlyModels",
   "preserveReasoningContentModels",
 ];
+// `requiresReasoningPlaceholderModels` is deliberately NOT reconciled here: no
+// OAuth preset seeds it, so the delete-when-preset-undefined branch would wipe
+// an explicit user opt-out (`[]`) on every startup. Registry seeds still reach
+// existing rows through enrichProviderFromRegistry, which is fill-only and
+// preserves explicit saved values.
 
 const GOOGLE_ANTIGRAVITY_PROVIDER = "google-antigravity";
 const GOOGLE_ANTIGRAVITY_LIVE_DISCOVERY_VERSION = 2 as const;
@@ -883,6 +888,12 @@ export function upsertOAuthProvider(config: OcxConfig, provider: string): void {
   if (existing?.commandCodeVersion !== undefined) {
     next.commandCodeVersion = existing.commandCodeVersion;
   }
+  // User-configured price overlays are operator data, not preset state; a
+  // re-login, add-account, or reauth must not silently drop them from the
+  // Logs/Usage estimates.
+  if (existing?.modelCosts !== undefined) {
+    next.modelCosts = existing.modelCosts;
+  }
   if (existing && getProviderRegistryEntry(provider)?.allowKeyAuthOverride === true) {
     // Shared sanitizeApiKeyValue trim / no-CRLF checks from api-key pool writes.
     let storedApiKey = sanitizeApiKeyValue(existing.apiKey);
@@ -1174,8 +1185,16 @@ export function getLoginStatus(provider: string): { loggedIn: boolean; email?: s
     ...(a.needsReauth ? { needsReauth: true } : {}),
     expiresAt: a.credential.expires,
   }));
+
+  // A stored credential counts as "logged in" when it exists and is not marked for
+  // re-authentication. An expired access token with a valid refresh token is still
+  // logged in: request resolution refreshes expired/near-expiry credentials lazily.
+  // Invalid/unknown local-import expiries are handled at parse/adoption time
+  // (local-token-detect.ts), never by over-reporting login state here.
+  const activeNeedsReauth = set?.accounts
+    .find(a => a.id === set.activeAccountId)?.needsReauth === true;
   return {
-    loggedIn: !!cred,
+    loggedIn: !!cred && !activeNeedsReauth,
     email: maskEmail(cred?.email) ?? undefined,
     source: cred?.source,
     error: st?.error,

package/src/oauth/local-token-detect.ts

@@ -24,7 +24,10 @@ export function detectGrokCliToken(): OAuthCredentials | null {
 
     const accessToken = entry.key as string;
     const refreshToken = entry.refresh_token as string;
-    const expiresAt = entry.expires_at ? new Date(entry.expires_at as string).getTime() : 0;
+    const parsedExpiresAt = entry.expires_at ? new Date(entry.expires_at as string).getTime() : 0;
+    // Guard against unparseable/NaN expiries: a non-finite value must never be treated as
+    // "valid forever". Unknown → 0, which forces the refresh-validation path downstream.
+    const expiresAt = Number.isFinite(parsedExpiresAt) ? parsedExpiresAt : 0;
 
     return {
       refresh: refreshToken,
@@ -55,6 +58,9 @@ export function shouldAdoptGrokGeneration(
   now = Date.now(),
   refreshSkewMs = 60_000,
 ): boolean {
+  // A non-finite disk expiry means we cannot reason about the generation: the credential is
+  // either garbage or unknown. Treat it as requiring refresh validation, never as an upgrade.
+  if (!Number.isFinite(disk.expires)) return false;
   if (disk.expires <= now + refreshSkewMs) return false;
   const bothExpiriesExist = stored.expires > 0 && disk.expires > 0;
   if (bothExpiriesExist) return disk.expires >= stored.expires;
@@ -108,7 +114,10 @@ export function parseClaudeOauthPayload(raw: string): OAuthCredentials | null {
     const data = JSON.parse(raw) as { claudeAiOauth?: { accessToken?: string; refreshToken?: string; expiresAt?: number } };
     const o = data.claudeAiOauth;
     if (!o?.accessToken || !o?.refreshToken) return null;
-    return { access: o.accessToken, refresh: o.refreshToken, expires: o.expiresAt ?? 0, source: "local-cli" };
+    // Number.isFinite guard: a string/NaN expiresAt must not flow into downstream time
+    // comparisons as a "valid forever" value. Unknown → 0 (refresh-validation path).
+    const expires = typeof o.expiresAt === "number" && Number.isFinite(o.expiresAt) ? o.expiresAt : 0;
+    return { access: o.accessToken, refresh: o.refreshToken, expires, source: "local-cli" };
   } catch {
     return null;
   }