@bitkyc08/opencodex 2.76.0 → 2.77.0

package/src/grok/session-identity.ts

@@ -0,0 +1,33 @@
+/**
+ * Grok Build sends its conversation identity as `x-grok-conv-id` (and the same value as the body
+ * `prompt_cache_key`), but never the `session_id` header Codex clients send. The ChatGPT Codex
+ * backend only reuses a warmed prompt prefix for requests that carry `session_id`, and opencodex
+ * reads the same header for thread affinity and conversation logging. Without it, every Grok turn
+ * routed to an OpenAI model was a cold `new_bind` with near-zero cached input.
+ *
+ * Only the managed Grok surface (`x-opencodex-grok: 1`, written by `ocx` into Grok's config) is
+ * promoted, and an explicit caller session header always wins.
+ */
+const GROK_SURFACE_HEADER = "x-opencodex-grok";
+const GROK_CONVERSATION_HEADER = "x-grok-conv-id";
+const SESSION_HEADERS = ["session_id", "session-id", "thread-id"] as const;
+// Grok emits UUIDs and `turn-summary-<uuid>`; anything else is not promoted.
+const SAFE_CONVERSATION_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+
+export function grokConversationSessionId(headers: Headers): string | undefined {
+  if (headers.get(GROK_SURFACE_HEADER) !== "1") return undefined;
+  if (SESSION_HEADERS.some(name => headers.has(name))) return undefined;
+  const conversationId = headers.get(GROK_CONVERSATION_HEADER)?.trim();
+  if (!conversationId || !SAFE_CONVERSATION_ID.test(conversationId)) return undefined;
+  return conversationId;
+}
+
+/** Returns `req` unchanged unless a Grok conversation id can stand in for the missing `session_id`. */
+export function withGrokSessionIdentity(req: Request): Request {
+  const sessionId = grokConversationSessionId(req.headers);
+  if (!sessionId) return req;
+  const headers = new Headers(req.headers);
+  headers.set("session_id", sessionId);
+  // The clone keeps the unread body stream and the caller's abort signal.
+  return new Request(req, { headers });
+}

package/src/integrations/catalog-refresh.ts

@@ -11,7 +11,7 @@ import {
 /** Refresh only previously connected clients; a refused file never blocks its peers. */
 export async function refreshOwnedCatalogIntegrations(
   input: Omit<OwnedIntegrationRefreshInput, "clientId">,
-  clientIds: readonly IntegrationClientId[] = ["pi", "aside", "raycast", "omo", "droid"],
+  clientIds: readonly IntegrationClientId[] = ["pi", "aside", "raycast", "omo", "droid", "opencode", "kilo"],
 ): Promise<OwnedIntegrationRefreshOutcome[]> {
   // Client files are shared with the live proxy a sibling instance runs beside; their entries
   // point at the owner's port, and refreshing them here would re-point them at this one.

package/src/integrations/mutation-plan.ts

@@ -36,7 +36,7 @@ import {
 } from "./registry";
 import { declaredIntegrationTarget, resolveIntegrationTarget, type IntegrationTarget } from "./target";
 import { shouldInjectApiAuthHeader } from "../codex/inject";
-import { classifyIntegration, exportContextOf, readPath, type IntegrationState, type StateReason } from "./state";
+import { buildIntegrationContribution, classifyIntegration, exportContextOf, readPath, type IntegrationState, type StateReason } from "./state";
 import { inspectKiloCandidates } from "./kilo-candidates";
 import { InvalidSelectorError } from "./merge";
 import { createIntegrationStateStore, type IntegrationStateStore } from "./store";
@@ -791,6 +791,8 @@ export interface IntegrationWriteInput {
   models: readonly ExportModel[];
   config: OcxConfig;
   port: number;
+  /** Explicit Droid-only defaults; omitted means retain matching owned rows. */
+  droidReasoningDefaults?: Record<string, string>;
   env?: NodeJS.ProcessEnv;
   home?: string;
   store?: IntegrationStateStore;
@@ -936,13 +938,13 @@ export function observeIntegration(
    * reads a different document there, and a write in the config file's shape
    * would be as unread as a write to the config file itself.
    */
-  const contribution = effective.buildContribution(exportContextOf(input));
   // A record proves ownership of the file it was written FOR. Matching only by
   // client id let a record for one home authorize a write to another whose
   // bytes happened to hash the same — which deleted a config we never touched.
   const record = stored && stored.clientId === clientId && stored.configPath === configPath
     ? stored
     : null;
+  const contribution = buildIntegrationContribution(input, effective, parsed, record);
   if (clientId === "droid" && input.models.length > 0 && contribution.fragments.length === 0 && !record) {
     return { failed: observationFailure("unsafe", "unsafe", "Factory Droid has no addressable models in the selected catalog") } as const;
   }

package/src/integrations/state.ts

@@ -10,7 +10,7 @@
  */
 import { createClineIO } from "./cline-io";
 import { parseClineDocument } from "./cline-document";
-import { ClientPathError, EXPORT_CLIENTS, opencodeProxyBaseUrl, type ExportModel, type ManagedContribution } from "../clients/config-export";
+import { ClientPathError, EXPORT_CLIENTS, opencodeProxyBaseUrl, droidDefaultsFromOwnedRows, type ExportModel, type ManagedContribution } from "../clients/config-export";
 import type { ConfigFormat } from "../clients/config-export";
 import type { OcxConfig } from "../types";
 import { PARSE_FAILED, loadTarget, parseConfig, type IntegrationIO } from "./config-io";
@@ -449,6 +449,7 @@ export interface IntegrationStateInput {
   models: readonly ExportModel[];
   config: OcxConfig;
   port: number;
+  droidReasoningDefaults?: Record<string, string>;
   env?: NodeJS.ProcessEnv;
   home?: string;
   /** The whole integration state store, bound to one root. */
@@ -462,7 +463,8 @@ export function exportContextOf(input: {
   models: readonly ExportModel[];
   config: OcxConfig;
   port: number;
-}): { baseUrl: string; models: readonly ExportModel[]; config: OcxConfig } {
+  droidReasoningDefaults?: Record<string, string>;
+}): { baseUrl: string; models: readonly ExportModel[]; config: OcxConfig; droidReasoningDefaults?: Record<string, string> } {
   return {
     /*
      * Composed through the SAME helper `ocx export` uses. Interpolating the
@@ -476,9 +478,41 @@ export function exportContextOf(input: {
     baseUrl: opencodeProxyBaseUrl(input.port, input.config.hostname, input.config),
     models: input.models,
     config: input.config,
+    ...(input.droidReasoningDefaults === undefined ? {} : { droidReasoningDefaults: input.droidReasoningDefaults }),
   };
 }
 
+export function buildIntegrationContribution(
+  input: IntegrationStateInput,
+  effective: IntegrationTarget,
+  parsed: unknown,
+  record: OwnershipRecord | null,
+): ManagedContribution {
+  const context = exportContextOf(input);
+  if (input.clientId === "droid" && input.droidReasoningDefaults === undefined && record?.configPath === effective.configPath) {
+    const inherited = recordedDroidContributionMatches(parsed, record)
+      ? droidDefaultsFromOwnedRows(context, parsed, record.fragmentPaths)
+      : {};
+    if (Object.keys(inherited).length > 0) context.droidReasoningDefaults = inherited;
+  }
+  return effective.buildContribution(context);
+}
+
+function recordedDroidContributionMatches(document: unknown, record: OwnershipRecord): boolean {
+  try {
+    const fragments = record.fragmentPaths.flatMap(path => {
+      const value = readPath(document, path);
+      return value === undefined ? [] : [{ path, value }];
+    });
+    if (fragments.length !== record.fragmentPaths.length) return false;
+    const observed: ManagedContribution = { clientId: "droid", fragments };
+    return record.semanticBlockFingerprint === fingerprint(semanticContribution(observed))
+      || record.blockFingerprint === fingerprint(canonicalContribution(observed));
+  } catch {
+    return false;
+  }
+}
+
 let retriedThisProcess = false;
 
 /**
@@ -535,9 +569,7 @@ export function readIntegrationState(input: IntegrationStateInput): IntegrationS
   try {
     // One resolution for both, so a client whose paths come from mutable state
     // cannot report one account's install beside another account's config path.
-    const context = exportContextOf(input);
-    const paths = input.resolvedPaths ?? resolveIntegrationPaths(input.clientId, input.env, input.home, context);
-    if (input.clientId === "droid" && input.resolvedPaths) assertDroidPathsUnambiguous(paths.detectDir, context);
+    const paths = resolveStatePaths(input);
     installed = io.statKind(paths.detectDir) === "dir";
     if (input.clientId === "cline") io = createClineIO(io, paths.configPath, store);
     /*
@@ -608,7 +640,7 @@ export function readIntegrationState(input: IntegrationStateInput): IntegrationS
   const parsed = input.clientId === "cline"
     ? parseClineDocument(loaded.before)
     : parseConfig(loaded.before, effective.format, EXPORT_CLIENTS[input.clientId].jsonc ? { jsonc: true } : undefined);
-  const contribution = effective.buildContribution(exportContextOf(input));
+  const contribution = buildIntegrationContribution(input, effective, parsed, record);
   if (input.clientId === "droid" && input.models.length > 0 && contribution.fragments.length === 0
     && (!record || record.configPath !== configPath)) {
     return { clientId: input.clientId, state: "unsafe", installed, configPath,
@@ -650,3 +682,33 @@ export function readIntegrationState(input: IntegrationStateInput): IntegrationS
     ...retention,
   };
 }
+
+function resolveStatePaths(input: IntegrationStateInput): { configPath: string; detectDir: string } {
+  const context = exportContextOf(input);
+  const paths = input.resolvedPaths ?? resolveIntegrationPaths(input.clientId, input.env, input.home, context);
+  if (input.clientId === "droid" && input.resolvedPaths) assertDroidPathsUnambiguous(paths.detectDir, context);
+  return paths;
+}
+
+export function readOwnedDroidReasoningDefaults(input: IntegrationStateInput): Record<string, string> {
+  if (input.clientId !== "droid") return {};
+  const store = input.store ?? createIntegrationStateStore();
+  const io = input.io ?? store.io();
+  try {
+    const paths = resolveStatePaths(input);
+    const record = store.readRecords().droid;
+    if (!record || record.clientId !== "droid" || record.configPath !== paths.configPath) return {};
+    const effective = resolveIntegrationTarget({
+      clientId: "droid", configPath: paths.configPath, io, record, env: input.env, home: input.home,
+    });
+    const loaded = loadTarget(io, effective.configPath);
+    if (!loaded.ok) return {};
+    const parsed = parseConfig(loaded.before, "json");
+    if (parsed === PARSE_FAILED) return {};
+    if (!recordedDroidContributionMatches(parsed, record)) return {};
+    return droidDefaultsFromOwnedRows(exportContextOf(input), parsed, record.fragmentPaths);
+  } catch (error) {
+    if (error instanceof ClientPathError) return {};
+    throw error;
+  }
+}

package/src/integrations/writer.ts

@@ -18,7 +18,7 @@ import { shouldInjectApiAuthHeader } from "../codex/inject";
 import { detachedConfigSnapshot } from "../config/admitted-identity";
 import { copyPlainData } from "../lib/plain-data";
 import type { OcxConfig } from "../types";
-import { defaultIntegrationIO, loadTarget, type IntegrationIO } from "./config-io";
+import { defaultIntegrationIO, loadTarget, parseConfig, type IntegrationIO } from "./config-io";
 import { inspectKiloCandidates } from "./kilo-candidates";
 import {
   fingerprint,
@@ -43,7 +43,7 @@ import {
   type IntegrationClientId,
 } from "./registry";
 import { declaredIntegrationTarget } from "./target";
-import { exportContextOf } from "./state";
+import { buildIntegrationContribution, exportContextOf } from "./state";
 import type { IntegrationState } from "./state";
 import { serializeDocument, UnserializableValueError } from "./serialize";
 import { ClientPathError } from "../clients/config-export";
@@ -713,7 +713,11 @@ export function restoreIntegration(input: IntegrationRestoreInput): WriteOutcome
   // exact bytes when the snapshot was taken. Re-deriving it from the file would
   // mean guessing which entries are ours, and a wrong guess deletes a user's.
   const restoredRecord = entry.priorRecord;
-  const fresh = rowTarget.buildContribution(exportContextOf(input));
+  const fresh = buildIntegrationContribution(
+    { ...input, droidReasoningDefaults: undefined }, rowTarget,
+    clientId === "droid" && restoredText !== null ? parseConfig(restoredText, "json") : undefined,
+    restoredRecord,
+  );
   /*
    * Does the restored record actually describe the restored bytes?
    *
@@ -812,6 +816,12 @@ function freezeIntegrationInput(input: IntegrationWriteInput): FrozenIntegration
   if (!models.ok) {
     throw new UncopyableIntegrationInputError("the model roster could not be captured for this write");
   }
+  const droidReasoningDefaults = input.droidReasoningDefaults === undefined
+    ? undefined
+    : copyPlainData(input.droidReasoningDefaults);
+  if (droidReasoningDefaults !== undefined && !droidReasoningDefaults.ok) {
+    throw new UncopyableIntegrationInputError("Droid reasoning defaults could not be captured for this write");
+  }
   /*
    * One resolution for both paths. Aside derives them from the account id in
    * its manifest, so two independent calls could verify one account's install
@@ -828,7 +838,11 @@ function freezeIntegrationInput(input: IntegrationWriteInput): FrozenIntegration
    * checked in one state and written from another, which is the substitution the fingerprint
    * exists to prevent. Copying both here gives the plan and the document one input.
    */
-  return { ...input, config, models: models.value, env, home, store, io, resolvedPaths };
+  return {
+    ...input, config, models: models.value,
+    ...(droidReasoningDefaults === undefined ? {} : { droidReasoningDefaults: droidReasoningDefaults.value }),
+    env, home, store, io, resolvedPaths,
+  };
 }
 
 function tryFreezeIntegrationInput(input: IntegrationWriteInput):

package/src/lib/gui-pair-capability.ts

@@ -65,6 +65,23 @@ export function canonicalHttpOrigin(value: unknown): string | null {
   }
 }
 
+/**
+ * Standalone pairing is only for this process's configured literal loopback origin.
+ * No CORS entry, public hub URL, wildcard bind, alias or client role can widen it.
+ * The CLI separately checks the attested runtime's actual port before requesting a grant.
+ */
+export function standaloneGuiPairingOrigin(config: {
+  runtimeRole?: string;
+  hostname?: string;
+  port: number;
+}): string | null {
+  if ((config.runtimeRole ?? "standalone") !== "standalone") return null;
+  const hostname = config.hostname ?? "127.0.0.1";
+  if (hostname !== "127.0.0.1" && hostname !== "::1") return null;
+  if (!Number.isInteger(config.port) || config.port < 1 || config.port > 65535) return null;
+  return new URL(`http://${hostname === "::1" ? "[::1]" : hostname}:${config.port}`).origin;
+}
+
 function capabilityPayload(
   nonce: string,
   method: string,

package/src/lib/provider-client-headers.ts

@@ -0,0 +1,62 @@
+const HEADER_NAME_PATTERN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+const BLOCKED_FORWARDED_CLIENT_HEADERS = new Set([
+  "authorization",
+  "chatgpt-account-id",
+  "connection",
+  "content-length",
+  "content-type",
+  "cookie",
+  "expect",
+  "host",
+  "keep-alive",
+  "proxy-authorization",
+  "proxy-connection",
+  "set-cookie",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "x-amz-security-token",
+  "x-api-key",
+  "api-key",
+  "x-goog-api-key",
+  "x-oai-attestation",
+]);
+
+const ALLOWED_FORWARDED_CLIENT_HEADERS = new Set([
+  "originator", "x-client-request-id", "x-codex-app-version", "user-agent",
+]);
+const MAX_FORWARDED_CLIENT_HEADERS = 64;
+
+/** Normalize one opt-in caller header while refusing credential and transport-owned fields. */
+export function normalizeForwardedClientHeaderName(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const name = value.trim().toLowerCase();
+  if (!name || !HEADER_NAME_PATTERN.test(name) || !ALLOWED_FORWARDED_CLIENT_HEADERS.has(name)) return null;
+  return name;
+}
+
+/** Validate provider.forwardClientHeaders without ever admitting credential-bearing headers. */
+export function providerForwardClientHeadersConfigError(value: unknown): string | null {
+  if (value === undefined) return null;
+  if (!Array.isArray(value)) return "forwardClientHeaders must be an array of header names";
+  if (value.length > MAX_FORWARDED_CLIENT_HEADERS) {
+    return `forwardClientHeaders must contain at most ${MAX_FORWARDED_CLIENT_HEADERS} names`;
+  }
+  const seen = new Set<string>();
+  for (const raw of value) {
+    if (typeof raw !== "string" || !raw.trim() || !HEADER_NAME_PATTERN.test(raw.trim())) {
+      return "forwardClientHeaders must use valid HTTP header names";
+    }
+    const name = raw.trim().toLowerCase();
+    if (BLOCKED_FORWARDED_CLIENT_HEADERS.has(name)) {
+      return `forwardClientHeaders must not include credential or transport-owned header "${raw.trim()}"`;
+    }
+    if (!ALLOWED_FORWARDED_CLIENT_HEADERS.has(name)) {
+      return "forwardClientHeaders must use the supported client metadata allowlist";
+    }
+    if (seen.has(name)) return `forwardClientHeaders must not repeat header "${raw.trim()}"`;
+    seen.add(name);
+  }
+  return null;
+}

package/src/oauth/anthropic-continuity.ts

@@ -0,0 +1,65 @@
+import { detectClaudeCodeToken, hasClaudeCredentialContinuity } from "./local-token-detect";
+import { normalizeAnthropicIdentity, resolveAnthropicAccountIdentity, type AnthropicIdentityResolver } from "./anthropic-identity";
+import { credentialGeneration, type AuthStore } from "./store";
+import { REFRESH_SKEW_MS } from "./refresh-policy";
+import type { OAuthCredentials, ProviderAccountSet } from "./types";
+
+export type ClaudeCredentialObservation =
+  | { kind: "absent" }
+  | { kind: "unresolved" | "different"; diskGeneration: string }
+  | { kind: "adopt"; credential: OAuthCredentials; diskGeneration: string };
+
+export async function newerClaudeCredential(
+  stored: OAuthCredentials, now: number, signal?: AbortSignal,
+  resolveIdentity: AnthropicIdentityResolver = resolveAnthropicAccountIdentity,
+): Promise<ClaudeCredentialObservation> {
+  if (stored.source !== "local-cli") return { kind: "absent" };
+  const disk = detectClaudeCodeToken();
+  if (!disk || !Number.isFinite(disk.expires) || disk.expires <= now + REFRESH_SKEW_MS
+    || credentialGeneration(disk) === credentialGeneration(stored)) return { kind: "absent" };
+  const diskGeneration = credentialGeneration(disk);
+  const before = normalizeAnthropicIdentity(stored.anthropicIdentity, stored.access);
+  if (hasClaudeCredentialContinuity(stored, disk)) {
+    return { kind: "adopt", diskGeneration: credentialGeneration(disk), credential: {
+      ...stored, ...disk, anthropicIdentity: disk.access === stored.access ? before : undefined,
+    } };
+  }
+  // Independent observations share a deadline through the caller signal; neither extends the other.
+  const [oldProof, newProof] = await Promise.all([
+    before ?? resolveIdentity(stored.access, signal), resolveIdentity(disk.access, signal),
+  ]);
+  const oldIdentity = normalizeAnthropicIdentity(oldProof, stored.access);
+  const newIdentity = normalizeAnthropicIdentity(newProof, disk.access);
+  if (!oldIdentity || !newIdentity) return { kind: "unresolved", diskGeneration };
+  if (oldIdentity.accountUuid !== newIdentity.accountUuid) return { kind: "different", diskGeneration };
+  return { kind: "adopt", diskGeneration: credentialGeneration(disk), credential: {
+    ...stored, ...disk, accountId: newIdentity.accountUuid, anthropicIdentity: newIdentity,
+  } };
+}
+
+/** Capture primitives before network awaits; check them again inside the serialized writer. */
+export function captureAnthropicCredentialOwner(set: ProviderAccountSet, accountId: string) {
+  const row = set.accounts.find(account => account.id === accountId)!;
+  const loginId = row.loginId;
+  const generation = credentialGeneration(row.credential);
+  const metadata = identityMetadata(row.credential);
+  const needsReauth = row.needsReauth;
+  const selection = { id: set.activeAccountId, revision: set.selectionRevision };
+  return (store: AuthStore, diskGeneration?: string, allowPaused = false): boolean => {
+    const current = store["anthropic"];
+    const account = current?.accounts.find(candidate => candidate.id === accountId);
+    if (!account || (!allowPaused && account.paused) || account.loginId !== loginId
+      || account.needsReauth !== needsReauth || credentialGeneration(account.credential) !== generation
+      || identityMetadata(account.credential) !== metadata) return false;
+    if (diskGeneration !== undefined) {
+      if (current?.activeAccountId !== selection.id || current?.selectionRevision !== selection.revision) return false;
+      const disk = detectClaudeCodeToken();
+      if (!disk || disk.expires <= Date.now() + REFRESH_SKEW_MS || credentialGeneration(disk) !== diskGeneration) return false;
+    }
+    return true;
+  };
+}
+
+function identityMetadata(credential: OAuthCredentials): string {
+  return JSON.stringify([credential.source, credential.accountId, credential.email, credential.anthropicIdentity]);
+}

package/src/oauth/anthropic-identity.ts

@@ -0,0 +1,75 @@
+/** Private account proof from an authenticated Anthropic response, bound to its exact bearer. */
+import { hasClaudeCredentialContinuity } from "./local-token-detect";
+import { createHash } from "node:crypto";
+import { readBoundedResponseBody } from "../lib/bounded-body";
+import { CLAUDE_CLI_USER_AGENT } from "../providers/claude-cli-identity";
+import type { OAuthCredentials } from "./types";
+
+const PROFILE_URL = "https://api.anthropic.com/api/oauth/profile";
+const PROFILE_TIMEOUT_MS = 10_000;
+const PROFILE_MAX_BYTES = 65_536;
+export type AnthropicIdentity = NonNullable<OAuthCredentials["anthropicIdentity"]>;
+export type AnthropicIdentityResolver = (access: string, signal?: AbortSignal) => Promise<AnthropicIdentity | undefined>;
+
+export function bindAnthropicIdentity(access: string, accountUuid: unknown): AnthropicIdentity | undefined {
+  if (!access || typeof accountUuid !== "string" || !accountUuid.length || accountUuid.length > 128
+    || accountUuid !== accountUuid.trim() || /[\x00-\x1f\x7f]/.test(accountUuid)) return undefined;
+  return { v: 1, accountUuid, bearerSha256: createHash("sha256").update(access).digest("hex") };
+}
+
+export function normalizeAnthropicIdentity(value: unknown, access: string): AnthropicIdentity | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const proof = value as Partial<AnthropicIdentity>;
+  const bound = bindAnthropicIdentity(access, proof.accountUuid);
+  return proof.v === 1 && bound && proof.bearerSha256 === bound.bearerSha256 ? bound : undefined;
+}
+
+/** Fixed destination, no redirects, bounded body and deadline; failures never include response data. */
+export const resolveAnthropicAccountIdentity: AnthropicIdentityResolver = async (access, signal) => {
+  if (!access || signal?.aborted) return undefined;
+  const deadline = AbortSignal.timeout(PROFILE_TIMEOUT_MS);
+  const combined = signal ? AbortSignal.any([signal, deadline]) : deadline;
+  try {
+    const response = await fetch(PROFILE_URL, {
+      method: "GET", redirect: "error", signal: combined,
+      headers: { Authorization: `Bearer ${access}`, Accept: "application/json",
+        "anthropic-beta": "oauth-2025-04-20",
+        "Cache-Control": "no-cache", "User-Agent": CLAUDE_CLI_USER_AGENT },
+    });
+    if (!response.ok || response.redirected) {
+      void response.body?.cancel().catch(() => {});
+      return undefined;
+    }
+    const body = await readBoundedResponseBody(response, {
+      signal: combined, maxBytes: PROFILE_MAX_BYTES, fatalUtf8: true,
+      totalTimeoutMs: PROFILE_TIMEOUT_MS, inactivityTimeoutMs: PROFILE_TIMEOUT_MS,
+    });
+    if (body.truncated || body.oversized || body.timedOut || combined.aborted) return undefined;
+    const data: unknown = JSON.parse(body.text);
+    if (!data || typeof data !== "object" || !("account" in data)) return undefined;
+    const account = data.account;
+    return account && typeof account === "object" && "uuid" in account
+      ? bindAnthropicIdentity(access, account.uuid) : undefined;
+  } catch {
+    // Unavailable identity is an explicit unresolved result, never an ownership guess.
+    return undefined;
+  }
+};
+
+/** A changed access bearer cannot inherit the previous bearer's proof. */
+export function mergeAnthropicIdentity(fresh: OAuthCredentials, previous: OAuthCredentials): Pick<OAuthCredentials, "anthropicIdentity"> {
+  const before = normalizeAnthropicIdentity(previous.anthropicIdentity, previous.access);
+  const after = normalizeAnthropicIdentity(fresh.anthropicIdentity, fresh.access);
+  if (before && after && before.accountUuid !== after.accountUuid) {
+    throw new Error("Anthropic credential identity changed; explicit account login required");
+  }
+  return { anthropicIdentity: after ?? (fresh.access === previous.access ? before : undefined) };
+}
+
+/** Explicit imports enrich only a proven slot; labels and paths never establish ownership. */
+export function matchesAnthropicImport(stored: OAuthCredentials, imported: OAuthCredentials): boolean {
+  const before = normalizeAnthropicIdentity(stored.anthropicIdentity, stored.access);
+  const after = normalizeAnthropicIdentity(imported.anthropicIdentity, imported.access);
+  if (before && after) return before.accountUuid === after.accountUuid;
+  return hasClaudeCredentialContinuity(stored, imported);
+}

package/src/oauth/anthropic-routing.ts

@@ -18,6 +18,7 @@ import { anthropicFamilyRejected, anthropicFamilyRetryAt, anthropicModelExhauste
  * Token refresh failures retain the existing store needsReauth policy.
  */
 import { anthropicRatePauseUntil, clearAnthropicRatePauses, classifyAnthropic429, anthropicRetryAfterMs, pauseAnthropicRateAdmission } from "./anthropic-rate-limit-policy";
+import { REFRESH_SKEW_MS } from "./refresh-policy";
 import { createHash } from "node:crypto";
 import { captureOAuthAccountSelection, commitOAuthAccountSelection, credentialGeneration, getAccountSet, getAccountCredential, getAccountCredentialWithStatus } from "./store";
 import type { OAuthAccessSnapshot } from "./index";
@@ -353,7 +354,6 @@ function usageScore(config: OcxConfig, accountId: string, model?: string): numbe
   }
 }
 
-const TOKEN_SKEW_MS = 60_000;
 
 /** Background `local-cli` slots with expired access are not pool-eligible (identity adoption risk). */
 function isPoolCredentialUsable(accountId: string, now: number): boolean {
@@ -361,7 +361,7 @@ function isPoolCredentialUsable(accountId: string, now: number): boolean {
   if (!cred) return false;
   if (cred.source !== "local-cli") return true;
   if (canRefreshAnthropicPoolAccount(accountId)) return true;
-  return cred.expires > now + TOKEN_SKEW_MS;
+  return cred.expires > now + REFRESH_SKEW_MS;
 }
 
 export function getEligibleAnthropicAccounts(now = Date.now(), model?: string): string[] {
@@ -1093,7 +1093,7 @@ export async function getAnthropicPoolAccessToken(accountId: string): Promise<st
     const { OAuthLoginRequiredError } = await import("./index");
     throw new OAuthLoginRequiredError(PROVIDER);
   }
-  if (stored.expires > Date.now() + TOKEN_SKEW_MS) return stored.access;
+  if (stored.expires > Date.now() + REFRESH_SKEW_MS) return stored.access;
   if (!canRefreshAnthropicPoolAccount(accountId)) {
     throw new Error("background local-cli token expired; refuse CLI-adopting refresh for pool");
   }

package/src/oauth/anthropic.ts

@@ -1,5 +1,6 @@
 /** Anthropic OAuth flow (Claude Pro/Max). Ported from jawcode oauth/anthropic.ts. */
 import { OAuthCallbackFlow } from "./callback-server";
+import { bindAnthropicIdentity, resolveAnthropicAccountIdentity } from "./anthropic-identity";
 import { generatePKCE } from "./pkce";
 import type { LocalTokenImportMode, OAuthController, OAuthCredentials } from "./types";
 
@@ -96,6 +97,7 @@ function credsFrom(data: AnthropicTokenResponse, refreshFallback?: string): OAut
     refresh: data.refresh_token || refreshFallback || "",
     access: data.access_token,
     expires,
+    anthropicIdentity: bindAnthropicIdentity(data.access_token, accountUuid),
     accountId: typeof accountUuid === "string" && accountUuid.length > 0 ? accountUuid : undefined,
     email: typeof email === "string" && email.length > 0 ? email : undefined,
   };
@@ -159,7 +161,11 @@ export async function loginAnthropic(
     const local = detectClaudeCodeToken();
     if (local) {
       ctrl.onProgress?.("Found Claude Code token, importing automatically");
-      if (local.expires >= Date.now() + 60_000) return local;
+      if (local.expires >= Date.now() + 60_000) {
+        const identity = await resolveAnthropicAccountIdentity(local.access, ctrl.signal);
+        ctrl.signal?.throwIfAborted();
+        return { ...local, ...(identity ? { accountId: identity.accountUuid, anthropicIdentity: identity } : {}) };
+      }
       try {
         return { ...(await refreshAnthropicToken(local.refresh)), source: "local-cli" };
       } catch (error) {

package/src/oauth/generic-account-failover.ts

@@ -734,3 +734,24 @@ export function clearGenericFailoverHealth(providerName?: string): void {
     if (key.startsWith(`${providerName}\u0000`)) health.delete(key);
   }
 }
+
+/**
+ * Retire one account's superseded auth evidence after an explicit (re-)login. An
+ * auth cooldown recorded against the old grant must not hold out the fresh
+ * credential, so it leaves with the login rather than lingering until its
+ * deadline. Rate, quota, and suspension evidence is preserved: a re-login says
+ * nothing about those verdicts, and dropping them would make a throttled account
+ * eligible early. Entries bound to the still-current generation stay as well.
+ */
+export function clearGenericFailoverHealthForAccount(providerName: string, accountId: string): void {
+  const live = getAccountSet(providerName)?.accounts.find(row => row.id === accountId);
+  const current = live ? credentialGeneration(live.credential) : undefined;
+  const bare = `${providerName}\u0000${accountId}`;
+  for (const key of [...health.keys()]) {
+    if (key !== bare && !key.startsWith(`${bare}\u0000`)) continue;
+    const entry = health.get(key);
+    if (!entry || entry.cooldownSource !== "auth") continue;
+    if (current !== undefined && entry.identity === current) continue;
+    health.delete(key);
+  }
+}