@cortexkit/anthropic-auth-core 1.12.1 → 1.13.0

package/dist/accounts.d.ts

@@ -19,7 +19,7 @@ export type OAuthAccount = AccountBase & {
     lastRefreshedAt?: number;
     lastRefreshError?: AccountOperationError;
     lastQuotaRefreshError?: AccountOperationError;
-    quota?: Partial<Record<QuotaWindowName, AccountQuotaWindow>>;
+    quota?: OAuthQuotaSnapshot;
 };
 export type ApiKeyAccount = AccountBase & {
     type: 'api';
@@ -60,8 +60,17 @@ export type AccountQuotaWindow = {
     resetsAt?: string;
     checkedAt: number;
 };
+export type AccountScopedQuotaWindow = AccountQuotaWindow & {
+    id: string;
+    title: string;
+    modelId?: string;
+    modelName: string;
+};
+export type OAuthQuotaSnapshot = Partial<Record<QuotaWindowName, AccountQuotaWindow>> & {
+    scoped?: AccountScopedQuotaWindow[];
+};
 export type RoutingMode = 'main-first' | 'fallback-first';
-export type KillswitchThresholds = Partial<Record<QuotaWindowName | '5h' | '1w', number>>;
+export type KillswitchThresholds = Partial<Record<QuotaWindowName | '5h' | '1w' | 'scoped', number>>;
 export type KillswitchConfig = {
     enabled?: boolean;
     /** Thresholds for the main OAuth account (remaining % below which the account is killed). */
@@ -164,7 +173,6 @@ export type AccountStateSaveScope = {
     mainRefresh?: boolean;
     accounts?: true | string[];
 };
-export type OAuthQuotaSnapshot = Partial<Record<QuotaWindowName, AccountQuotaWindow>>;
 export type AccountManagerOptions = {
     now?: () => number;
     fetchImpl?: typeof fetch;
@@ -253,21 +261,36 @@ export declare function getPersistedMainQuota(storage: AccountStorage | null): {
  * Returns 0 when disabled (default).
  */
 export declare function getQuotaRefreshEveryNRequests(storage: AccountStorage | null): number;
+export declare function getScopedQuotaWindowForModel(quota: OAuthQuotaSnapshot | undefined, model: unknown): AccountScopedQuotaWindow | undefined;
+export declare function quotaSnapshotModelScopeIsExhausted(quota: OAuthQuotaSnapshot | undefined, model: unknown): boolean;
+export declare function quotaSnapshotPassesModelScope(quota: OAuthQuotaSnapshot | undefined, model: unknown): boolean;
 export declare function quotaSnapshotPassesPolicy(quota: OAuthQuotaSnapshot | undefined, storage: AccountStorage | null): boolean;
-export declare const DEFAULT_KILLSWITCH_THRESHOLDS: Record<QuotaWindowName, number>;
+export declare const DEFAULT_KILLSWITCH_THRESHOLDS: Record<QuotaWindowName | 'scoped', number>;
+export declare function normalizeKillswitchThresholds(thresholds: KillswitchThresholds | undefined): Record<QuotaWindowName | 'scoped', number>;
 export declare function isKillswitchEnabled(storage: AccountStorage | null): boolean;
+export declare function getKillswitchThresholdsForAccount(storage: AccountStorage | null, accountId?: string): Record<QuotaWindowName | 'scoped', number>;
 /**
  * Returns true if the account's quota is above its killswitch threshold.
  * When killswitch is disabled, always returns true.
+ *
+ * When `modelId` is provided, the per-account `scoped` threshold is also
+ * evaluated against the quota window matching that model — additive to the
+ * 5h/7d check. A model with no matching scoped window is unaffected.
  */
-export declare function killswitchPassesPolicy(quota: OAuthQuotaSnapshot | undefined, storage: AccountStorage | null, accountId?: string): boolean;
+export declare function killswitchPassesPolicy(quota: OAuthQuotaSnapshot | undefined, storage: AccountStorage | null, accountId?: string, modelId?: string): boolean;
 /**
  * Find the earliest reset time across all accounts' quota windows.
  * Returns seconds from `now` until that reset, or 300 as a fallback.
+ *
+ * When `scopedModelId` is provided, ONLY the matched scoped window's
+ * `resetsAt` is considered — the 5h/7d resets are intentionally ignored
+ * so the retry hint reflects the weekly reset, not the sooner 5h reset
+ * (which would cause a retry-storm against a block that won't clear for
+ * days). With `scopedModelId` undefined, the 5h/7d behavior is unchanged.
  */
 export declare function killswitchRetryAfterSeconds(mainQuota: OAuthQuotaSnapshot | undefined, fallbackAccounts: Array<{
     quota?: OAuthQuotaSnapshot;
-}>, now: number): number;
+}>, now: number, scopedModelId?: string): number;
 export declare function getKillswitchConfig(storage: AccountStorage | null): KillswitchConfig;
 export declare function setKillswitchPersistent(config: KillswitchConfig, path?: string): Promise<AccountStorage>;
 export declare function removeAccountPersistent(id: string, path?: string): Promise<boolean>;
@@ -279,10 +302,7 @@ export declare function fetchOAuthQuotaSnapshot(input: {
     accessToken: string;
     fetchImpl?: typeof fetch;
     now?: () => number;
-}): Promise<{
-    five_hour: AccountQuotaWindow | undefined;
-    seven_day: AccountQuotaWindow | undefined;
-}>;
+}): Promise<OAuthQuotaSnapshot>;
 export declare function upsertAccount(storage: AccountStorage, account: FallbackAccount): void;
 export declare function removeAccount(storage: AccountStorage, id: string): boolean;
 export declare function reorderAccounts(storage: AccountStorage, orderedIds: string[]): void;
@@ -306,9 +326,13 @@ export declare class FallbackAccountManager {
     save(storage: AccountStorage, accountIds?: string[]): Promise<void>;
     startBackgroundRefresh(): void;
     stopBackgroundRefresh(): void;
-    getUsableFallbackAccounts(existingStorage?: AccountStorage | null): Promise<OAuthAccount[]>;
+    getUsableFallbackAccounts(existingStorage?: AccountStorage | null, options?: {
+        modelId?: string;
+    }): Promise<OAuthAccount[]>;
     markUsed(account: FallbackAccount): Promise<void>;
-    accountPassesQuotaPolicy(account: OAuthAccount, storage: AccountStorage | null): boolean;
+    accountPassesQuotaPolicy(account: OAuthAccount, storage: AccountStorage | null, options?: {
+        modelId?: string;
+    }): boolean;
     /**
      * Return the account with its quota overlaid from the unified QuotaManager
      * cache (token-bound) when available, so quota-policy decisions use the same

package/dist/accounts.js

@@ -151,28 +151,63 @@ function normalizeOperationError(value) {
         permanent: typeof value.permanent === 'boolean' ? value.permanent : undefined,
     };
 }
+function normalizeQuotaWindow(value) {
+    if (!isRecord(value))
+        return undefined;
+    const usedPercent = Number(value.usedPercent);
+    const remainingPercent = Number(value.remainingPercent);
+    const checkedAt = Number(value.checkedAt);
+    if (!Number.isFinite(usedPercent) ||
+        !Number.isFinite(remainingPercent) ||
+        !Number.isFinite(checkedAt)) {
+        return undefined;
+    }
+    return {
+        usedPercent,
+        remainingPercent,
+        checkedAt,
+        resetsAt: typeof value.resetsAt === 'string' ? value.resetsAt : undefined,
+    };
+}
 function normalizeQuota(value) {
     if (!isRecord(value))
         return undefined;
     const quota = {};
     for (const key of ['five_hour', 'seven_day']) {
-        const window = value[key];
-        if (!isRecord(window))
-            continue;
-        const usedPercent = Number(window.usedPercent);
-        const remainingPercent = Number(window.remainingPercent);
-        const checkedAt = Number(window.checkedAt);
-        if (!Number.isFinite(usedPercent) ||
-            !Number.isFinite(remainingPercent) ||
-            !Number.isFinite(checkedAt)) {
-            continue;
-        }
-        quota[key] = {
-            usedPercent,
-            remainingPercent,
-            checkedAt,
-            resetsAt: typeof window.resetsAt === 'string' ? window.resetsAt : undefined,
-        };
+        const normalized = normalizeQuotaWindow(value[key]);
+        if (normalized)
+            quota[key] = normalized;
+    }
+    if (Array.isArray(value.scoped)) {
+        const scoped = value.scoped
+            .map((entry) => {
+            if (!isRecord(entry))
+                return undefined;
+            const window = normalizeQuotaWindow(entry);
+            if (!window)
+                return undefined;
+            if (typeof entry.id !== 'string' || !entry.id.trim())
+                return undefined;
+            if (typeof entry.title !== 'string' || !entry.title.trim()) {
+                return undefined;
+            }
+            if (typeof entry.modelName !== 'string' || !entry.modelName.trim()) {
+                return undefined;
+            }
+            const modelId = typeof entry.modelId === 'string' && entry.modelId.trim()
+                ? entry.modelId.trim()
+                : undefined;
+            return {
+                ...window,
+                id: entry.id.trim(),
+                title: entry.title.trim(),
+                ...(modelId && { modelId }),
+                modelName: entry.modelName.trim(),
+            };
+        })
+            .filter((entry) => entry != null);
+        if (scoped.length)
+            quota.scoped = scoped;
     }
     return Object.keys(quota).length ? quota : undefined;
 }
@@ -225,6 +260,43 @@ async function readJsonIfPresent(path) {
 function objectWithDefinedEntries(value) {
     return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
 }
+function numericField(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+function accountCredentialTimestamp(value) {
+    return Math.max(numericField(value.lastRefreshedAt), numericField(value.lastUsed), numericField(value.addedAt));
+}
+function legacyConfigCredentialsAreNewer(account, stateAccount) {
+    if (account.type !== 'oauth')
+        return false;
+    if (typeof account.refresh !== 'string' || !account.refresh.trim()) {
+        return false;
+    }
+    const tokenChanged = Boolean((typeof account.access === 'string' &&
+        typeof stateAccount.access === 'string' &&
+        account.access !== stateAccount.access) ||
+        (typeof account.refresh === 'string' &&
+            typeof stateAccount.refresh === 'string' &&
+            account.refresh !== stateAccount.refresh));
+    if (!tokenChanged)
+        return false;
+    return (accountCredentialTimestamp(account) >
+        accountCredentialTimestamp(stateAccount));
+}
+function mergeConfigAccountAndState(account, stateAccount) {
+    if (legacyConfigCredentialsAreNewer(account, stateAccount)) {
+        const merged = { ...stateAccount, ...account };
+        const configTimestamp = accountCredentialTimestamp(account);
+        if (configTimestamp > numericField(merged.lastRefreshedAt)) {
+            merged.lastRefreshedAt = configTimestamp;
+        }
+        delete merged.quota;
+        delete merged.lastRefreshError;
+        delete merged.lastQuotaRefreshError;
+        return merged;
+    }
+    return { ...account, ...stateAccount };
+}
 function mergeConfigAndState(configValue, stateValue) {
     if (!isRecord(configValue))
         return configValue;
@@ -242,7 +314,7 @@ function mergeConfigAndState(configValue, stateValue) {
             const stateAccount = typeof account.id === 'string' && isRecord(stateAccounts[account.id])
                 ? stateAccounts[account.id]
                 : {};
-            return { ...account, ...stateAccount };
+            return mergeConfigAccountAndState(account, stateAccount);
         })
         : [];
     return {
@@ -312,7 +384,7 @@ function accountRuntimeState(account) {
     });
 }
 function quotaSnapshotCheckedAt(quota) {
-    return Math.max(quota?.five_hour?.checkedAt ?? 0, quota?.seven_day?.checkedAt ?? 0);
+    return Math.max(quota?.five_hour?.checkedAt ?? 0, quota?.seven_day?.checkedAt ?? 0, ...(quota?.scoped?.map((window) => window.checkedAt) ?? []));
 }
 function mergeAccountRuntimeState(existing, incoming) {
     if (!isRecord(existing))
@@ -320,10 +392,13 @@ function mergeAccountRuntimeState(existing, 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 tokenChanged = Boolean(existingEntry.access &&
-            incoming.access &&
-            existingEntry.access !== incoming.access);
         const existingRefreshAt = existingEntry.lastRefreshedAt ?? 0;
         const incomingRefreshAt = incoming.lastRefreshedAt ?? 0;
         if (tokenChanged && incomingRefreshAt <= existingRefreshAt) {
@@ -335,9 +410,27 @@ function mergeAccountRuntimeState(existing, incoming) {
             }
             return merged;
         }
+        const merged = { ...existingEntry, ...incoming };
+        if (tokenChanged) {
+            if ('quota' in incoming) {
+                merged.quota = existingEntry.quota;
+                if ('lastQuotaRefreshError' in existingEntry) {
+                    merged.lastQuotaRefreshError = existingEntry.lastQuotaRefreshError;
+                }
+                else {
+                    delete merged.lastQuotaRefreshError;
+                }
+            }
+            else {
+                delete merged.quota;
+                delete merged.lastQuotaRefreshError;
+            }
+            if (!('lastRefreshError' in incoming))
+                delete merged.lastRefreshError;
+            return merged;
+        }
         return {
-            ...existingEntry,
-            ...incoming,
+            ...merged,
             quota: existingEntry.quota,
             lastQuotaRefreshError: existingEntry.lastQuotaRefreshError,
         };
@@ -1003,6 +1096,37 @@ function failClosedOnUnknownQuota(storage) {
     return (storage?.quota?.failClosedOnUnknownQuota ??
         DEFAULT_FAIL_CLOSED_ON_UNKNOWN_QUOTA);
 }
+function scopedQuotaModelKey(model) {
+    if (typeof model !== 'string')
+        return null;
+    const normalized = model.toLowerCase();
+    if (normalized.includes('fable'))
+        return 'fable';
+    if (normalized.includes('mythos'))
+        return 'mythos';
+    return null;
+}
+export function getScopedQuotaWindowForModel(quota, model) {
+    const key = scopedQuotaModelKey(model);
+    if (!key)
+        return undefined;
+    return quota?.scoped?.find((window) => {
+        const haystack = [window.modelId, window.modelName, window.title]
+            .filter((value) => typeof value === 'string')
+            .join(' ')
+            .toLowerCase();
+        return haystack.includes(key);
+    });
+}
+export function quotaSnapshotModelScopeIsExhausted(quota, model) {
+    const window = getScopedQuotaWindowForModel(quota, model);
+    return Boolean(window &&
+        Number.isFinite(window.remainingPercent) &&
+        window.remainingPercent <= 0);
+}
+export function quotaSnapshotPassesModelScope(quota, model) {
+    return !quotaSnapshotModelScopeIsExhausted(quota, model);
+}
 export function quotaSnapshotPassesPolicy(quota, storage) {
     if (!quotaEnabled(storage))
         return true;
@@ -1026,10 +1150,12 @@ export function quotaSnapshotPassesPolicy(quota, storage) {
 export const DEFAULT_KILLSWITCH_THRESHOLDS = {
     five_hour: 5,
     seven_day: 10,
+    scoped: 0,
 };
-function normalizeKillswitchThresholds(thresholds) {
+export function normalizeKillswitchThresholds(thresholds) {
     const fiveHour = thresholds?.five_hour ?? thresholds?.['5h'];
     const sevenDay = thresholds?.seven_day ?? thresholds?.['1w'];
+    const scoped = thresholds?.scoped;
     return {
         five_hour: typeof fiveHour === 'number' && Number.isFinite(fiveHour)
             ? fiveHour
@@ -1037,12 +1163,15 @@ function normalizeKillswitchThresholds(thresholds) {
         seven_day: typeof sevenDay === 'number' && Number.isFinite(sevenDay)
             ? sevenDay
             : DEFAULT_KILLSWITCH_THRESHOLDS.seven_day,
+        scoped: typeof scoped === 'number' && Number.isFinite(scoped)
+            ? scoped
+            : DEFAULT_KILLSWITCH_THRESHOLDS.scoped,
     };
 }
 export function isKillswitchEnabled(storage) {
     return storage?.killswitch?.enabled === true;
 }
-function getKillswitchThresholdsForAccount(storage, accountId) {
+export function getKillswitchThresholdsForAccount(storage, accountId) {
     if (!storage?.killswitch)
         return DEFAULT_KILLSWITCH_THRESHOLDS;
     if (accountId && storage.killswitch.accounts?.[accountId]) {
@@ -1053,8 +1182,12 @@ function getKillswitchThresholdsForAccount(storage, accountId) {
 /**
  * Returns true if the account's quota is above its killswitch threshold.
  * When killswitch is disabled, always returns true.
+ *
+ * When `modelId` is provided, the per-account `scoped` threshold is also
+ * evaluated against the quota window matching that model — additive to the
+ * 5h/7d check. A model with no matching scoped window is unaffected.
  */
-export function killswitchPassesPolicy(quota, storage, accountId) {
+export function killswitchPassesPolicy(quota, storage, accountId, modelId) {
     if (!isKillswitchEnabled(storage))
         return true;
     const thresholds = getKillswitchThresholdsForAccount(storage, accountId);
@@ -1075,6 +1208,22 @@ export function killswitchPassesPolicy(quota, storage, accountId) {
         if (window.remainingPercent < thresholds[key])
             return false;
     }
+    // Scoped check is additive to the 5h/7d evaluation above and is an
+    // INDEPENDENT block reason — it must run before the unknown-window
+    // fail-closed decision, so an exhausted scoped window blocks even when
+    // 5h/7d is missing/non-finite (the latter only changes the fall-through
+    // for accounts that did not already block on scoped). A missing scoped
+    // window (no carve-out for this model) is not "unknown quota" — only a
+    // PRESENT window at/below threshold blocks. The comparison is inclusive
+    // (`<=`) so the default 0 fires at exhaustion.
+    if (modelId) {
+        const scopedWindow = getScopedQuotaWindowForModel(quota, modelId);
+        if (scopedWindow &&
+            Number.isFinite(scopedWindow.remainingPercent) &&
+            scopedWindow.remainingPercent <= thresholds.scoped) {
+            return false;
+        }
+    }
     if (sawUnknownWindow)
         return !failClosedOnUnknownQuota(storage);
     return true;
@@ -1082,13 +1231,20 @@ export function killswitchPassesPolicy(quota, storage, accountId) {
 /**
  * Find the earliest reset time across all accounts' quota windows.
  * Returns seconds from `now` until that reset, or 300 as a fallback.
+ *
+ * When `scopedModelId` is provided, ONLY the matched scoped window's
+ * `resetsAt` is considered — the 5h/7d resets are intentionally ignored
+ * so the retry hint reflects the weekly reset, not the sooner 5h reset
+ * (which would cause a retry-storm against a block that won't clear for
+ * days). With `scopedModelId` undefined, the 5h/7d behavior is unchanged.
  */
-export function killswitchRetryAfterSeconds(mainQuota, fallbackAccounts, now) {
+export function killswitchRetryAfterSeconds(mainQuota, fallbackAccounts, now, scopedModelId) {
     const resetTimes = [];
     const allQuotas = [mainQuota, ...fallbackAccounts.map((a) => a.quota)];
     for (const quota of allQuotas) {
-        for (const key of ['five_hour', 'seven_day']) {
-            const resetStr = quota?.[key]?.resetsAt;
+        if (scopedModelId) {
+            const scopedWindow = getScopedQuotaWindowForModel(quota, scopedModelId);
+            const resetStr = scopedWindow?.resetsAt;
             if (!resetStr)
                 continue;
             const resetTime = Date.parse(resetStr);
@@ -1096,6 +1252,17 @@ export function killswitchRetryAfterSeconds(mainQuota, fallbackAccounts, now) {
                 resetTimes.push(resetTime);
             }
         }
+        else {
+            for (const key of ['five_hour', 'seven_day']) {
+                const resetStr = quota?.[key]?.resetsAt;
+                if (!resetStr)
+                    continue;
+                const resetTime = Date.parse(resetStr);
+                if (Number.isFinite(resetTime) && resetTime > now) {
+                    resetTimes.push(resetTime);
+                }
+            }
+        }
     }
     if (!resetTimes.length)
         return 300;
@@ -1226,6 +1393,52 @@ function clampPercent(value) {
         return 100;
     return value;
 }
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function slugForQuotaIdentity(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+function mapScopedWeeklyLimits(limits, checkedAt) {
+    if (!Array.isArray(limits))
+        return undefined;
+    const seen = new Set();
+    const scoped = [];
+    for (const limit of limits) {
+        if (limit?.kind !== 'weekly_scoped' || limit.group !== 'weekly')
+            continue;
+        if (typeof limit.percent !== 'number' || !Number.isFinite(limit.percent)) {
+            continue;
+        }
+        const modelName = nonEmptyString(limit.scope?.model?.display_name);
+        if (!modelName)
+            continue;
+        const identity = nonEmptyString(limit.scope?.model?.id) ?? modelName;
+        const slug = slugForQuotaIdentity(identity);
+        if (!slug)
+            continue;
+        const id = `claude-weekly-scoped-${slug}`;
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        const usedPercent = clampPercent(limit.percent);
+        const modelId = nonEmptyString(limit.scope?.model?.id);
+        scoped.push({
+            id,
+            title: `${modelName} only`,
+            ...(modelId && { modelId }),
+            modelName,
+            usedPercent,
+            remainingPercent: clampPercent(100 - usedPercent),
+            resetsAt: limit.resets_at,
+            checkedAt,
+        });
+    }
+    return scoped.length ? scoped : undefined;
+}
 function mapUsageWindow(window, checkedAt) {
     if (typeof window?.utilization !== 'number')
         return undefined;
@@ -1264,6 +1477,7 @@ export async function fetchOAuthQuotaSnapshot(input) {
     return {
         five_hour: mapUsageWindow(usage.five_hour, checkedAt),
         seven_day: mapUsageWindow(usage.seven_day, checkedAt),
+        scoped: mapScopedWeeklyLimits(usage.limits, checkedAt),
     };
 }
 function updateStoredAccount(storage, account) {
@@ -1408,7 +1622,7 @@ export class FallbackAccountManager {
         this.refreshTimer = null;
         this.quotaTimer = null;
     }
-    async getUsableFallbackAccounts(existingStorage) {
+    async getUsableFallbackAccounts(existingStorage, options = {}) {
         const storage = existingStorage !== undefined ? existingStorage : await this.load();
         if (!storage)
             return [];
@@ -1444,7 +1658,9 @@ export class FallbackAccountManager {
                 // Single source of truth: evaluate quota policy from the unified
                 // QuotaManager cache (the same source as the staleness check above) so
                 // an active-route refresh that updated only the cache is not ignored.
-                if (this.accountPassesQuotaPolicy(this.quotaPolicyAccount(next), storage))
+                if (this.accountPassesQuotaPolicy(this.quotaPolicyAccount(next), storage, {
+                    modelId: options.modelId,
+                }))
                     usable.push(next);
             }
             catch (error) {
@@ -1453,9 +1669,14 @@ export class FallbackAccountManager {
                         accountId: account.id,
                         error: formatErrorMessage(error),
                     });
-                    usable.push(account);
+                    if (this.accountPassesQuotaPolicy(this.quotaPolicyAccount(account), storage, {
+                        modelId: options.modelId,
+                    })) {
+                        usable.push(account);
+                    }
                 }
-                else if (!failClosedOnUnknownQuota(storage)) {
+                else if (!failClosedOnUnknownQuota(storage) &&
+                    quotaSnapshotPassesModelScope(account.quota, options.modelId)) {
                     usable.push(account);
                 }
             }
@@ -1474,8 +1695,9 @@ export class FallbackAccountManager {
         stored.lastUsed = this.now();
         await this.save(storage);
     }
-    accountPassesQuotaPolicy(account, storage) {
-        return quotaSnapshotPassesPolicy(account.quota, storage);
+    accountPassesQuotaPolicy(account, storage, options = {}) {
+        return (quotaSnapshotPassesPolicy(account.quota, storage) &&
+            quotaSnapshotPassesModelScope(account.quota, options.modelId));
     }
     /**
      * Return the account with its quota overlaid from the unified QuotaManager

package/dist/cachekeep.d.ts

@@ -61,6 +61,7 @@ export type CacheKeepTarget = {
     bodyText: string;
     cacheExpiresAt: number;
     dayKey: string;
+    oauthAccountId?: string;
 };
 export declare class CacheKeepManager {
     private readonly options;
@@ -89,6 +90,7 @@ export declare class CacheKeepManager {
         bodyText: string;
         storage: AccountStorage | null;
         cacheMode: string;
+        oauthAccountId?: string;
     }): {
         tracked: boolean;
         reason: string;

package/dist/cachekeep.js

@@ -287,6 +287,7 @@ export class CacheKeepManager {
             bodyText: input.bodyText,
             cacheExpiresAt: now + CACHE_KEEP_TTL_MS,
             dayKey: today,
+            oauthAccountId: input.oauthAccountId,
         });
         this.pruneTargets(now, today);
         this.start();

package/dist/killswitch.d.ts

@@ -12,6 +12,7 @@ export type KillswitchCommandAction = {
         account: string;
         fh: number;
         sd: number;
+        scoped?: number;
     }>;
 } | {
     type: 'usage';

package/dist/killswitch.js

@@ -1,4 +1,4 @@
-import { DEFAULT_KILLSWITCH_THRESHOLDS as DEFAULT_THRESHOLDS } from "./accounts.js";
+import { DEFAULT_KILLSWITCH_THRESHOLDS as DEFAULT_THRESHOLDS, normalizeKillswitchThresholds, } from "./accounts.js";
 export const KILLSWITCH_COMMAND_NAME = 'claude-killswitch';
 export function parseKillswitchCommandAction(argumentsText) {
     const parts = argumentsText.trim().split(/\s+/).filter(Boolean);
@@ -11,15 +11,21 @@ export function parseKillswitchCommandAction(argumentsText) {
     if (parts[0] === 'set') {
         const entries = [];
         for (let i = 1; i < parts.length; i++) {
-            const match = parts[i]?.match(/^([^:]+):(\d+),(\d+)$/);
+            const match = parts[i]?.match(/^([^:]+):(\d+),(\d+)(?:,(\d+))?$/);
             if (!match)
                 return { type: 'usage' };
-            const [, account, fhStr, sdStr] = match;
-            entries.push({
+            const [, account, fhStr, sdStr, scopedStr] = match;
+            const scoped = typeof scopedStr === 'string' && scopedStr.length > 0
+                ? Number.parseInt(scopedStr, 10)
+                : undefined;
+            const entry = {
                 account,
                 fh: Number.parseInt(fhStr, 10),
                 sd: Number.parseInt(sdStr, 10),
-            });
+            };
+            if (scoped !== undefined)
+                entry.scoped = scoped;
+            entries.push(entry);
         }
         if (entries.length === 0)
             return { type: 'usage' };
@@ -36,17 +42,13 @@ function buildStatusTable(config, accountIds) {
     ];
     if (enabled) {
         lines.push('');
-        lines.push('| Account | 5h threshold | 1w threshold |');
-        lines.push('| ------- | ------------ | ------------ |');
-        const mainT = config.main ?? {};
-        const fh = mainT.five_hour ?? mainT['5h'] ?? DEFAULT_THRESHOLDS.five_hour;
-        const sd = mainT.seven_day ?? mainT['1w'] ?? DEFAULT_THRESHOLDS.seven_day;
-        lines.push(`| main | \u2265 ${fh}% | \u2265 ${sd}% |`);
+        lines.push('| Account | 5h threshold | 1w threshold | Scoped |');
+        lines.push('| ------- | ------------ | ------------ | ------ |');
+        const mainT = normalizeKillswitchThresholds(config.main);
+        lines.push(`| main | \u2265 ${mainT.five_hour}% | \u2265 ${mainT.seven_day}% | \u2264 ${mainT.scoped}% |`);
         for (const id of accountIds) {
-            const t = config.accounts?.[id] ?? config.main ?? {};
-            const afh = t.five_hour ?? t['5h'] ?? DEFAULT_THRESHOLDS.five_hour;
-            const asd = t.seven_day ?? t['1w'] ?? DEFAULT_THRESHOLDS.seven_day;
-            lines.push(`| ${id} | \u2265 ${afh}% | \u2265 ${asd}% |`);
+            const t = normalizeKillswitchThresholds(config.accounts?.[id] ?? config.main);
+            lines.push(`| ${id} | \u2265 ${t.five_hour}% | \u2265 ${t.seven_day}% | \u2264 ${t.scoped}% |`);
         }
     }
     return lines.join('\n');
@@ -59,6 +61,7 @@ const USAGE_TEXT = [
     `/${KILLSWITCH_COMMAND_NAME} on           — enable with current or default thresholds`,
     `/${KILLSWITCH_COMMAND_NAME} off          — disable`,
     `/${KILLSWITCH_COMMAND_NAME} set all:5,10 — set all accounts to 5h≥5%, 1w≥10%`,
+    `/${KILLSWITCH_COMMAND_NAME} set main:3,8,0 — set 5h≥3%, 1w≥8%, scoped≤0%`,
     `/${KILLSWITCH_COMMAND_NAME} set main:3,8 work-alt:5,10 — per-account`,
     '```',
 ].join('\n');
@@ -102,6 +105,8 @@ export function executeKillswitchCommand(input) {
                 five_hour: entry.fh,
                 seven_day: entry.sd,
             };
+            if (entry.scoped !== undefined)
+                thresholds.scoped = entry.scoped;
             if (entry.account === 'main') {
                 updated.main = thresholds;
             }

package/dist/quotas.d.ts

@@ -1,4 +1,4 @@
-import type { AccountQuotaWindow, AccountStorage, OAuthQuotaSnapshot, QuotaWindowName } from './accounts.ts';
+import type { AccountStorage, OAuthQuotaSnapshot } from './accounts.ts';
 export declare const CLAUDE_QUOTAS_COMMAND_NAME = "claude-quota";
 export type QuotaAccountSummary = {
     name: string;
@@ -13,7 +13,7 @@ export declare function buildFallbackQuotaSummaries(storage: AccountStorage | nu
     name: string;
     role: "fallback";
     enabled: boolean;
-    quota: Partial<Record<QuotaWindowName, AccountQuotaWindow>> | undefined;
+    quota: OAuthQuotaSnapshot | undefined;
     lastRefreshedAt: number | undefined;
 }[];
 export declare function buildClaudeQuotaSummary(input: {

package/dist/quotas.js

@@ -52,6 +52,13 @@ function formatWindow(key, window, now) {
         `${formatReset(window.resetsAt, now)}, checked ${formatAge(window.checkedAt, now)})`,
     ].join('');
 }
+function formatScopedWindow(window, now) {
+    return [
+        `  - ${window.title}: ${formatPercent(window.remainingPercent)} remaining`,
+        ` (${formatPercent(window.usedPercent)} used`,
+        `${formatReset(window.resetsAt, now)}, checked ${formatAge(window.checkedAt, now)})`,
+    ].join('');
+}
 function accountName(account) {
     return account.label?.trim() || account.id;
 }
@@ -95,6 +102,9 @@ export function buildClaudeQuotaSummary(input) {
         }
         lines.push(formatWindow('five_hour', account.quota?.five_hour, now));
         lines.push(formatWindow('seven_day', account.quota?.seven_day, now));
+        for (const window of account.quota?.scoped ?? []) {
+            lines.push(formatScopedWindow(window, now));
+        }
         lines.push('');
     }
     return lines.join('\n').trimEnd();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/anthropic-auth-core",
-  "version": "1.12.1",
+  "version": "1.13.0",
   "type": "module",
   "repository": {
     "type": "git",