@cortexkit/anthropic-auth-core 1.15.1 → 1.17.0

package/dist/accounts.js

@@ -5,6 +5,7 @@ import { dirname, join } from 'node:path';
 import { parseRetryAfterHeader, refreshClaudeOAuthToken } from "./auth.js";
 import { CACHE_1H_MODES, CLAUDE_CODE_VERSION, DEFAULT_CACHE_1H_MODE, } from "./constants.js";
 import { log, logger } from "./logger.js";
+import { tokenFingerprint } from "./token-fingerprint.js";
 const setRefreshLockRenewalTimeout = globalThis.setTimeout.bind(globalThis);
 const clearRefreshLockRenewalTimeout = globalThis.clearTimeout.bind(globalThis);
 export const ACCOUNT_FILE_NAME = 'anthropic-auth.json';
@@ -124,6 +125,28 @@ function normalizeAccount(value) {
         lastRefreshError: normalizeOperationError(value.lastRefreshError),
         lastQuotaRefreshError: normalizeOperationError(value.lastQuotaRefreshError),
         quota: normalizeQuota(value.quota),
+        profile: normalizeOAuthAccountProfile(value.profile),
+    };
+}
+function normalizeOAuthAccountProfile(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (typeof value.tier !== 'string' ||
+        !value.tier.trim() ||
+        typeof value.orgType !== 'string' ||
+        !value.orgType.trim() ||
+        typeof value.checkedAt !== 'number' ||
+        !Number.isFinite(value.checkedAt)) {
+        return undefined;
+    }
+    return {
+        tier: value.tier.trim(),
+        orgType: value.orgType.trim(),
+        checkedAt: value.checkedAt,
+        ...(typeof value.tokenFingerprint === 'string' &&
+            value.tokenFingerprint.trim() && {
+            tokenFingerprint: value.tokenFingerprint.trim(),
+        }),
     };
 }
 function normalizeOperationError(value) {
@@ -220,8 +243,56 @@ function normalizeQuota(value) {
         // — only inputs that already carried an array reach this line.
         quota.scoped = scoped;
     }
+    if (isRecord(value.extraUsage)) {
+        const used = normalizeQuotaMoney(value.extraUsage.used);
+        const limit = normalizeQuotaMoney(value.extraUsage.limit);
+        if (used && limit && typeof value.extraUsage.exhausted === 'boolean') {
+            quota.extraUsage = {
+                used,
+                limit,
+                ...(typeof value.extraUsage.utilizationPercent === 'number' &&
+                    Number.isFinite(value.extraUsage.utilizationPercent) && {
+                    utilizationPercent: value.extraUsage.utilizationPercent,
+                }),
+                ...(typeof value.extraUsage.severity === 'string' && {
+                    severity: value.extraUsage.severity,
+                }),
+                exhausted: value.extraUsage.exhausted,
+            };
+        }
+    }
+    if (typeof value.bindingWindow === 'string' && value.bindingWindow.trim()) {
+        quota.bindingWindow = value.bindingWindow.trim();
+    }
+    if (value.bindingWindowSource === 'poll' ||
+        value.bindingWindowSource === 'headers') {
+        quota.bindingWindowSource = value.bindingWindowSource;
+    }
+    if (typeof value.fallbackAdvised === 'boolean') {
+        quota.fallbackAdvised = value.fallbackAdvised;
+    }
+    if (value.source === 'poll' || value.source === 'headers') {
+        quota.source = value.source;
+    }
     return Object.keys(quota).length ? quota : undefined;
 }
+function normalizeQuotaMoney(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (typeof value.amountMinor !== 'number' ||
+        !Number.isFinite(value.amountMinor) ||
+        typeof value.currency !== 'string' ||
+        !value.currency.trim() ||
+        typeof value.exponent !== 'number' ||
+        !Number.isFinite(value.exponent)) {
+        return undefined;
+    }
+    return {
+        amountMinor: value.amountMinor,
+        currency: value.currency.trim(),
+        exponent: value.exponent,
+    };
+}
 // Fresh empty storage shell — main OpenCode OAuth account, no fallback
 // accounts. Returns a new object each call so mutating callers don't alias.
 export function createEmptyStorage() {
@@ -236,7 +307,11 @@ function normalizeStorage(value) {
         return null;
     return {
         version: 1,
-        main: { type: 'opencode', provider: 'anthropic' },
+        main: {
+            type: 'opencode',
+            provider: 'anthropic',
+            profile: normalizeOAuthAccountProfile(isRecord(value.main) ? value.main.profile : undefined),
+        },
         routing: isRecord(value.routing) ? value.routing : undefined,
         fallbackOn: Array.isArray(value.fallbackOn)
             ? value.fallbackOn.filter((status) => Number.isInteger(status))
@@ -330,6 +405,11 @@ function mergeConfigAndState(configValue, stateValue) {
         : [];
     return {
         ...configValue,
+        main: {
+            type: 'opencode',
+            provider: 'anthropic',
+            profile: normalizeOAuthAccountProfile(mainState?.profile),
+        },
         refresh: objectWithDefinedEntries({
             ...refreshConfig,
             mainLastRefreshError: mainRefreshSource.lastRefreshError,
@@ -392,52 +472,127 @@ function accountRuntimeState(account) {
         lastRefreshError: account.lastRefreshError,
         lastQuotaRefreshError: account.lastQuotaRefreshError,
         quota: account.quota,
+        profile: account.profile,
     });
 }
 function quotaSnapshotCheckedAt(quota) {
     return Math.max(quota?.five_hour?.checkedAt ?? 0, quota?.seven_day?.checkedAt ?? 0, ...(quota?.scoped?.map((window) => window.checkedAt) ?? []), quota?.checkedAt ?? 0);
 }
+function quotaSourcePrecedence(quota) {
+    if (quota?.source === 'poll')
+        return 2;
+    if (quota?.source === 'headers')
+        return 1;
+    return 0;
+}
+function mergeHeaderScopedQuota(existing, incoming) {
+    if (!('scoped' in existing))
+        return incoming.scoped;
+    if (!Array.isArray(existing.scoped) || existing.scoped.length === 0) {
+        return existing.scoped;
+    }
+    if (!Array.isArray(incoming.scoped) || incoming.scoped.length === 0) {
+        return existing.scoped;
+    }
+    const merged = new Map(incoming.scoped.map((window) => [window.id, window]));
+    for (const window of existing.scoped) {
+        const candidate = merged.get(window.id);
+        if (!candidate || window.checkedAt >= candidate.checkedAt) {
+            merged.set(window.id, window);
+        }
+    }
+    return [...merged.values()];
+}
+function mergeHeaderOwnedWindow(existingSnapshot, incomingSnapshot, key) {
+    const existing = existingSnapshot[key];
+    const incoming = incomingSnapshot[key];
+    if (!incoming)
+        return existing;
+    if (!existing)
+        return incoming;
+    if (incoming.checkedAt > existing.checkedAt)
+        return incoming;
+    if (incoming.checkedAt < existing.checkedAt)
+        return existing;
+    return quotaSourcePrecedence(existingSnapshot) >
+        quotaSourcePrecedence(incomingSnapshot)
+        ? existing
+        : incoming;
+}
+function mergeHeaderQuotaForPersistence(existing, incoming) {
+    if (!existing || incoming.source !== 'headers')
+        return incoming;
+    const preservePollBinding = existing.bindingWindowSource === 'poll';
+    return {
+        ...existing,
+        ...incoming,
+        five_hour: mergeHeaderOwnedWindow(existing, incoming, 'five_hour'),
+        seven_day: mergeHeaderOwnedWindow(existing, incoming, 'seven_day'),
+        scoped: mergeHeaderScopedQuota(existing, incoming),
+        extraUsage: existing.extraUsage ?? incoming.extraUsage,
+        bindingWindow: preservePollBinding
+            ? existing.bindingWindow
+            : (incoming.bindingWindow ?? existing.bindingWindow),
+        bindingWindowSource: preservePollBinding
+            ? 'poll'
+            : (incoming.bindingWindowSource ?? existing.bindingWindowSource),
+    };
+}
 function mergeAccountRuntimeState(existing, incoming) {
     if (!isRecord(existing))
         return incoming;
     const existingEntry = existing;
-    const existingQuotaCheckedAt = quotaSnapshotCheckedAt(existingEntry.quota);
-    const incomingQuotaCheckedAt = quotaSnapshotCheckedAt(incoming.quota);
     const tokenChanged = Boolean((existingEntry.access &&
         incoming.access &&
         existingEntry.access !== incoming.access) ||
         (existingEntry.refresh &&
             incoming.refresh &&
             existingEntry.refresh !== incoming.refresh));
-    if (existingQuotaCheckedAt > incomingQuotaCheckedAt) {
+    const mergesHeaderQuota = Boolean(!tokenChanged && incoming.quota?.source === 'headers');
+    const effectiveIncoming = mergesHeaderQuota && incoming.quota
+        ? {
+            ...incoming,
+            quota: mergeHeaderQuotaForPersistence(existingEntry.quota, incoming.quota),
+        }
+        : incoming;
+    const existingQuotaCheckedAt = quotaSnapshotCheckedAt(existingEntry.quota);
+    const incomingQuotaCheckedAt = quotaSnapshotCheckedAt(effectiveIncoming.quota);
+    const existingQuotaWinsEqualTimestamp = Boolean(existingQuotaCheckedAt === incomingQuotaCheckedAt &&
+        quotaSourcePrecedence(existingEntry.quota) >
+            quotaSourcePrecedence(effectiveIncoming.quota));
+    if (!mergesHeaderQuota &&
+        (existingQuotaCheckedAt > incomingQuotaCheckedAt ||
+            existingQuotaWinsEqualTimestamp)) {
         const existingRefreshAt = existingEntry.lastRefreshedAt ?? 0;
-        const incomingRefreshAt = incoming.lastRefreshedAt ?? 0;
+        const incomingRefreshAt = effectiveIncoming.lastRefreshedAt ?? 0;
         if (tokenChanged && incomingRefreshAt <= existingRefreshAt) {
             const merged = { ...existingEntry };
-            if (typeof incoming.lastUsed === 'number' &&
+            if (typeof effectiveIncoming.lastUsed === 'number' &&
                 (!(typeof existingEntry.lastUsed === 'number') ||
-                    incoming.lastUsed > existingEntry.lastUsed)) {
-                merged.lastUsed = incoming.lastUsed;
+                    effectiveIncoming.lastUsed > existingEntry.lastUsed)) {
+                merged.lastUsed = effectiveIncoming.lastUsed;
             }
             return merged;
         }
-        const merged = { ...existingEntry, ...incoming };
+        const merged = {
+            ...existingEntry,
+            ...effectiveIncoming,
+        };
         if (tokenChanged) {
-            if ('quota' in incoming) {
-                merged.quota = existingEntry.quota;
-                if ('lastQuotaRefreshError' in existingEntry) {
-                    merged.lastQuotaRefreshError = existingEntry.lastQuotaRefreshError;
-                }
-                else {
-                    delete merged.lastQuotaRefreshError;
-                }
+            if (!('profile' in effectiveIncoming))
+                delete merged.profile;
+            if (effectiveIncoming.quota?.source) {
+                merged.quota = effectiveIncoming.quota;
             }
             else {
                 delete merged.quota;
+            }
+            if (!('lastQuotaRefreshError' in effectiveIncoming)) {
                 delete merged.lastQuotaRefreshError;
             }
-            if (!('lastRefreshError' in incoming))
+            if (!('lastRefreshError' in effectiveIncoming)) {
                 delete merged.lastRefreshError;
+            }
             return merged;
         }
         return {
@@ -446,11 +601,20 @@ function mergeAccountRuntimeState(existing, incoming) {
             lastQuotaRefreshError: existingEntry.lastQuotaRefreshError,
         };
     }
-    const merged = { ...existingEntry, ...incoming };
-    if (!('lastQuotaRefreshError' in incoming)) {
+    const merged = {
+        ...existingEntry,
+        ...effectiveIncoming,
+    };
+    if (tokenChanged) {
+        if (!('profile' in effectiveIncoming))
+            delete merged.profile;
+        if (!effectiveIncoming.quota?.source)
+            delete merged.quota;
+    }
+    if (!('lastQuotaRefreshError' in effectiveIncoming)) {
         delete merged.lastQuotaRefreshError;
     }
-    if (!('lastRefreshError' in incoming)) {
+    if (!('lastRefreshError' in effectiveIncoming)) {
         delete merged.lastRefreshError;
     }
     return merged;
@@ -475,7 +639,7 @@ function configFromStorage(storage) {
         : undefined;
     return omitUndefinedTopLevel({
         version: 1,
-        main: storage.main,
+        main: { type: 'opencode', provider: 'anthropic' },
         routing: storage.routing,
         fallbackOn: storage.fallbackOn,
         refresh,
@@ -517,32 +681,142 @@ async function writeJsonAtomic(path, value) {
         throw error;
     }
 }
-export function saveAccounts(storage, path = getAccountStoragePath()) {
-    const resolvedPath = path;
-    return enqueueSave(() => saveAccountsLocked(storage, resolvedPath));
-}
-async function saveAccountsLocked(storage, path) {
-    const existing = await loadExistingTopLevelFields(path);
-    const nextConfig = { ...existing, ...configFromStorage(storage) };
-    await writeJsonAtomic(path, nextConfig);
-    await saveAccountStateUnlocked(storage, path, {
-        mainQuota: true,
-        mainRefresh: true,
-        accounts: true,
+function sameAccountIdentity(left, right) {
+    return (left.id === right.id ||
+        Boolean(left.label && right.label && left.label === right.label));
+}
+function mergeAccountsForSave(existing, incoming, options) {
+    const removedIds = new Set(options.removedAccountIds ?? []);
+    const current = existing.filter((account) => !removedIds.has(account.id));
+    const next = incoming.filter((account) => !removedIds.has(account.id));
+    const missing = current.filter((account) => !next.some((candidate) => sameAccountIdentity(candidate, account)));
+    if (!missing.length)
+        return [...next];
+    if (options.preserveExistingAccountOrder === false) {
+        return [...next, ...missing];
+    }
+    const usedIncoming = new Set();
+    const merged = current.map((account) => {
+        const index = next.findIndex((candidate, candidateIndex) => !usedIncoming.has(candidateIndex) &&
+            sameAccountIdentity(candidate, account));
+        const candidate = next[index];
+        if (!candidate)
+            return account;
+        usedIncoming.add(index);
+        return candidate;
+    });
+    for (let index = 0; index < next.length; index++) {
+        const candidate = next[index];
+        if (!usedIncoming.has(index) && candidate)
+            merged.push(candidate);
+    }
+    return merged;
+}
+const ACCOUNT_CONFIG_LOCK_TTL_MS = 10_000;
+const ACCOUNT_CONFIG_LOCK_WAIT_MS = 12_000;
+const ACCOUNT_STATE_LOCK_TTL_MS = 10_000;
+const ACCOUNT_STATE_LOCK_WAIT_MS = 12_000;
+async function acquireAccountWriteLock(input) {
+    const { path, name, ttlMs, waitMs, description } = input;
+    await mkdir(dirname(path), { recursive: true });
+    const deadline = Date.now() + waitMs;
+    while (true) {
+        const lock = await acquireRefreshFileLock({
+            name,
+            ttlMs,
+            path,
+            renew: true,
+        });
+        if (lock)
+            return lock;
+        if (Date.now() >= deadline) {
+            throw new Error(`Timed out waiting for the account ${description} lock`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+}
+function acquireAccountConfigWriteLock(path) {
+    return acquireAccountWriteLock({
+        path,
+        name: 'config-write',
+        ttlMs: ACCOUNT_CONFIG_LOCK_TTL_MS,
+        waitMs: ACCOUNT_CONFIG_LOCK_WAIT_MS,
+        description: 'configuration write',
     });
 }
+function acquireAccountStateWriteLock(path) {
+    return acquireAccountWriteLock({
+        path,
+        name: 'state-write',
+        ttlMs: ACCOUNT_STATE_LOCK_TTL_MS,
+        waitMs: ACCOUNT_STATE_LOCK_WAIT_MS,
+        description: 'state write',
+    });
+}
+export function saveAccounts(storage, path = getAccountStoragePath(), options = {}) {
+    const resolvedPath = path;
+    return enqueueSave(() => saveAccountsLocked(storage, resolvedPath, options));
+}
+async function saveAccountsLocked(storage, path, options) {
+    const lock = await acquireAccountConfigWriteLock(path);
+    try {
+        const current = await loadAccounts(path);
+        const nextStorage = {
+            ...storage,
+            accounts: mergeAccountsForSave(current?.accounts ?? [], storage.accounts, options),
+        };
+        const existing = await loadExistingTopLevelFields(path);
+        const nextConfig = { ...existing, ...configFromStorage(nextStorage) };
+        await writeJsonAtomic(path, nextConfig);
+        // Config precedes state everywhere both locks are needed; reversing this
+        // order can deadlock profile mutations against full account saves.
+        const stateLock = await acquireAccountStateWriteLock(path);
+        try {
+            await saveAccountStateUnlocked(nextStorage, path, {
+                mainQuota: true,
+                mainRefresh: true,
+                accounts: true,
+            });
+        }
+        finally {
+            await stateLock.release();
+        }
+    }
+    finally {
+        await lock.release();
+    }
+}
+function applyMainProfileStatePatch(state, storage) {
+    state.main = state.main ?? {};
+    state.main.profile = storage.main?.profile;
+}
 function applyMainQuotaStatePatch(state, storage) {
     state.main = state.main ?? {};
+    const incomingQuota = storage.quota?.mainQuota;
+    const sameToken = Boolean(state.main.quotaToken &&
+        storage.quota?.mainQuotaToken &&
+        state.main.quotaToken === storage.quota.mainQuotaToken);
+    const effectiveIncomingQuota = sameToken && incomingQuota?.source === 'headers'
+        ? mergeHeaderQuotaForPersistence(state.main.quota, incomingQuota)
+        : incomingQuota;
+    const mergesHeaderQuota = Boolean(sameToken && incomingQuota?.source === 'headers');
     const existingCheckedAt = typeof state.main.quotaCheckedAt === 'number'
         ? state.main.quotaCheckedAt
         : quotaSnapshotCheckedAt(state.main.quota);
     const incomingCheckedAt = typeof storage.quota?.mainQuotaCheckedAt === 'number'
         ? storage.quota.mainQuotaCheckedAt
-        : quotaSnapshotCheckedAt(storage.quota?.mainQuota);
-    if (existingCheckedAt > incomingCheckedAt)
+        : quotaSnapshotCheckedAt(effectiveIncomingQuota);
+    if (!mergesHeaderQuota &&
+        (existingCheckedAt > incomingCheckedAt ||
+            (existingCheckedAt === incomingCheckedAt &&
+                quotaSourcePrecedence(state.main.quota) >
+                    quotaSourcePrecedence(effectiveIncomingQuota)))) {
         return;
-    state.main.quota = storage.quota?.mainQuota;
-    state.main.quotaCheckedAt = storage.quota?.mainQuotaCheckedAt;
+    }
+    state.main.quota = effectiveIncomingQuota;
+    state.main.quotaCheckedAt = mergesHeaderQuota
+        ? Math.max(existingCheckedAt, incomingCheckedAt)
+        : storage.quota?.mainQuotaCheckedAt;
     state.main.quotaToken = storage.quota?.mainQuotaToken;
     state.main.lastQuotaApiError = storage.quota?.mainLastQuotaApiError;
 }
@@ -563,12 +837,97 @@ function pruneUndefined(value) {
         .map(([key, entry]) => [key, pruneUndefined(entry)]));
 }
 export function saveAccountState(storage, path = getAccountStoragePath(), scope = {
+    mainProfile: true,
     mainQuota: true,
     mainRefresh: true,
     accounts: true,
 }) {
     const resolvedPath = path;
-    return enqueueSave(() => saveAccountStateUnlocked(storage, resolvedPath, scope));
+    return enqueueSave(async () => {
+        const lock = await acquireAccountStateWriteLock(resolvedPath);
+        try {
+            await saveAccountStateUnlocked(storage, resolvedPath, scope);
+        }
+        finally {
+            await lock.release();
+        }
+    });
+}
+export function saveOAuthProfileState(input, path = getAccountStoragePath()) {
+    const resolvedPath = path;
+    return enqueueSave(async () => {
+        const configLock = await acquireAccountConfigWriteLock(resolvedPath);
+        try {
+            const stateLock = await acquireAccountStateWriteLock(resolvedPath);
+            try {
+                const current = await loadAccounts(resolvedPath);
+                const statePath = getAccountStatePath(resolvedPath);
+                const existing = (await readJsonIfPresent(statePath)).value;
+                const next = isRecord(existing)
+                    ? { ...existing, version: 1 }
+                    : { version: 1 };
+                const { accountId, expectedTokenFingerprint, profile } = input;
+                if (profile?.tokenFingerprint &&
+                    profile.tokenFingerprint !== expectedTokenFingerprint) {
+                    return false;
+                }
+                if (accountId === 'main') {
+                    next.main = { ...(next.main ?? {}) };
+                    const existingProfile = normalizeOAuthAccountProfile(next.main.profile);
+                    const persistedToken = next.main.profileToken ?? existingProfile?.tokenFingerprint;
+                    if (!profile &&
+                        existingProfile &&
+                        persistedToken === expectedTokenFingerprint) {
+                        return false;
+                    }
+                    if (profile) {
+                        if (persistedToken && persistedToken !== expectedTokenFingerprint) {
+                            return false;
+                        }
+                        if (existingProfile &&
+                            existingProfile.checkedAt > profile.checkedAt) {
+                            return false;
+                        }
+                    }
+                    next.main.profile = profile;
+                    next.main.profileToken = expectedTokenFingerprint;
+                }
+                else {
+                    const account = current?.accounts.find((candidate) => candidate.id === accountId && isOAuthAccount(candidate));
+                    if (!account?.access ||
+                        tokenFingerprint(account.access) !== expectedTokenFingerprint) {
+                        return false;
+                    }
+                    next.accounts = {
+                        ...(isRecord(next.accounts) ? next.accounts : {}),
+                    };
+                    const existingEntry = isRecord(next.accounts[accountId])
+                        ? { ...next.accounts[accountId] }
+                        : {};
+                    const existingProfile = normalizeOAuthAccountProfile(existingEntry.profile);
+                    if (!profile &&
+                        existingProfile?.tokenFingerprint === expectedTokenFingerprint) {
+                        return false;
+                    }
+                    if (profile &&
+                        existingProfile &&
+                        existingProfile.checkedAt > profile.checkedAt) {
+                        return false;
+                    }
+                    existingEntry.profile = profile;
+                    next.accounts[accountId] = existingEntry;
+                }
+                await writeJsonAtomic(statePath, pruneUndefined(next));
+                return true;
+            }
+            finally {
+                await stateLock.release();
+            }
+        }
+        finally {
+            await configLock.release();
+        }
+    });
 }
 async function saveAccountStateUnlocked(storage, path, scope) {
     const statePath = getAccountStatePath(path);
@@ -576,6 +935,8 @@ async function saveAccountStateUnlocked(storage, path, scope) {
     const next = isRecord(existing)
         ? { ...existing, version: 1 }
         : { version: 1 };
+    if (scope.mainProfile)
+        applyMainProfileStatePatch(next, storage);
     if (scope.mainQuota)
         applyMainQuotaStatePatch(next, storage);
     if (scope.mainRefresh)
@@ -877,13 +1238,27 @@ export async function setFastModePersistentEnabled(enabled, path = getAccountSto
 export async function setCacheKeepPersistentWindow(startHour, endHour, path = getAccountStoragePath()) {
     const storage = (await loadAccounts(path)) ?? createEmptyStorage();
     storage.cacheKeep = {
+        ...(storage.cacheKeep ?? {}),
         enabled: true,
+        always: false,
         startHour,
         endHour,
     };
     await saveAccounts(storage, path);
     return storage;
 }
+export async function setCacheKeepPersistentAlways(path = getAccountStoragePath()) {
+    const storage = (await loadAccounts(path)) ?? createEmptyStorage();
+    storage.cacheKeep = {
+        ...(storage.cacheKeep ?? {}),
+        enabled: true,
+        always: true,
+    };
+    delete storage.cacheKeep.startHour;
+    delete storage.cacheKeep.endHour;
+    await saveAccounts(storage, path);
+    return storage;
+}
 export async function setCacheKeepPersistentEnabled(enabled, path = getAccountStoragePath()) {
     const storage = (await loadAccounts(path)) ?? createEmptyStorage();
     storage.cacheKeep = {
@@ -911,7 +1286,7 @@ function getFallbackStatuses(storage) {
 export function shouldFallbackStatus(status, storage) {
     return getFallbackStatuses(storage).includes(status);
 }
-function normalizeThresholds(storage) {
+export function getQuotaMinimumRemainingThresholds(storage) {
     const configured = storage?.quota?.minimumRemaining || {};
     return {
         five_hour: configured.five_hour ??
@@ -1141,7 +1516,7 @@ export function quotaSnapshotPassesModelScope(quota, model) {
 export function quotaSnapshotPassesPolicy(quota, storage) {
     if (!quotaEnabled(storage))
         return true;
-    const thresholds = normalizeThresholds(storage);
+    const thresholds = getQuotaMinimumRemainingThresholds(storage);
     for (const key of ['five_hour', 'seven_day']) {
         const window = quota?.[key];
         if (!window)
@@ -1293,8 +1668,9 @@ export async function removeAccountPersistent(id, path = getAccountStoragePath()
     if (!storage)
         return false;
     const existed = removeAccount(storage, id);
-    if (existed)
-        await saveAccounts(storage, path);
+    if (existed) {
+        await saveAccounts(storage, path, { removedAccountIds: [id] });
+    }
     return existed;
 }
 export async function reorderAccountsPersistent(orderedIds, path = getAccountStoragePath()) {
@@ -1302,7 +1678,7 @@ export async function reorderAccountsPersistent(orderedIds, path = getAccountSto
     if (!storage)
         return;
     reorderAccounts(storage, orderedIds);
-    await saveAccounts(storage, path);
+    await saveAccounts(storage, path, { preserveExistingAccountOrder: false });
 }
 export async function setAccountEnabledPersistent(id, enabled, path = getAccountStoragePath()) {
     const storage = await loadAccounts(path);
@@ -1319,25 +1695,35 @@ export async function addAccountPersistent(account, path = getAccountStoragePath
     await saveAccounts(storage, path);
 }
 export function getQuotaNextRefreshAt(quota, storage, now) {
+    const intervalMs = getQuotaCheckIntervalMs(storage);
     if (!quotaEnabled(storage))
-        return now + getQuotaCheckIntervalMs(storage);
-    const thresholds = normalizeThresholds(storage);
+        return now + intervalMs;
+    const windowFreshnessDeadline = Math.min(...[
+        ...['five_hour', 'seven_day'].map((key) => quota?.[key]?.checkedAt),
+        ...(quota?.scoped ?? []).map((window) => window.checkedAt),
+    ]
+        .filter((checkedAt) => Number.isFinite(checkedAt))
+        .map((checkedAt) => checkedAt + intervalMs));
+    const capAtOldestWindow = (candidate) => Number.isFinite(windowFreshnessDeadline)
+        ? Math.min(candidate, windowFreshnessDeadline)
+        : candidate;
+    const thresholds = getQuotaMinimumRemainingThresholds(storage);
     const blockedResetTimes = [];
     for (const key of ['five_hour', 'seven_day']) {
         const window = quota?.[key];
         if (!window)
-            return now + getQuotaCheckIntervalMs(storage);
+            return capAtOldestWindow(now + intervalMs);
         if (window.remainingPercent >= thresholds[key])
             continue;
         const resetTime = window.resetsAt ? Date.parse(window.resetsAt) : Number.NaN;
         if (!Number.isFinite(resetTime) || resetTime <= now) {
-            return now + getQuotaCheckIntervalMs(storage);
+            return capAtOldestWindow(now + intervalMs);
         }
         blockedResetTimes.push(resetTime);
     }
     if (!blockedResetTimes.length)
-        return now + getQuotaCheckIntervalMs(storage);
-    return Math.min(...blockedResetTimes) + 60_000;
+        return capAtOldestWindow(now + intervalMs);
+    return capAtOldestWindow(Math.min(...blockedResetTimes) + 60_000);
 }
 function tokenNeedsRefresh(account, storage, now) {
     return (!account.access ||
@@ -1353,8 +1739,11 @@ function quotaSnapshotIsFresh(quota, storage, now) {
         return Boolean(window && now - window.checkedAt < maxAge);
     });
 }
-function quotaIsStale(account, storage, now) {
-    return !quotaSnapshotIsFresh(account.quota, storage, now);
+function quotaIsStale(account, storage, now, modelId) {
+    if (!quotaSnapshotIsFresh(account.quota, storage, now))
+        return true;
+    const scoped = getScopedQuotaWindowForModel(account.quota, modelId);
+    return Boolean(scoped && now - scoped.checkedAt >= getQuotaCheckIntervalMs(storage));
 }
 function cachedQuotaWindowStillRelevant(window, now) {
     if (!window)
@@ -1450,6 +1839,61 @@ function mapScopedWeeklyLimits(limits, checkedAt) {
     }
     return scoped;
 }
+function mapExtraUsage(usage) {
+    if (usage.extra_usage?.is_enabled !== true)
+        return undefined;
+    const usedAmount = usage.extra_usage.used_credits;
+    const limitAmount = usage.extra_usage.monthly_limit;
+    if (typeof usedAmount !== 'number' ||
+        !Number.isFinite(usedAmount) ||
+        typeof limitAmount !== 'number' ||
+        !Number.isFinite(limitAmount)) {
+        return undefined;
+    }
+    const rawCurrency = usage.spend?.limit?.currency;
+    const currency = rawCurrency == null ? 'USD' : nonEmptyString(rawCurrency);
+    const rawExponent = usage.spend?.limit?.exponent;
+    const moneyExponent = rawExponent == null ? 2 : rawExponent;
+    if (!currency ||
+        !/^[A-Za-z]{3}$/.test(currency) ||
+        !Number.isInteger(moneyExponent) ||
+        moneyExponent < 0 ||
+        moneyExponent > 20) {
+        return undefined;
+    }
+    return {
+        used: { amountMinor: usedAmount, currency, exponent: moneyExponent },
+        limit: { amountMinor: limitAmount, currency, exponent: moneyExponent },
+        ...(typeof usage.extra_usage.utilization === 'number' &&
+            Number.isFinite(usage.extra_usage.utilization) && {
+            utilizationPercent: usage.extra_usage.utilization,
+        }),
+        ...(nonEmptyString(usage.spend?.severity) && {
+            severity: nonEmptyString(usage.spend?.severity),
+        }),
+        exhausted: usedAmount >= limitAmount,
+    };
+}
+function mapBindingWindow(limits) {
+    if (!Array.isArray(limits))
+        return undefined;
+    const active = limits.find((limit) => limit?.is_active === true);
+    if (!active)
+        return undefined;
+    if (active.kind === 'session')
+        return 'five_hour';
+    if (active.kind === 'weekly_all')
+        return 'seven_day';
+    if (active.kind !== 'weekly_scoped' || active.group !== 'weekly') {
+        return undefined;
+    }
+    const modelName = nonEmptyString(active.scope?.model?.display_name);
+    if (!modelName)
+        return undefined;
+    const identity = nonEmptyString(active.scope?.model?.id) ?? modelName;
+    const slug = slugForQuotaIdentity(identity);
+    return slug ? `claude-weekly-scoped-${slug}` : undefined;
+}
 function mapUsageWindow(window, checkedAt) {
     if (typeof window?.utilization !== 'number')
         return undefined;
@@ -1485,10 +1929,17 @@ export async function fetchOAuthQuotaSnapshot(input) {
     }
     const checkedAt = input.now?.() ?? Date.now();
     const usage = (await response.json());
+    const bindingWindow = mapBindingWindow(usage.limits);
     return {
         five_hour: mapUsageWindow(usage.five_hour, checkedAt),
         seven_day: mapUsageWindow(usage.seven_day, checkedAt),
         scoped: mapScopedWeeklyLimits(usage.limits, checkedAt),
+        extraUsage: mapExtraUsage(usage),
+        ...(bindingWindow && {
+            bindingWindow,
+            bindingWindowSource: 'poll',
+        }),
+        source: 'poll',
         checkedAt,
     };
 }
@@ -1507,6 +1958,7 @@ export function upsertAccount(storage, account) {
             addedAt: storage.accounts[index]?.addedAt ?? account.addedAt,
             ...(account.type === 'oauth' && {
                 quota: account.quota,
+                profile: account.profile,
                 lastRefreshedAt: account.lastRefreshedAt,
                 lastRefreshError: account.lastRefreshError,
                 lastQuotaRefreshError: account.lastQuotaRefreshError,
@@ -1656,8 +2108,8 @@ export class FallbackAccountManager {
                 }
                 this.seedFallbackQuota(next, storage);
                 const stale = this.quotaManager
-                    ? this.quotaManager.isFallbackStale(next.id, next.access)
-                    : quotaIsStale(next, storage, this.now());
+                    ? this.quotaManager.isFallbackStale(next.id, next.access, options.modelId)
+                    : quotaIsStale(next, storage, this.now(), options.modelId);
                 // Skip the request-time refresh when this account's quota API is
                 // backed off (recent 429/5xx). Hitting it again would extend the
                 // backoff; evaluate policy on the cached/seeded quota instead. Mirrors