@juspay/neurolink 12.7.3 → 12.7.4

package/dist/cli/commands/proxy.js

@@ -24,7 +24,7 @@ import { formatUptime, isProcessRunning, StateFileManager, } from "../utils/serv
 import { configureProxyKeepAliveDispatcher } from "../../proxy/proxyDispatcher.js";
 import { ProxyRuntimeConfigStore } from "../../proxy/runtimeConfig.js";
 import { startProxyLogCleanupScheduler } from "../../proxy/logCleanupScheduler.js";
-import { anthropicAccountKeysEqual, createAccountAllowlist, ENV_ANTHROPIC_ACCOUNT_KEY, isAccountAllowed, LEGACY_ANTHROPIC_ACCOUNT_KEY, normalizeAnthropicAccountKey, shouldLoadFallbackCredential, } from "../../proxy/accountSelection.js";
+import { anthropicAccountKeysEqual, createAccountAllowlist, isAccountAllowed, LEGACY_ANTHROPIC_ACCOUNT_KEY, normalizeAnthropicAccountKey, shouldLoadFallbackCredential, } from "../../proxy/accountSelection.js";
 import { resolveProxyStatusAccountIdentity } from "../../proxy/codexAccountUsage.js";
 import { beginProxyRequest, getProxyActivitySnapshot, trackProxyResponse, } from "../../proxy/proxyActivity.js";
 import { flushProxyLifecycleEvents, getProxyLifecycleLoggerSnapshot, hashProxyLifecycleSessionId, logProxyLifecycleEvent, } from "../../proxy/proxyLifecycle.js";
@@ -66,11 +66,9 @@ const gatedShareRequests = new WeakSet();
 const PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS = 5_000;
 /** How long shutdown waits on the share listener before moving on. */
 const SHARE_LISTENER_CLOSE_TIMEOUT_MS = 10_000;
-const LEGACY_STATUS_ACCOUNT_CACHE_TTL_MS = 5_000;
 const PROXY_STATUS_TOKEN_READ_TIMEOUT_MS = 2_000;
 const PROXY_STATUS_RECONCILE_TIMEOUT_MS = 750;
 const PROXY_STATUS_ACCOUNT_INVENTORY_TIMEOUT_MS = 750;
-let legacyStatusAccountCache;
 // Allowed drift between a pid's OS-reported start time and the persisted
 // ProxySupervisorState.startTime before processLooksLikeProxySupervisor
 // treats it as a confident mismatch (recycled pid). Generous on purpose:
@@ -386,34 +384,6 @@ async function resolveStatusPrimaryAccount(proxyConfig) {
         source: "fallback",
     };
 }
-async function resolveLegacyStatusAccountLabel(storedAnthropicAccountCount) {
-    if (storedAnthropicAccountCount !== 0) {
-        return null;
-    }
-    const credentialsPath = join(homedir(), ".neurolink", "anthropic-credentials.json");
-    const now = Date.now();
-    if (legacyStatusAccountCache?.credentialsPath === credentialsPath &&
-        legacyStatusAccountCache.expiresAt > now) {
-        return legacyStatusAccountCache.label;
-    }
-    let label = null;
-    try {
-        const { readFile } = await import("node:fs/promises");
-        const parsed = JSON.parse(await readFile(credentialsPath, "utf8"));
-        if (parsed.oauth?.accessToken) {
-            label = parsed.email?.trim() || "legacy-default";
-        }
-    }
-    catch {
-        label = null;
-    }
-    legacyStatusAccountCache = {
-        credentialsPath,
-        expiresAt: now + LEGACY_STATUS_ACCOUNT_CACHE_TTL_MS,
-        label,
-    };
-    return label;
-}
 function deriveAccountAllowance(accountKey, now, allowlist, expirations, cooldowns) {
     const allowed = isAccountAllowed(accountKey, allowlist);
     const expiresAt = expirations.get(accountKey);
@@ -1067,6 +1037,7 @@ function redactStatusAccounts(rows, allowed) {
     return rows.map((row, index) => ({
         ...row,
         label: `account-${index + 1}`,
+        ...(row.key !== undefined ? { key: null } : {}),
         ...(row.email !== undefined ? { email: null } : {}),
     }));
 }
@@ -1686,21 +1657,28 @@ export async function createProxyStartApp(params) {
             logger.debug(`[proxy] /status using empty cooldown snapshot: ${error instanceof Error ? error.message : String(error)}`);
             return {};
         });
-        const storedAccountKeys = new Set();
+        const storedAnthropicAccountKeys = new Set();
+        const storedCodexAccountKeys = new Set();
         const storedAccountExpirations = new Map();
-        const disabledAccountKeys = new Set();
         const disabledProviderAccountKeys = new Set();
         let accountInventoryLoaded = false;
         try {
             const { tokenStore } = await import("../../auth/tokenStore.js");
-            const storedKeys = await withTimeout(tokenStore.listByPrefix("anthropic:"), PROXY_STATUS_ACCOUNT_INVENTORY_TIMEOUT_MS, "[proxy] /status account enumeration timed out");
-            for (const key of storedKeys) {
-                storedAccountKeys.add(normalizeAnthropicAccountKey(key));
+            const [anthropicKeys, codexKeys] = await withTimeout(Promise.all([
+                tokenStore.listByPrefix("anthropic:"),
+                tokenStore.listByPrefix("codex:"),
+            ]), PROXY_STATUS_ACCOUNT_INVENTORY_TIMEOUT_MS, "[proxy] /status account enumeration timed out");
+            for (const key of anthropicKeys) {
+                storedAnthropicAccountKeys.add(normalizeAnthropicAccountKey(key));
+            }
+            for (const key of codexKeys) {
+                storedCodexAccountKeys.add(key);
             }
             // Once account names are known, preserve them even when optional token
             // metadata is slow. That keeps the status table useful and avoids
             // incorrectly presenting known accounts as removed.
             accountInventoryLoaded = true;
+            const storedKeys = [...anthropicKeys, ...codexKeys];
             const inventory = await withTimeout((async () => {
                 const tokenExpirations = await Promise.all(storedKeys.map(async (key) => {
                     try {
@@ -1717,20 +1695,21 @@ export async function createProxyStartApp(params) {
             })(), PROXY_STATUS_ACCOUNT_INVENTORY_TIMEOUT_MS, "[proxy] /status account metadata timed out");
             for (const expiration of inventory.tokenExpirations) {
                 if (expiration) {
-                    storedAccountExpirations.set(normalizeAnthropicAccountKey(expiration[0]), expiration[1]);
+                    const key = expiration[0].startsWith("anthropic:")
+                        ? normalizeAnthropicAccountKey(expiration[0])
+                        : expiration[0];
+                    storedAccountExpirations.set(key, expiration[1]);
                 }
             }
             for (const key of inventory.disabledKeys) {
-                disabledAccountKeys.add(normalizeAnthropicAccountKey(key));
-                disabledProviderAccountKeys.add(key);
+                disabledProviderAccountKeys.add(key.startsWith("anthropic:")
+                    ? normalizeAnthropicAccountKey(key)
+                    : key);
             }
         }
         catch (err) {
             logger.debug(`[proxy] /status: failed to resolve account cooldown labels: ${err instanceof Error ? err.message : String(err)}`);
         }
-        const legacyAccountLabel = accountInventoryLoaded
-            ? await withTimeout(resolveLegacyStatusAccountLabel(storedAccountKeys.size), PROXY_STATUS_ACCOUNT_INVENTORY_TIMEOUT_MS, "[proxy] /status legacy account inspection timed out").catch(() => null)
-            : null;
         const now = Date.now();
         const health = buildProxyHealthResponse(readiness, {
             strategy: activeStrategy,
@@ -1744,52 +1723,54 @@ export async function createProxyStartApp(params) {
             source: "fallback",
         }));
         const activeUpdaterPid = supervisorState?.updaterPid ?? runtimeState?.updaterPid;
-        const accountRows = Object.values(stats.accounts).map((account) => {
-            const identity = resolveProxyStatusAccountIdentity(account.label, account.type);
+        const accountRows = Object.entries(stats.accounts).map(([persistedMapKey, account]) => {
+            // Legacy snapshots used their bare map key as an inferred identity. Do
+            // not map those old rows to a provider based on an email: the same email
+            // can be present in both pools. New records carry account.key.
+            const persistedKey = account.key ?? null;
+            const identity = persistedKey
+                ? resolveProxyStatusAccountIdentity(account.label, account.type, persistedKey)
+                : { provider: "other", key: null };
+            const isLegacyUnattributed = persistedKey === null &&
+                (account.type === "oauth" ||
+                    account.type === "api_key" ||
+                    account.type === "codex-oauth");
             const isAnthropicAccount = identity.provider === "anthropic";
             const isCodexAccount = identity.provider === "codex";
-            const normalizedKey = identity.provider === "anthropic" ? identity.key : null;
-            const isLegacyAccount = isAnthropicAccount && account.label === legacyAccountLabel;
-            const accountKey = isAnthropicAccount
-                ? storedAccountKeys.has(normalizedKey ?? "")
-                    ? normalizedKey
-                    : isLegacyAccount
-                        ? LEGACY_ANTHROPIC_ACCOUNT_KEY
-                        : account.label === "env"
-                            ? ENV_ANTHROPIC_ACCOUNT_KEY
-                            : normalizedKey
-                : identity.key;
-            const isStored = isAnthropicAccount &&
-                accountKey !== null &&
-                (storedAccountKeys.has(accountKey) || isLegacyAccount);
-            const { allowed, expired, cooling } = isAnthropicAccount && accountKey !== null
+            const accountKey = identity.key ?? (persistedKey || persistedMapKey);
+            const isStored = (isAnthropicAccount && storedAnthropicAccountKeys.has(accountKey)) ||
+                (isCodexAccount && storedCodexAccountKeys.has(accountKey));
+            const providerState = isAnthropicAccount
                 ? deriveAccountAllowance(accountKey, now, activeAccountAllowlist, storedAccountExpirations, cooldowns)
-                : {
-                    allowed: true,
-                    expired: false,
-                    cooling: accountKey !== null &&
-                        (cooldowns[accountKey]?.coolingUntil ?? 0) > now,
-                };
-            const isDisabled = (isAnthropicAccount &&
-                accountKey !== null &&
-                disabledAccountKeys.has(accountKey)) ||
-                (isCodexAccount &&
-                    accountKey !== null &&
-                    disabledProviderAccountKeys.has(accountKey));
+                : isCodexAccount
+                    ? {
+                        allowed: true,
+                        expired: (storedAccountExpirations.get(accountKey) ?? 0) > 0 &&
+                            (storedAccountExpirations.get(accountKey) ?? 0) <= now,
+                        cooling: (cooldowns[accountKey]?.coolingUntil ?? 0) > now,
+                    }
+                    : { allowed: true, expired: false, cooling: false };
+            const isDisabled = !isLegacyUnattributed && disabledProviderAccountKeys.has(accountKey);
             const accountStatus = account.type === "internal"
                 ? "internal"
-                : isDisabled
-                    ? "disabled"
-                    : isAnthropicAccount && expired
-                        ? "expired"
-                        : isAnthropicAccount && !allowed
-                            ? "excluded"
-                            : accountInventoryLoaded && isAnthropicAccount && !isStored
-                                ? "removed"
-                                : cooling
-                                    ? "cooling"
-                                    : "active";
+                : isLegacyUnattributed
+                    ? "unattributed"
+                    : isDisabled
+                        ? "disabled"
+                        : providerState.expired
+                            ? "expired"
+                            : isAnthropicAccount && !providerState.allowed
+                                ? "excluded"
+                                : accountInventoryLoaded &&
+                                    (isAnthropicAccount || isCodexAccount) &&
+                                    !isStored
+                                    ? "removed"
+                                    : providerState.cooling
+                                        ? "cooling"
+                                        : "active";
             return {
+                key: isLegacyUnattributed ? null : accountKey,
+                provider: isLegacyUnattributed ? "unknown" : identity.provider,
                 label: account.label,
                 type: account.type,
                 attempts: account.attemptCount,
@@ -1800,21 +1781,26 @@ export async function createProxyStartApp(params) {
                 rateLimits: account.rateLimitCount,
                 transientRateLimits: account.transientRateLimitCount,
                 quotaRateLimits: account.quotaRateLimitCount,
-                cooling,
+                cooling: providerState.cooling,
                 status: accountStatus,
-                allowed: account.type === "internal" ? undefined : allowed,
-                expired: isAnthropicAccount ? expired : undefined,
+                allowed: account.type === "internal" ? undefined : providerState.allowed,
+                expired: isAnthropicAccount || isCodexAccount
+                    ? providerState.expired
+                    : undefined,
             };
         });
-        const representedAccountKeys = new Set(accountRows
-            .filter((account) => account.type === "oauth" || account.type === "api_key")
-            .map((account) => normalizeAnthropicAccountKey(account.label)));
-        for (const accountKey of storedAccountKeys) {
+        const representedAccountKeys = new Set(accountRows.flatMap((account) => account.key &&
+            (account.provider === "anthropic" || account.provider === "codex")
+            ? [account.key]
+            : []));
+        for (const accountKey of storedAnthropicAccountKeys) {
             if (representedAccountKeys.has(accountKey)) {
                 continue;
             }
             const { allowed, expired, cooling } = deriveAccountAllowance(accountKey, now, activeAccountAllowlist, storedAccountExpirations, cooldowns);
             accountRows.push({
+                key: accountKey,
+                provider: "anthropic",
                 label: accountKey.slice("anthropic:".length),
                 type: "oauth",
                 attempts: 0,
@@ -1826,7 +1812,7 @@ export async function createProxyStartApp(params) {
                 transientRateLimits: 0,
                 quotaRateLimits: 0,
                 cooling,
-                status: disabledAccountKeys.has(accountKey)
+                status: disabledProviderAccountKeys.has(accountKey)
                     ? "disabled"
                     : expired
                         ? "expired"
@@ -1839,6 +1825,38 @@ export async function createProxyStartApp(params) {
                 expired,
             });
         }
+        for (const accountKey of storedCodexAccountKeys) {
+            if (representedAccountKeys.has(accountKey)) {
+                continue;
+            }
+            const expiresAt = storedAccountExpirations.get(accountKey);
+            const expired = expiresAt !== undefined && expiresAt > 0 && expiresAt <= now;
+            const cooling = (cooldowns[accountKey]?.coolingUntil ?? 0) > now;
+            accountRows.push({
+                key: accountKey,
+                provider: "codex",
+                label: accountKey.slice("codex:".length),
+                type: "codex-oauth",
+                attempts: 0,
+                requests: 0,
+                success: 0,
+                errors: 0,
+                attemptErrors: 0,
+                rateLimits: 0,
+                transientRateLimits: 0,
+                quotaRateLimits: 0,
+                cooling,
+                status: disabledProviderAccountKeys.has(accountKey)
+                    ? "disabled"
+                    : expired
+                        ? "expired"
+                        : cooling
+                            ? "cooling"
+                            : "active",
+                allowed: true,
+                expired,
+            });
+        }
         const attributed = accountRows.reduce((total, account) => ({
             attempts: total.attempts + (account.attempts ?? 0),
             requests: total.requests + (account.requests ?? 0),
@@ -3031,7 +3049,8 @@ function printStatusStats(stats) {
         if (lastError) {
             const cause = lastError.errorType ?? lastError.category;
             const code = lastError.errorCode ? `/${lastError.errorCode}` : "";
-            const account = lastError.account ? ` account=${lastError.account}` : "";
+            const accountIdentity = lastError.accountKey ?? lastError.account;
+            const account = accountIdentity ? ` account=${accountIdentity}` : "";
             console.info(`    Last error:  ${new Date(lastError.at).toISOString()} ${cause}${code} status=${lastError.status}${account}`);
             if (lastError.message) {
                 console.info(`    Last cause:  ${sanitizeProxyStatusTerminalErrorMessage(lastError.message)}`);

package/dist/cli/factories/authCommandFactory.js

@@ -6,10 +6,8 @@
  * - login, logout, status, refresh: Anthropic OAuth (API key + OAuth)
  * - providers, validate, health: Multi-provider auth management
  */
-/**
- * Supported providers for authentication
- */
-const SUPPORTED_PROVIDERS = ["anthropic", "codex"];
+/** Providers with first-class credential flows in `neurolink auth`. */
+const AUTH_LOGIN_PROVIDERS = ["anthropic", "codex"];
 /**
  * Auth Command Factory
  *
@@ -167,7 +165,7 @@ export class AuthCommandFactory {
             .positional("provider", {
             type: "string",
             description: "AI provider to authenticate with",
-            choices: SUPPORTED_PROVIDERS,
+            choices: AUTH_LOGIN_PROVIDERS,
             demandOption: true,
         })
             .option("method", {
@@ -204,7 +202,7 @@ export class AuthCommandFactory {
             .positional("provider", {
             type: "string",
             description: "AI provider to log out from",
-            choices: SUPPORTED_PROVIDERS,
+            choices: AUTH_LOGIN_PROVIDERS,
             demandOption: true,
         })
             .example("$0 auth logout anthropic", "Clear all Anthropic credentials");
@@ -217,7 +215,7 @@ export class AuthCommandFactory {
             .positional("provider", {
             type: "string",
             description: "AI provider to check (optional, shows all if not specified)",
-            choices: SUPPORTED_PROVIDERS,
+            choices: AUTH_LOGIN_PROVIDERS,
         })
             .example("$0 auth status", "Show status for all configured providers")
             .example("$0 auth status anthropic", "Show Anthropic authentication status")
@@ -231,7 +229,7 @@ export class AuthCommandFactory {
             .positional("provider", {
             type: "string",
             description: "AI provider to refresh tokens for",
-            choices: SUPPORTED_PROVIDERS,
+            choices: AUTH_LOGIN_PROVIDERS,
             demandOption: true,
         })
             .example("$0 auth refresh anthropic", "Refresh Anthropic OAuth tokens");
@@ -244,7 +242,7 @@ export class AuthCommandFactory {
             .option("refresh", {
             type: "boolean",
             default: false,
-            description: "Fetch fresh limits from Anthropic for all OAuth accounts before listing (via the running proxy when available)",
+            description: "Refresh available provider limits for authenticated accounts; show unsupported providers explicitly",
         })
             .example("$0 auth list", "List all authenticated accounts")
             .example("$0 auth list --format json", "List accounts in JSON format")
@@ -257,8 +255,7 @@ export class AuthCommandFactory {
         return yargs
             .positional("provider", {
             type: "string",
-            description: "AI provider to remove account from",
-            choices: SUPPORTED_PROVIDERS,
+            description: "Provider namespace to remove an account from",
             demandOption: true,
         })
             .option("label", {

package/dist/proxy/codexAccountUsage.d.ts

@@ -12,7 +12,7 @@ export declare const CODEX_ACCOUNT_PREFIX = "codex:";
 /** Keep an account label in the Codex namespace used by its token store. */
 export declare function normalizeCodexAccountKey(value: string): string;
 /** Resolve the provider-qualified key used to render a proxy status row. */
-export declare function resolveProxyStatusAccountIdentity(label: string, type: string): CodexProxyStatusAccountIdentity;
+export declare function resolveProxyStatusAccountIdentity(label: string, type: string, persistedKey?: string): CodexProxyStatusAccountIdentity;
 /** Enumerate Codex OAuth accounts from the token store for usage refresh. */
 export declare function listCodexAccountsForUsage(): Promise<ProxyPassthroughAccount[]>;
 /** Normalise a Codex rate-limit block into the shared AccountQuota shape. */

package/dist/proxy/codexAccountUsage.js

@@ -19,7 +19,19 @@ export function normalizeCodexAccountKey(value) {
         : `${CODEX_ACCOUNT_PREFIX}${trimmed}`;
 }
 /** Resolve the provider-qualified key used to render a proxy status row. */
-export function resolveProxyStatusAccountIdentity(label, type) {
+export function resolveProxyStatusAccountIdentity(label, type, persistedKey) {
+    // Current counter snapshots persist the provider-qualified key. Prefer it
+    // over the display type so a future type rename cannot move an account into
+    // the wrong cooldown/disabled namespace.
+    if (persistedKey?.toLowerCase().startsWith("anthropic:")) {
+        return {
+            provider: "anthropic",
+            key: normalizeAnthropicAccountKey(persistedKey),
+        };
+    }
+    if (persistedKey?.startsWith(CODEX_ACCOUNT_PREFIX)) {
+        return { provider: "codex", key: persistedKey };
+    }
     if (type === "oauth" || type === "api_key") {
         return { provider: "anthropic", key: normalizeAnthropicAccountKey(label) };
     }

package/dist/proxy/proxyActivity.js

@@ -63,6 +63,13 @@ export function trackProxyResponse(response, finishRequest, observer) {
     let observedBodyBytes = 0;
     let responseChunks = 0;
     let settled = false;
+    let sourceClosed = false;
+    // A framework can cancel its adapter after the upstream stream has already
+    // closed. Snapshot reader.closed before cancel() so that normal cleanup is
+    // not recorded as a client-aborted request.
+    void reader.closed.then(() => {
+        sourceClosed = true;
+    }, () => undefined);
     const settle = (outcome) => {
         if (settled) {
             return;
@@ -100,7 +107,11 @@ export function trackProxyResponse(response, finishRequest, observer) {
             }
         },
         async cancel(reason) {
-            settle("client_cancelled");
+            // Read the state before cancelling: reader.cancel() itself rejects the
+            // closed promise for a genuinely active source, which is too late to
+            // distinguish it from a source that had already ended normally.
+            await Promise.resolve();
+            settle(sourceClosed ? "completed" : "client_cancelled");
             await withTimeout(reader.cancel(reason), PROXY_RESPONSE_CANCEL_TIMEOUT_MS, "Timed out cancelling the upstream proxy response");
         },
     });

package/dist/proxy/usageStats.d.ts

@@ -40,7 +40,7 @@ export declare class ProxyUsageStatsStore {
     recordAttemptError(accountLabel: string, accountType: string, status: number, rateLimitKind?: "transient" | "quota"): void;
     recordFinalError(status: number, accountLabel?: string, accountType?: string, details?: ProxyTerminalErrorDetails): void;
     getStats(): ProxyStats;
-    getAccountStats(label: string): AccountStats | undefined;
+    getAccountStats(label: string, type?: string): AccountStats | undefined;
     getTerminalErrors(): ProxyTerminalErrorJournal;
     getUsageSnapshot(): ProxyUsageStatsSnapshot;
     getPersistenceStatus(): ProxyStatsPersistenceStatus;
@@ -81,7 +81,7 @@ export declare function getStats(): ProxyStats;
 export declare function getUsageSnapshot(): ProxyUsageStatsSnapshot;
 export declare function getReconciledStats(): Promise<ProxyStats>;
 export declare function getReconciledUsageSnapshot(): Promise<ProxyUsageStatsSnapshot>;
-export declare function getAccountStats(label: string): AccountStats | undefined;
+export declare function getAccountStats(label: string, type?: string): AccountStats | undefined;
 export declare function getTerminalErrors(): ProxyTerminalErrorJournal;
 export declare function getUsageStatsPersistenceStatus(): ProxyStatsPersistenceStatus;
 export declare function flushUsageStats(): Promise<void>;

package/dist/proxy/usageStats.js

@@ -8,6 +8,7 @@
 import { randomUUID } from "node:crypto";
 import { mkdir, open, readFile, readdir, rename, rm, stat, } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
+import { normalizeAnthropicAccountKey } from "./accountSelection.js";
 import { AsyncMutex } from "../utils/asyncMutex.js";
 import { redactUrlsInText, sanitizeForLog } from "../utils/logSanitize.js";
 import { writeJsonSnapshotAtomically } from "./snapshotPersistence.js";
@@ -63,6 +64,34 @@ function emptyTerminalErrorJournal(startedAt) {
         recent: [],
     };
 }
+/**
+ * Statistics must never use an email/label as their primary map key. One
+ * person can authenticate both provider pools with the same email, and a
+ * bare key silently merged their attempts, limits, and failures into one row.
+ *
+ * Keep non-account pseudo rows (passthrough, peer, internal) untouched. The
+ * display label remains separate so the CLI stays readable while persisted
+ * counters retain a collision-proof identity.
+ */
+function resolveStatsAccountIdentity(label, type) {
+    if (type === "codex-oauth") {
+        const key = label.startsWith("codex:") ? label : `codex:${label}`;
+        return {
+            key,
+            label: label.startsWith("codex:") ? label.slice("codex:".length) : label,
+        };
+    }
+    if (type === "oauth" || type === "api_key") {
+        const key = normalizeAnthropicAccountKey(label);
+        return {
+            key,
+            label: label.startsWith("anthropic:")
+                ? label.slice("anthropic:".length)
+                : label,
+        };
+    }
+    return { key: label, label };
+}
 function cloneTerminalErrorSummary(summary) {
     return { ...summary };
 }
@@ -152,6 +181,9 @@ function terminalErrorCategory(status, errorType) {
 }
 function createTerminalErrorSummary(args) {
     const { now, status, accountLabel, accountType, details } = args;
+    const accountIdentity = accountLabel && accountType
+        ? resolveStatsAccountIdentity(accountLabel, accountType)
+        : undefined;
     const errorType = clipTerminalErrorField(details?.errorType);
     const message = details?.message
         ? stripTerminalErrorControlCharacters(sanitizeForLog(redactUrlsInText(details.message), MAX_TERMINAL_ERROR_MESSAGE_LENGTH + MAX_TERMINAL_ERROR_FIELD_LENGTH))
@@ -170,6 +202,11 @@ function createTerminalErrorSummary(args) {
         ...(clipTerminalErrorField(accountLabel)
             ? { account: clipTerminalErrorField(accountLabel) }
             : {}),
+        ...(clipTerminalErrorField(details?.accountKey ?? accountIdentity?.key)
+            ? {
+                accountKey: clipTerminalErrorField(details?.accountKey ?? accountIdentity?.key),
+            }
+            : {}),
         ...(clipTerminalErrorField(accountType)
             ? { accountType: clipTerminalErrorField(accountType) }
             : {}),
@@ -201,7 +238,9 @@ function mergeAccountStats(left, right) {
     if (!left) {
         return cloneAccount(right);
     }
+    const key = right.key ?? left.key;
     return {
+        ...(key ? { key } : {}),
         label: right.label || left.label,
         type: right.type || left.type,
         attemptCount: left.attemptCount + right.attemptCount,
@@ -248,7 +287,9 @@ function validAccountStats(value) {
         return false;
     }
     const candidate = value;
-    return (typeof candidate.label === "string" &&
+    return ((candidate.key === undefined ||
+        (typeof candidate.key === "string" && candidate.key.length > 0)) &&
+        typeof candidate.label === "string" &&
         typeof candidate.type === "string" &&
         finiteNonNegativeInteger(candidate.attemptCount) &&
         finiteNonNegativeInteger(candidate.attemptErrorCount) &&
@@ -282,7 +323,7 @@ function validStats(value) {
         typeof candidate.accounts !== "object") {
         return false;
     }
-    return Object.entries(candidate.accounts).every(([label, account]) => validAccountStats(account) && label === account.label);
+    return Object.entries(candidate.accounts).every(([key, account]) => validAccountStats(account) && key === (account.key ?? account.label));
 }
 function validOptionalString(value, maxLength) {
     return (value === undefined ||
@@ -302,6 +343,7 @@ function validTerminalErrorSummary(value) {
         TERMINAL_ERROR_CATEGORIES.includes(candidate.category) &&
         validOptionalString(candidate.requestId, MAX_TERMINAL_ERROR_FIELD_LENGTH) &&
         validOptionalString(candidate.account, MAX_TERMINAL_ERROR_FIELD_LENGTH) &&
+        validOptionalString(candidate.accountKey, MAX_TERMINAL_ERROR_FIELD_LENGTH) &&
         validOptionalString(candidate.accountType, MAX_TERMINAL_ERROR_FIELD_LENGTH) &&
         validOptionalString(candidate.errorType, MAX_TERMINAL_ERROR_FIELD_LENGTH) &&
         validOptionalString(candidate.errorCode, MAX_TERMINAL_ERROR_FIELD_LENGTH) &&
@@ -615,8 +657,20 @@ export class ProxyUsageStatsStore {
     getStats() {
         return cloneStats(this.stats);
     }
-    getAccountStats(label) {
-        const account = this.stats.accounts[label];
+    getAccountStats(label, type) {
+        const direct = this.stats.accounts[label];
+        if (direct) {
+            return cloneAccount(direct);
+        }
+        const identity = type
+            ? resolveStatsAccountIdentity(label, type)
+            : undefined;
+        const account = identity
+            ? this.stats.accounts[identity.key]
+            : (() => {
+                const matches = Object.values(this.stats.accounts).filter((candidate) => candidate.label === label);
+                return matches.length === 1 ? matches[0] : undefined;
+            })();
         return account ? cloneAccount(account) : undefined;
     }
     getTerminalErrors() {
@@ -920,9 +974,11 @@ export class ProxyUsageStatsStore {
         }
     }
     ensureAccount(target, label, type) {
-        if (!target.accounts[label]) {
-            target.accounts[label] = {
-                label,
+        const identity = resolveStatsAccountIdentity(label, type);
+        if (!target.accounts[identity.key]) {
+            target.accounts[identity.key] = {
+                key: identity.key,
+                label: identity.label,
                 type,
                 attemptCount: 0,
                 attemptErrorCount: 0,
@@ -934,7 +990,7 @@ export class ProxyUsageStatsStore {
                 lastAttemptAt: 0,
             };
         }
-        return target.accounts[label];
+        return target.accounts[identity.key];
     }
     scheduleFlush() {
         if (!this.filePath || this.flushTimer) {
@@ -1131,8 +1187,8 @@ export async function getReconciledStats() {
 export async function getReconciledUsageSnapshot() {
     return defaultStore.reconcileUsageSnapshot();
 }
-export function getAccountStats(label) {
-    return defaultStore.getAccountStats(label);
+export function getAccountStats(label, type) {
+    return defaultStore.getAccountStats(label, type);
 }
 export function getTerminalErrors() {
     return defaultStore.getTerminalErrors();

package/dist/server/routes/claudeProxyRoutes.d.ts

@@ -65,7 +65,8 @@ declare function planCooldownFor429(quota: AccountQuota | null, retryAfterMs: nu
 declare function reconcileCooldownFromQuota(state: RuntimeAccountState, quota: AccountQuota, now: number, policy?: ProxyOveragePolicy): ProxyQuotaCooldownUpdate;
 /**
  * Seed each account's runtime quota from the persisted snapshots in
- * ~/.neurolink/account-quotas.json (keyed by label). Runtime state is
+ * ~/.neurolink/account-quotas.json (keyed by provider-qualified account key).
+ * Runtime state is
  * in-memory only, so without this the quota-aware ordering is blind after a
  * proxy restart: all accounts tie, selection falls back to token-store
  * enumeration order, and the first account served becomes self-reinforcing