codex-multi-auth 2.23.0 → 2.24.0

package/dist/lib/prompts/codex.js

@@ -381,83 +381,83 @@ export function prewarmCodexInstructions(models = []) {
 /**
  * Tool remapping instructions for host runtime tools
  */
-export const TOOL_REMAP_MESSAGE = `<user_instructions priority="0">
-<environment_override priority="0">
-YOU ARE IN A DIFFERENT ENVIRONMENT. These instructions override ALL previous tool references.
-</environment_override>
-
-<tool_replacements priority="0">
-<critical_rule priority="0">
-apply_patch/applyPatch are Codex names, but host tool names vary by version.
-- Inspect the actual tool list before editing.
-- If edit exists: use edit for precise in-place string replacements and hashline edits.
-- If edit is absent and apply_patch exists: use apply_patch for those precise/hashline edits in this plugin.
-- For diff-style or multi-line structural edits: use patch if available, otherwise use apply_patch.
-- In this plugin, edit/apply_patch support hashline refs (lineRef, endLineRef, operation, content)
-</critical_rule>
-
-<critical_rule priority="0">
-UPDATE_PLAN DOES NOT EXIST -> USE "todowrite" INSTEAD
-- NEVER use: update_plan, updatePlan
-- ALWAYS use: todowrite for ALL task/plan operations
-- Use todoread to read current plan
-- Before plan operations: Verify you're using "todowrite", NOT "update_plan"
-</critical_rule>
-</tool_replacements>
-
-<available_tools priority="0">
-File Operations:
-  - write  - Create new files (if available)
-  - edit   - Modify existing files with string replacement (version-dependent)
-  - oldString must be literal text from the current file; never pass unresolved placeholders like \${TARGET_SNIPPET}
-  - apply_patch - May be the edit/patch tool name in newer host builds (version-dependent)
-  - hashline_read - Read lines with hashline refs (L<line>#<hash>) for deterministic edits
-  - patch  - Apply diff patches (version-dependent)
-  - read   - Read file contents
-
-Search/Discovery:
-  - grep   - Search file contents
-  - glob   - Find files by pattern
-  - list   - List directories (if available)
-
-Execution:
-  - bash   - Run shell commands
-
-Network:
-  - webfetch - Fetch web content
-
-Task Management:
-  - todowrite - Manage tasks/plans (REPLACES update_plan)
-  - todoread  - Read current plan
-</available_tools>
-
-<substitution_rules priority="0">
-Base instruction says:    You MUST use instead:
-apply_patch           ->   patch (preferred if available), otherwise edit/apply_patch based on actual tool list
-update_plan           ->   todowrite
-read_plan             ->   todoread
-absolute paths        ->   relative paths
-</substitution_rules>
-
-<verification_checklist priority="0">
-Before file/plan modifications:
-1. Am I using the actual available edit tool name (edit, patch, or apply_patch)?
-2. Am I using "todowrite" NOT "update_plan"?
-3. Is this tool in the approved list above?
-4. Am I using relative paths?
-
-If ANY answer is NO -> STOP and correct before proceeding.
-</verification_checklist>
-
-<hashline_workflow priority="0">
-When hashline_read is available:
-1. call hashline_read on the file
-2. edit/apply_patch using lineRef/endLineRef + operation + content
-3. use oldString/newString only as fallback, and only with literal file text (no template placeholders)
-</hashline_workflow>
-
-<safety_rules priority="0">
-- Never run destructive git commands (\`git reset --hard\`, \`git checkout --\`) unless explicitly requested by the user.
-- Never call \`request_user_input\` unless collaboration mode is explicitly Plan mode.
-</safety_rules>
+export const TOOL_REMAP_MESSAGE = `<user_instructions priority="0">
+<environment_override priority="0">
+YOU ARE IN A DIFFERENT ENVIRONMENT. These instructions override ALL previous tool references.
+</environment_override>
+
+<tool_replacements priority="0">
+<critical_rule priority="0">
+apply_patch/applyPatch are Codex names, but host tool names vary by version.
+- Inspect the actual tool list before editing.
+- If edit exists: use edit for precise in-place string replacements and hashline edits.
+- If edit is absent and apply_patch exists: use apply_patch for those precise/hashline edits in this plugin.
+- For diff-style or multi-line structural edits: use patch if available, otherwise use apply_patch.
+- In this plugin, edit/apply_patch support hashline refs (lineRef, endLineRef, operation, content)
+</critical_rule>
+
+<critical_rule priority="0">
+UPDATE_PLAN DOES NOT EXIST -> USE "todowrite" INSTEAD
+- NEVER use: update_plan, updatePlan
+- ALWAYS use: todowrite for ALL task/plan operations
+- Use todoread to read current plan
+- Before plan operations: Verify you're using "todowrite", NOT "update_plan"
+</critical_rule>
+</tool_replacements>
+
+<available_tools priority="0">
+File Operations:
+  - write  - Create new files (if available)
+  - edit   - Modify existing files with string replacement (version-dependent)
+  - oldString must be literal text from the current file; never pass unresolved placeholders like \${TARGET_SNIPPET}
+  - apply_patch - May be the edit/patch tool name in newer host builds (version-dependent)
+  - hashline_read - Read lines with hashline refs (L<line>#<hash>) for deterministic edits
+  - patch  - Apply diff patches (version-dependent)
+  - read   - Read file contents
+
+Search/Discovery:
+  - grep   - Search file contents
+  - glob   - Find files by pattern
+  - list   - List directories (if available)
+
+Execution:
+  - bash   - Run shell commands
+
+Network:
+  - webfetch - Fetch web content
+
+Task Management:
+  - todowrite - Manage tasks/plans (REPLACES update_plan)
+  - todoread  - Read current plan
+</available_tools>
+
+<substitution_rules priority="0">
+Base instruction says:    You MUST use instead:
+apply_patch           ->   patch (preferred if available), otherwise edit/apply_patch based on actual tool list
+update_plan           ->   todowrite
+read_plan             ->   todoread
+absolute paths        ->   relative paths
+</substitution_rules>
+
+<verification_checklist priority="0">
+Before file/plan modifications:
+1. Am I using the actual available edit tool name (edit, patch, or apply_patch)?
+2. Am I using "todowrite" NOT "update_plan"?
+3. Is this tool in the approved list above?
+4. Am I using relative paths?
+
+If ANY answer is NO -> STOP and correct before proceeding.
+</verification_checklist>
+
+<hashline_workflow priority="0">
+When hashline_read is available:
+1. call hashline_read on the file
+2. edit/apply_patch using lineRef/endLineRef + operation + content
+3. use oldString/newString only as fallback, and only with literal file text (no template placeholders)
+</hashline_workflow>
+
+<safety_rules priority="0">
+- Never run destructive git commands (\`git reset --hard\`, \`git checkout --\`) unless explicitly requested by the user.
+- Never call \`request_user_input\` unless collaboration mode is explicitly Plan mode.
+</safety_rules>
 </user_instructions>`;

package/dist/lib/quota-cache.d.ts

@@ -4,6 +4,10 @@ export interface QuotaCacheWindow {
     resetAtMs?: number;
 }
 export interface QuotaCacheEntry {
+    /** Account-validated native usage permission; never inferred from percentages. */
+    ordinaryUsageAllowed?: boolean | null;
+    /** Native permission timestamp; header refreshes must not extend its lifetime. */
+    ordinaryUsageCheckedAt?: number;
     primingCompleted?: boolean;
     /** Completion/failure time, independent of the quota header observation. */
     primingObservedAt?: number;

package/dist/lib/quota-readiness.d.ts

@@ -1,6 +1,6 @@
 import type { QuotaCacheData, QuotaCacheEntry } from "./quota-cache.js";
 import type { AccountMetadataV3 } from "./storage.js";
-export type QuotaCacheAccountRef = Pick<AccountMetadataV3, "accountId" | "email" | "recordId" | "workspaces" | "currentWorkspaceIndex"> & Partial<Pick<AccountMetadataV3, "refreshToken" | "addedAt" | "accessToken">>;
+export type QuotaCacheAccountRef = Pick<AccountMetadataV3, "accountId" | "email" | "recordId" | "workspaces" | "currentWorkspaceIndex"> & Partial<Pick<AccountMetadataV3, "refreshToken" | "addedAt" | "accessToken" | "codexCliMirror">>;
 export declare function normalizeQuotaAccountId(value: string | undefined): string | null;
 export declare function normalizeQuotaEmail(value: string | undefined): string | null;
 export declare function hasUniqueQuotaAccountId(accounts: readonly QuotaCacheAccountRef[], account: QuotaCacheAccountRef): boolean;

package/dist/lib/quota-readiness.js

@@ -1,4 +1,5 @@
-import { extractAccountId } from "./auth/token-utils.js";
+import { RATE_LIMIT_CACHE_TTL_MS } from "./constants.js";
+import { extractAccountId, nativeWorkspaceIdentity } from "./auth/token-utils.js";
 import { createHash } from "node:crypto";
 import { resolveAccountRecordId } from "./storage/record-identity.js";
 export function normalizeQuotaAccountId(value) {
@@ -89,6 +90,11 @@ export function isQuotaCacheEntryExhausted(entry, now = Date.now()) {
     // Codex quota windows are cumulative gates: a 0% remaining active window blocks use
     // even if another window still has quota left.
     const updatedAt = entry?.updatedAt;
+    // Stale usage is unknown, not proof that the server still rejects requests.
+    if (typeof updatedAt === "number" &&
+        Number.isFinite(updatedAt) &&
+        now >= updatedAt + RATE_LIMIT_CACHE_TTL_MS)
+        return false;
     return (quotaWindowIsExhausted(entry?.primary, now, updatedAt) ||
         quotaWindowIsExhausted(entry?.secondary, now, updatedAt));
 }
@@ -100,9 +106,10 @@ export function quotaWorkspaceKey(account, workspaceId) {
 }
 /** Display the selected workspace; callers routing another scope must pass that exact workspace. */
 export function quotaWorkspaceId(account) {
-    return account.workspaces?.length
+    const selectedId = account.workspaces?.length
         ? account.workspaces[account.currentWorkspaceIndex ?? 0]?.id.trim()
         : account.accountId?.trim() || extractAccountId(account.accessToken);
+    return nativeWorkspaceIdentity({ access: account.accessToken, codexCliMirror: account.codexCliMirror }, selectedId);
 }
 /** Read exact-workspace quota, using legacy binding entries only for that binding. */
 export function findQuotaCacheEntryForAccount(cache, account, accounts, emailFallbackState = buildQuotaEmailFallbackState(accounts), workspaceId = quotaWorkspaceId(account)) {

package/dist/lib/request/rate-limit-decision.js

@@ -181,7 +181,7 @@ const DEADLINE_SENTENCES = {
     "available-again": (resetAt) => `the account is expected to be available again at ${resetAt}`,
     "next-attempt": (resetAt) => `the next attempt is allowed at ${resetAt}`,
     "cooldown-ends": (resetAt) => `the cooldown ends at ${resetAt}`,
-    "rate-limit-reset": (resetAt) => `the rate limit resets at ${resetAt}`,
+    "rate-limit-reset": (resetAt) => `the cached rate limit will be rechecked at ${resetAt}`,
 };
 /**
  * Every cooldown variant is bounded by the same `coolingDownUntil` field, so

package/dist/lib/runtime/account-reset-credits.d.ts

@@ -1,15 +1,19 @@
 import { AccountManager } from '../accounts.js';
 import { type AccountMetadataV3 } from '../storage.js';
-import { ResetCreditService, type ResetTarget } from './reset-credits.js';
+import { ResetCreditService, type ResetCreditDetail, type ResetTarget } from './reset-credits.js';
 export declare function resetTargetForStoredAccount(account: AccountMetadataV3): ResetTarget | null;
 export declare function isResetTargetEnabled(account: AccountMetadataV3, target: ResetTarget): boolean;
 export declare function createResetCreditService(manager?: AccountManager): ResetCreditService;
 export declare function loadResetCreditState(): Promise<{
-    version: 1;
+    version: 1 | 2;
     policy: "last-resort" | "manual";
     snapshots: Record<string, {
         updatedAt: number;
         availableCount: number | null;
+        credits?: {
+            expiresAt?: number | null | undefined;
+            title?: string | null | undefined;
+        }[] | null | undefined;
         ordinaryUsageAllowed: boolean | null;
         planType: string | null;
         primary: {
@@ -26,6 +30,7 @@ export declare function loadResetCreditState(): Promise<{
     pending?: {
         key: string;
         idempotencyKey: string;
+        creditId?: string | undefined;
     } | undefined;
     lastAutomaticCheckAt?: number | undefined;
     lastRedemptionAt?: number | undefined;
@@ -38,4 +43,8 @@ export declare function loadResetCreditState(): Promise<{
 }>;
 /** Local terminal labels only; never used in provider requests or public artifacts. */
 export declare function resetAccountLabel(account: Pick<AccountMetadataV3, "email">, index: number): string;
+/** Strips terminal control codes, invisible formatters, and whitespace before printing credit titles. */
+export declare function sanitizeCreditTitle(title: string | null | undefined): string | null;
+/** One local terminal line per credit row; expiresAt is Unix seconds and null means it never expires. */
+export declare function formatResetCreditLine(credit: ResetCreditDetail, index: number): string;
 export declare function refreshAndPrintResetCredits(log: (message: string) => void): Promise<void>;

package/dist/lib/runtime/account-reset-credits.js

@@ -1,9 +1,9 @@
 import { join } from 'node:path';
-import { AccountManager, extractAccountId, resolveAccountRecordId, sanitizeEmail } from '../accounts.js';
+import { AccountManager, resolveAccountRecordId, sanitizeEmail } from '../accounts.js';
 import { loadAccounts } from '../storage.js';
 import { getCodexMultiAuthDir } from '../runtime-paths.js';
 import { ensureFreshAccessToken } from './rotation-token-refresh.js';
-import { modelScopeId, workspaceModelScopes } from './workspace-model-scopes.js';
+import { modelScopeId, workspaceModelScopes, nativeWorkspaceIdentity } from './workspace-model-scopes.js';
 import { nativeRateLimitsRpc } from './native-rate-limits.js';
 import { codexCliAccountIdFor } from '../auth/token-utils.js';
 import { isRecord } from '../utils.js';
@@ -11,10 +11,13 @@ import { ResetCreditService } from './reset-credits.js';
 import { withCheckProgress } from '../ui/check-progress.js';
 export function resetTargetForStoredAccount(account) {
     // Organization display aliases are not native ChatGPT workspace identities.
-    const stored = account.accountId?.trim();
-    const id = stored?.startsWith("org-") ? extractAccountId(account.accessToken)?.trim() : stored;
+    const selected = account.workspaces?.length ? account.workspaces[account.currentWorkspaceIndex ?? 0] : undefined;
+    if (account.workspaces?.length && (!selected || selected.enabled === false))
+        return null;
+    const stored = (selected?.id ?? account.accountId)?.trim();
+    const id = nativeWorkspaceIdentity({ access: account.accessToken, codexCliMirror: account.codexCliMirror }, stored);
     const workspace = account.workspaces?.find(w => w.id === id);
-    if (!id || id.startsWith("org-") || account.enabled === false || workspace?.enabled === false)
+    if (!id || id.startsWith("org-") || account.enabled === false || (!selected && workspace?.enabled === false))
         return null;
     return { key: modelScopeId('oauth', resolveAccountRecordId(account), id), accountId: id };
 }
@@ -24,8 +27,7 @@ export function isResetTargetEnabled(account, target) {
     const canonical = resetTargetForStoredAccount(account);
     if (canonical?.key === target.key && canonical.accountId === target.accountId)
         return true;
-    const scopeKey = modelScopeId('oauth', resolveAccountRecordId(account), target.accountId);
-    return !target.accountId.startsWith('org-') && scopeKey === target.key && Boolean(account.workspaces?.some(w => w.id === target.accountId && w.enabled !== false));
+    return false;
 }
 export function createResetCreditService(manager) {
     const auth = async (target) => {
@@ -43,17 +45,17 @@ export function createResetCreditService(manager) {
         return { accessToken: fresh.accessToken, accountId: target.accountId, expiresAt: fresh.account.expires ?? 0, codexCliMirror: current.codexCliMirror };
     };
     return new ResetCreditService(join(getCodexMultiAuthDir(), 'reset-credits.json'), {
-        read: async (target) => {
+        read: async (target, { creditDetails }) => {
             // The backend answers for the id written into its auth.json (the mirror id when one
             // applies). Verify the reply against that id; the snapshot stays keyed on the target.
             const freshAuth = await auth(target);
             const sent = codexCliAccountIdFor(freshAuth, freshAuth.accessToken) ?? freshAuth.accountId;
-            const reply = await nativeRateLimitsRpc(freshAuth, 'account/rateLimits/read', { excludeResetCreditDetails: true });
+            const reply = await nativeRateLimitsRpc(freshAuth, 'account/rateLimits/read', { excludeResetCreditDetails: !creditDetails });
             if (!isRecord(reply) || reply.accountId !== sent)
                 throw Error('Reset credit workspace identity mismatch');
             return { ...reply, accountId: target.accountId };
         },
-        consume: async (target, idempotencyKey) => {
+        consume: async (target, idempotencyKey, creditId) => {
             const freshAuth = await auth(target);
             const disk = await loadAccounts();
             const matches = disk?.accounts.filter(a => isResetTargetEnabled(a, target)) ?? [];
@@ -61,7 +63,7 @@ export function createResetCreditService(manager) {
                 throw Error('Reset account identity is ambiguous; no credit consumed');
             if (matches.length !== 1)
                 throw Error('Reset target was removed, disabled, or changed; no credit consumed');
-            return nativeRateLimitsRpc(freshAuth, 'account/rateLimitResetCredit/consume', { idempotencyKey });
+            return nativeRateLimitsRpc(freshAuth, 'account/rateLimitResetCredit/consume', { idempotencyKey, ...(creditId === undefined ? {} : { creditId }) });
         },
     });
 }
@@ -72,6 +74,22 @@ export function resetAccountLabel(account, index) {
     const printable = email && !/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u.test(email);
     return `Account ${index + 1}${printable ? ` (${email})` : ""}`;
 }
+/** Strips terminal control codes, invisible formatters, and whitespace before printing credit titles. */
+export function sanitizeCreditTitle(title) {
+    if (typeof title !== "string")
+        return null;
+    const trimmed = title.trim();
+    if (!trimmed || /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u.test(trimmed))
+        return null;
+    return trimmed;
+}
+/** One local terminal line per credit row; expiresAt is Unix seconds and null means it never expires. */
+export function formatResetCreditLine(credit, index) {
+    const date = new Date(typeof credit.expiresAt === 'number' && credit.expiresAt > 0 ? credit.expiresAt * 1000 : Number.NaN);
+    const expiry = credit.expiresAt === null ? 'no expiry' : Number.isNaN(date.getTime()) ? 'expires unknown' : `expires ${date.toLocaleString()}`;
+    const title = sanitizeCreditTitle(credit.title);
+    return `   - credit #${index + 1}: ${expiry}${title ? ` (${title})` : ''}`;
+}
 export async function refreshAndPrintResetCredits(log) {
     const storage = await loadAccounts();
     if (!storage?.accounts.length)
@@ -80,7 +98,12 @@ export async function refreshAndPrintResetCredits(log) {
     const targets = storage.accounts.map(resetTargetForStoredAccount).filter((t) => Boolean(t));
     try {
         const snapshots = await withCheckProgress(`Checking reset credits for ${targets.length} accounts`, () => createResetCreditService(manager).refresh(targets), log);
-        storage.accounts.forEach((a, i) => { const target = resetTargetForStoredAccount(a); const count = target ? snapshots[target.key]?.availableCount : undefined; log(`${resetAccountLabel(a, i)}: available subscription resets: ${count ?? 'unknown (not verified)'}`); });
+        storage.accounts.forEach((a, i) => {
+            const target = resetTargetForStoredAccount(a);
+            const snap = target ? snapshots[target.key] : undefined;
+            log(`${resetAccountLabel(a, i)}: available subscription resets: ${snap?.availableCount ?? 'unknown (not verified)'}`);
+            snap?.credits?.forEach((c, idx) => log(formatResetCreditLine(c, idx)));
+        });
     }
     finally {
         await manager.flushPendingSave();

package/dist/lib/runtime/automatic-account-checks.js

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import { promises as fs } from "node:fs";
 import { z } from "zod";
 import { resolveAccountRecordId } from "../accounts.js";
-import { extractAccountId } from "../auth/token-utils.js";
+import { extractAccountId, nativeWorkspaceIdentity } from "../auth/token-utils.js";
 import { getAccountPolicyKey } from "../account-policy.js";
 import { withFileTransactionLock } from "../storage/file-lock.js";
 import { withRetry } from "../fs-retry.js";
@@ -17,11 +17,12 @@ const schema = z.record(z.string().regex(/^sha256:[a-f0-9]{64}$/), z.number().fi
 const retry = { maxAttempts: 6, backoffMs: 25 };
 /** Honor the saved selection; a disabled/invalid selection must not fall back to a sibling. */
 export function automaticCheckWorkspaceId(account) {
+    const identity = { access: account.accessToken, codexCliMirror: account.codexCliMirror };
     if (account.workspaces?.length) {
         const selected = account.workspaces[account.currentWorkspaceIndex ?? 0];
-        return selected?.enabled === false ? undefined : selected?.id.trim() || undefined;
+        return selected?.enabled === false ? undefined : nativeWorkspaceIdentity(identity, selected?.id);
     }
-    return account.accountId?.trim() || extractAccountId(account.accessToken) || undefined;
+    return nativeWorkspaceIdentity(identity, account.accountId?.trim() || extractAccountId(account.accessToken));
 }
 /** Policy keys can be shared by organization members; attempt limits must never be. */
 export function automaticAccountCheckKey(account) {
@@ -72,7 +73,7 @@ export async function runAutomaticAccountChecks(options) {
         // Keep every still-saved workspace's throttle, including temporarily disabled selections.
         const keys = new Set(storage.accounts.flatMap(account => [
             automaticAccountCheckKey(account),
-            ...(account.workspaces ?? []).map(workspace => workspaceAttemptKey(account, workspace.id.trim())),
+            ...(account.workspaces ?? []).map(workspace => workspaceAttemptKey(account, nativeWorkspaceIdentity({ access: account.accessToken, codexCliMirror: account.codexCliMirror }, workspace.id) ?? "")),
         ]));
         for (const key of Object.keys(attempts))
             if (!keys.has(key))
@@ -84,7 +85,7 @@ export async function runAutomaticAccountChecks(options) {
             if (!account)
                 continue;
             const key = automaticAccountCheckKey(account), policy = policies.accounts[getAccountPolicyKey(account)], now = options.now?.() ?? Date.now();
-            if (!policy?.autoPrime || policy.paused || policy.drained || account.enabled === false || account.authInvalidatedAt || (account.coolingDownUntil ?? 0) > now)
+            if (!policy?.autoPrime || policy.paused || policy.drained || policy.emergencyOnly || account.enabled === false || account.authInvalidatedAt || (account.coolingDownUntil ?? 0) > now)
                 continue;
             const lastAttempt = attempts[key];
             if (lastAttempt !== undefined && lastAttempt <= now + FUTURE_SKEW_MS && now - lastAttempt < AUTOMATIC_CHECK_INTERVAL_MS)

package/dist/lib/runtime/automatic-subscription-checks.js

@@ -20,7 +20,8 @@ export function createAutomaticSubscriptionCheck(observe) {
         await saveQuotaCache(cache, baseline);
     });
     return (signal) => runWithStoragePathState(storageState, () => runAutomaticAccountChecks({
-        path: `${path}.automatic-checks.json`, signal, loadPolicies: loadAccountPolicyStore,
+        // Priming may consume quota: malformed permissions must never normalize to OFF.
+        path: `${path}.automatic-checks.json`, signal, loadPolicies: () => loadAccountPolicyStore({ strict: true }),
         loadAccounts: async () => { const snapshot = await read(); return snapshot.verified ? snapshot.storage : null; },
         check: async (storage, index) => {
             const manager = new AccountManager(undefined, storage);
@@ -36,8 +37,8 @@ export function createAutomaticSubscriptionCheck(observe) {
                 // A refresh is an I/O boundary: revalidate removal, policy, auth and workspace changes.
                 const disk = await read();
                 const current = disk.verified ? disk.storage?.accounts.find(row => resolveAccountRecordId(row) === resolveAccountRecordId(fresh.account)) : undefined;
-                const policy = current ? (await loadAccountPolicyStore()).accounts[getAccountPolicyKey(current)] : undefined;
-                if (!disk.storage || !current || current.refreshToken !== fresh.account.refreshToken || current.accessToken !== fresh.accessToken || !policy?.autoPrime || policy.paused || policy.drained || current.enabled === false || current.authInvalidatedAt || (current.coolingDownUntil ?? 0) > Date.now())
+                const policy = current ? (await loadAccountPolicyStore({ strict: true })).accounts[getAccountPolicyKey(current)] : undefined;
+                if (!disk.storage || !current || current.refreshToken !== fresh.account.refreshToken || current.accessToken !== fresh.accessToken || !policy?.autoPrime || policy.paused || policy.drained || policy.emergencyOnly || current.enabled === false || current.authInvalidatedAt || (current.coolingDownUntil ?? 0) > Date.now())
                     return;
                 if (automaticCheckWorkspaceId(current) !== targetId || signal.aborted)
                     return;

package/dist/lib/runtime/model-discovery-status.js

@@ -68,7 +68,7 @@ export async function discoverModelInventory(storage, routes, options = {}) {
     const scopes = manager.getAccountsSnapshot().flatMap(workspaceModelScopes);
     const catalog = new AccountModelCatalog(async (key) => {
         const scope = scopes.find(item => item.id === key);
-        const account = scope?.enabled ? manager.getAccountByIndex(scope.accountIndex) : null;
+        const account = scope?.routable ? manager.getAccountByIndex(scope.accountIndex) : null;
         if (!account || account.enabled === false)
             throw Error("Disabled");
         const fresh = await ensureFreshAccessToken({
@@ -105,7 +105,7 @@ export async function discoverModelInventory(storage, routes, options = {}) {
     }, now);
     try {
         entries.push(...await mapWithConcurrency(scopes, 3, async (scope) => {
-            if (scope.enabled)
+            if (scope.routable)
                 await catalog.list([scope.id]);
             const snapshot = catalog.snapshot(scope.id);
             return { id: scope.id, label: scope.label, kind: "oauth", enabled: scope.enabled, routable: scope.routable, bound: scope.bound, selected: scope.selected,

package/dist/lib/runtime/reset-credit-routing.d.ts

@@ -1,8 +1,8 @@
-import { type AccountManager, type ManagedAccount } from '../accounts.js';
+import type { AccountManager, ManagedAccount } from '../accounts.js';
 import type { ModelFamily } from '../prompts/codex.js';
 import type { QuotaCacheEntry } from '../quota-cache.js';
-import { type ResetCreditService } from './reset-credits.js';
-import type { workspaceModelScopes } from './workspace-model-scopes.js';
+import { type ResetSnapshot, type ResetCreditService, type ResetExhaustionEvidence } from './reset-credits.js';
+import { workspaceModelScopes } from './workspace-model-scopes.js';
 type Scope = ReturnType<typeof workspaceModelScopes>[number];
 export declare function recoverResetQuota(options: {
     model: string;
@@ -19,6 +19,7 @@ export declare function recoverResetQuota(options: {
             snapshots: Awaited<ReturnType<ResetCreditService['status']>>['snapshots'];
         }>;
     };
+    quotaRejections?: ReadonlyMap<string, ResetExhaustionEvidence>;
     observations: Map<string, QuotaCacheEntry>;
     clearQuotaScheduler: (account: ManagedAccount) => void;
     now: () => number;
@@ -37,4 +38,11 @@ export declare function applyConfirmedReset(options: {
     clearQuotaScheduler: (account: ManagedAccount) => void;
     now: number;
 }): boolean;
+/** Unknown, stale, or pending reset state must never authorize backup traffic. */
+export declare function primaryPoolFullyExhausted(scopes: Map<number, Scope[]>, state: {
+    snapshots: Record<string, ResetSnapshot>;
+    pending?: {
+        key: string;
+    };
+} | null, now: number, latestQuota?: (index: number, scope: Scope) => QuotaCacheEntry | null | undefined): boolean;
 export {};

package/dist/lib/runtime/reset-credit-routing.js

@@ -1,8 +1,21 @@
-import { extractAccountId } from '../accounts.js';
 import { LUNA_RESERVE_MODEL } from '../constants.js';
 import { parseModelRoute } from '../model-route-policy.js';
 import { subscriptionQuotaPreference } from './subscription-quota-order.js';
-import { resetSnapshotQuota } from './reset-credits.js';
+import { resetSnapshotQuota, isResetSubscription } from './reset-credits.js';
+import { workspaceModelScopes } from './workspace-model-scopes.js';
+/** Account-level quota blockers belong to the currently routed workspace. */
+function clearRecoveredScopeQuota(options) {
+    const { account, scope, family, model, manager, clearQuotaScheduler } = options;
+    // Recheck selection and enablement: a reset read may outlive a workspace change.
+    if (account.lastRateLimitReason !== 'quota' || !workspaceModelScopes(account).some(current => current.routable && current.id === scope.id && current.accountId === scope.accountId))
+        return false;
+    delete account.rateLimitResetTimes[family];
+    delete account.rateLimitResetTimes[`${family}:${model}`];
+    if (account.cooldownReason === 'rate-limit')
+        manager.clearAccountCooldown(account);
+    clearQuotaScheduler(account);
+    return true;
+}
 export async function recoverResetQuota(options) {
     if (options.model === LUNA_RESERVE_MODEL || !options.native || options.pinned || parseModelRoute(options.model).kind !== 'oauth')
         return false;
@@ -10,39 +23,62 @@ export async function recoverResetQuota(options) {
     const candidates = [...options.scopes].flatMap(([index, scopes]) => { const account = options.manager.getAccountByIndex(index); return account && !account.authInvalidatedAt ? scopes.map(scope => ({ account, scope })) : []; });
     if (!candidates.length)
         return false;
+    const currentScope = (account, scope) => workspaceModelScopes(account).some(current => current.routable && current.id === scope.id && current.accountId === scope.accountId);
+    const rejectionForScope = (account, scope) => {
+        const proof = options.quotaRejections?.get(JSON.stringify([scope.id, options.model]));
+        const latest = options.quotaForScope(account, scope), now = options.now();
+        // An older in-flight response can deliver newer percentage headers. Only a
+        // later authoritative native permission check supersedes a body rejection.
+        const checkedAt = typeof latest?.ordinaryUsageAllowed === 'boolean'
+            ? latest.ordinaryUsageCheckedAt ?? latest.updatedAt : 0;
+        return proof && proof.key === scope.id && proof.accountId === scope.accountId &&
+            Number.isFinite(proof.observedAt) && proof.observedAt <= now && now - proof.observedAt <= 60000 &&
+            proof.observedAt > checkedAt ? proof : undefined;
+    };
     // Any usable capacity (including the reserve), unknown quota, or non-quota
     // failure prevents an automatic credit from being spent.
     if (candidates.some(({ account, scope }) => {
-        if (account.enabled === false || account.authInvalidatedAt || !scope.routable)
+        if (account.enabled === false || account.authInvalidatedAt || !scope.routable || !currentScope(account, scope))
             return true;
         const skip = options.manager.getAccountRuntimeSkipReason(account.index, family, options.model);
         if (skip && !['rate-limited', 'cooling-down:rate-limit'].includes(skip))
             return true;
         const quota = subscriptionQuotaPreference(options.quotaForScope(account, scope), options.now());
-        return !quota.exhausted && !['rate-limited', 'cooling-down:rate-limit'].includes(skip ?? '');
+        return !quota.exhausted && !rejectionForScope(account, scope) && !['rate-limited', 'cooling-down:rate-limit'].includes(skip ?? '');
     }))
         return false;
     candidates.sort((a, b) => Number(b.account.index === options.preferredIndex) - Number(a.account.index === options.preferredIndex) || (options.priorityByAccount?.[a.account.index] ?? 1) - (options.priorityByAccount?.[b.account.index] ?? 1));
     const targets = candidates.filter(({ scope }) => !scope.accountId.startsWith("org-")).map(({ scope }) => ({ key: scope.id, accountId: scope.accountId }));
-    await options.service.automatic(targets);
+    const evidence = candidates.flatMap(({ account, scope }) => {
+        if (scope.accountId.startsWith("org-"))
+            return [];
+        const rejection = rejectionForScope(account, scope);
+        if (rejection)
+            return [rejection];
+        const quota = subscriptionQuotaPreference(options.quotaForScope(account, scope), options.now());
+        return quota.exhausted && quota.observedAt !== null
+            ? [{ key: scope.id, accountId: scope.accountId, observedAt: quota.observedAt }] : [];
+    });
+    await options.service.automatic(targets, evidence);
     const state = await options.service.status();
     let recovered = false;
     for (const { account, scope } of candidates) {
         const snapshot = state.snapshots[scope.id];
         const previous = options.quotaForScope(account, scope);
-        if (!snapshot || snapshot.updatedAt < (previous?.updatedAt ?? 0) || options.now() - snapshot.updatedAt > 60000 || snapshot.updatedAt > options.now())
+        const rejectedAt = rejectionForScope(account, scope)?.observedAt ?? 0;
+        // Healthy headers may arrive late from an older in-flight request. Native
+        // permission chronology wins there; unknown, exhausted, and failed reads do not.
+        const healthyHeaders = snapshot?.ordinaryUsageAllowed === true && previous?.status === 200 &&
+            (subscriptionQuotaPreference(previous, options.now()).remainingPercent ?? 0) > 0;
+        const previousAt = healthyHeaders
+            ? typeof previous?.ordinaryUsageAllowed === 'boolean' ? previous.ordinaryUsageCheckedAt ?? previous.updatedAt : 0
+            : previous?.updatedAt ?? 0;
+        if (!snapshot || snapshot.updatedAt < Math.max(previousAt, rejectedAt) || options.now() - snapshot.updatedAt > 60000 || snapshot.updatedAt > options.now())
             continue;
         options.observations.set(JSON.stringify([scope.id, options.model]), resetSnapshotQuota(snapshot));
         if (snapshot.ordinaryUsageAllowed !== true)
             continue;
-        // Do not clear sibling workspace/model throttles or authentication failures.
-        if ((scope.bound || (account.accountId?.startsWith('org-') && scope.accountId === extractAccountId(account.access))) && account.lastRateLimitReason === 'quota') {
-            delete account.rateLimitResetTimes[family];
-            delete account.rateLimitResetTimes[`${family}:${options.model}`];
-            if (account.cooldownReason === 'rate-limit')
-                options.manager.clearAccountCooldown(account);
-            options.clearQuotaScheduler(account);
-        }
+        clearRecoveredScopeQuota({ ...options, account, scope, family });
         recovered = true;
     }
     if (recovered)
@@ -57,13 +93,22 @@ export function applyConfirmedReset(options) {
     if (!s || options.lastRedemptionAt === undefined || s.updatedAt < options.lastRedemptionAt || s.ordinaryUsageAllowed !== true || s.updatedAt <= (options.previous?.updatedAt ?? 0) || options.now - s.updatedAt > 60000 || s.updatedAt > options.now)
         return false;
     options.observations.set(JSON.stringify([options.scope.id, options.model]), resetSnapshotQuota(s));
-    if ((options.scope.bound || (options.account.accountId?.startsWith('org-') && options.scope.accountId === extractAccountId(options.account.access))) && options.account.lastRateLimitReason === 'quota') {
-        delete options.account.rateLimitResetTimes[options.family];
-        delete options.account.rateLimitResetTimes[`${options.family}:${options.model}`];
-        if (options.account.cooldownReason === 'rate-limit')
-            options.manager.clearAccountCooldown(options.account);
-        options.clearQuotaScheduler(options.account);
+    if (clearRecoveredScopeQuota(options))
         options.manager.saveToDiskDebounced();
-    }
     return true;
 }
+/** Unknown, stale, or pending reset state must never authorize backup traffic. */
+export function primaryPoolFullyExhausted(scopes, state, now, latestQuota) {
+    const primary = [...scopes].flatMap(([index, rows]) => rows.map(scope => ({ index, scope })));
+    return primary.length > 0 && !!state && !state.pending && primary.every(({ index, scope }) => {
+        const snapshot = state.snapshots[scope.id];
+        const latest = latestQuota?.(index, scope);
+        if (snapshot && latest && latest.updatedAt >= snapshot.updatedAt &&
+            !subscriptionQuotaPreference(latest, now).exhausted)
+            return false;
+        return scope.routable && !!snapshot && Number.isFinite(snapshot.updatedAt) &&
+            snapshot.updatedAt <= now && now - snapshot.updatedAt <= 60_000 &&
+            isResetSubscription(snapshot) && snapshot.ordinaryUsageAllowed === false &&
+            snapshot.availableCount === 0;
+    });
+}