@cortexkit/opencode-antigravity-auth 1.0.0 → 1.1.0

package/dist/src/plugin/accounts.js

@@ -1,5 +1,5 @@
 import { formatRefreshParts, parseRefreshParts } from "./auth";
-import { loadAccounts, saveAccounts } from "./storage";
+import { loadAccounts, saveAccounts, saveAccountsReplace } from "./storage";
 import { getHealthTracker, getTokenTracker, selectHybridAccount } from "./rotation";
 import { generateFingerprint, updateFingerprintVersion, MAX_FINGERPRINT_HISTORY } from "./fingerprint";
 import { getModelFamily } from "./transform/model-resolver";
@@ -193,6 +193,8 @@ export function computeSoftQuotaCacheTtlMs(ttlConfig, refreshIntervalMinutes) {
     }
     return ttlConfig * 60 * 1000;
 }
+const ACCOUNT_SESSION_STATE_TTL_MS = 24 * 60 * 60 * 1000;
+const MAX_ACCOUNT_SESSION_STATES = 256;
 /**
  * In-memory multi-account manager with sticky account selection.
  *
@@ -221,6 +223,7 @@ export class AccountManager {
     sessionStartTime = Date.now();
     sessionRequestCounts = new Map();
     sessionUsedAccounts = new Set();
+    requestSessionStates = new Map();
     static async loadFromDisk(authFallback) {
         const stored = await loadAccounts();
         return new AccountManager(authFallback, stored);
@@ -266,9 +269,14 @@ export class AccountManager {
                     cachedQuota: acc.cachedQuota,
                     cachedQuotaUpdatedAt: acc.cachedQuotaUpdatedAt,
                     dailyRequestCounts: acc.dailyRequestCounts,
-                    verificationRequired: acc.verificationRequired, verificationRequiredAt: acc.verificationRequiredAt,
+                    verificationRequired: acc.verificationRequired,
+                    verificationRequiredAt: acc.verificationRequiredAt,
                     verificationRequiredReason: acc.verificationRequiredReason,
                     verificationUrl: acc.verificationUrl,
+                    accountIneligible: acc.accountIneligible,
+                    accountIneligibleAt: acc.accountIneligibleAt,
+                    accountIneligibleReason: acc.accountIneligibleReason,
+                    eligibilityStateUpdatedAt: acc.eligibilityStateUpdatedAt,
                 };
             })
                 .filter((a) => a !== null);
@@ -350,11 +358,111 @@ export class AccountManager {
     getEnabledAccounts() {
         return this.accounts.filter((account) => account.enabled !== false);
     }
+    getEffectiveSoftQuotaThreshold(thresholdPercent) {
+        // Soft-quota protection only has a purpose when another enabled account
+        // exists to rotate to. Never block the sole usable account.
+        return this.getEnabledAccounts().length > 1 ? thresholdPercent : 100;
+    }
     getAccountsSnapshot() {
         return this.accounts.map((a) => ({ ...a, parts: { ...a.parts }, rateLimitResetTimes: { ...a.rateLimitResetTimes } }));
     }
-    getCurrentAccountForFamily(family) {
-        const currentIndex = this.currentAccountIndexByFamily[family];
+    getRequestSessionState(identity) {
+        const now = nowMs();
+        this.pruneRequestSessionStates(now, identity.id);
+        const existing = this.requestSessionStates.get(identity.id);
+        if (existing) {
+            existing.lastAccessedAt = now;
+            if (identity.parentId) {
+                existing.parentId = identity.parentId;
+            }
+            return existing;
+        }
+        const state = {
+            parentId: identity.parentId ?? null,
+            currentAccountIndexByFamily: { claude: -1, gemini: -1 },
+            cursorByFamily: { ...this.cursorByFamily },
+            offsetAppliedByFamily: { claude: false, gemini: false },
+            usedAccounts: new Set(),
+            lastAccessedAt: now,
+        };
+        this.requestSessionStates.set(identity.id, state);
+        return state;
+    }
+    pruneRequestSessionStates(now, preservedId) {
+        const expiry = now - ACCOUNT_SESSION_STATE_TTL_MS;
+        for (const [id, state] of this.requestSessionStates) {
+            if (id !== preservedId && state.lastAccessedAt < expiry) {
+                this.requestSessionStates.delete(id);
+            }
+        }
+        if (this.requestSessionStates.size < MAX_ACCOUNT_SESSION_STATES || this.requestSessionStates.has(preservedId)) {
+            return;
+        }
+        let oldestId = null;
+        let oldestAccess = Number.POSITIVE_INFINITY;
+        for (const [id, state] of this.requestSessionStates) {
+            if (id !== preservedId && state.lastAccessedAt < oldestAccess) {
+                oldestId = id;
+                oldestAccess = state.lastAccessedAt;
+            }
+        }
+        if (oldestId) {
+            this.requestSessionStates.delete(oldestId);
+        }
+    }
+    getActiveIndex(family, identity) {
+        return identity
+            ? this.getRequestSessionState(identity).currentAccountIndexByFamily[family]
+            : this.currentAccountIndexByFamily[family];
+    }
+    setActiveIndex(family, index, identity) {
+        if (!identity) {
+            this.currentAccountIndexByFamily[family] = index;
+            return;
+        }
+        const state = this.getRequestSessionState(identity);
+        state.currentAccountIndexByFamily[family] = index;
+        if (!state.parentId) {
+            // Preserve a useful persisted starting point without coupling active root sessions.
+            this.currentAccountIndexByFamily[family] = index;
+        }
+    }
+    getCursor(family, identity) {
+        return identity
+            ? this.getRequestSessionState(identity).cursorByFamily[family]
+            : this.cursorByFamily[family];
+    }
+    advanceCursor(family, identity) {
+        const nextGlobalCursor = this.cursorByFamily[family] + 1;
+        this.cursorByFamily[family] = nextGlobalCursor;
+        if (identity) {
+            this.getRequestSessionState(identity).cursorByFamily[family] += 1;
+        }
+    }
+    getUsedAccounts(identity) {
+        return identity ? this.getRequestSessionState(identity).usedAccounts : this.sessionUsedAccounts;
+    }
+    preferAccountOutsideParent(accounts, family, identity) {
+        if (!identity) {
+            return accounts;
+        }
+        const parentId = this.getRequestSessionState(identity).parentId;
+        if (!parentId) {
+            return accounts;
+        }
+        const parentState = this.requestSessionStates.get(parentId);
+        const parentIndex = parentState?.currentAccountIndexByFamily[family] ?? -1;
+        if (parentIndex < 0) {
+            return accounts;
+        }
+        const isolated = accounts.filter((account) => account.index !== parentIndex);
+        return isolated.length > 0 ? isolated : accounts;
+    }
+    deleteSessionState(sessionId) {
+        this.requestSessionStates.delete(sessionId);
+    }
+    getCurrentAccountForFamily(family, identity) {
+        const currentIndex = this.getActiveIndex(family, identity);
         if (currentIndex >= 0 && currentIndex < this.accounts.length) {
             const account = this.accounts[currentIndex] ?? null;
             // Only return account if it's enabled - disabled accounts should not be selected
@@ -364,9 +472,9 @@ export class AccountManager {
         }
         return null;
     }
-    markSwitched(account, reason, family) {
+    markSwitched(account, reason, family, identity) {
         account.lastSwitchReason = reason;
-        this.currentAccountIndexByFamily[family] = account.index;
+        this.setActiveIndex(family, account.index, identity);
     }
     /**
      * Check if we should show an account switch toast.
@@ -383,41 +491,56 @@ export class AccountManager {
         this.lastToastAccountIndex = accountIndex;
         this.lastToastTime = nowMs();
     }
-    getCurrentOrNextForFamily(family, model, strategy = 'sticky', headerStyle = 'antigravity', pidOffsetEnabled = false, softQuotaThresholdPercent = 100, softQuotaCacheTtlMs = 10 * 60 * 1000) {
+    getCurrentOrNextForFamily(family, model, strategy = 'sticky', headerStyle = 'antigravity', pidOffsetEnabled = false, softQuotaThresholdPercent = 100, softQuotaCacheTtlMs = 10 * 60 * 1000, identity) {
         const quotaKey = getQuotaKey(family, headerStyle, model);
+        const effectiveSoftQuotaThreshold = this.getEffectiveSoftQuotaThreshold(softQuotaThresholdPercent);
+        // OpenCode may run many root and child sessions concurrently in one plugin
+        // process. Pin each exact session until its account becomes unavailable.
+        if (identity) {
+            const pinned = this.getCurrentAccountForFamily(family, identity);
+            if (pinned) {
+                clearExpiredRateLimits(pinned);
+                const unavailable = isRateLimitedForHeaderStyle(pinned, family, headerStyle, model) ||
+                    isOverSoftQuotaThreshold(pinned, family, effectiveSoftQuotaThreshold, softQuotaCacheTtlMs, model) ||
+                    this.isAccountCoolingDown(pinned);
+                if (!unavailable) {
+                    this.markTouchedForQuota(pinned, quotaKey);
+                    return pinned;
+                }
+            }
+        }
         if (strategy === 'round-robin') {
-            const next = this.getNextForFamily(family, model, headerStyle, softQuotaThresholdPercent, softQuotaCacheTtlMs);
+            const next = this.getNextForFamily(family, model, headerStyle, effectiveSoftQuotaThreshold, softQuotaCacheTtlMs, identity);
             if (next) {
                 this.markTouchedForQuota(next, quotaKey);
-                this.currentAccountIndexByFamily[family] = next.index;
+                this.setActiveIndex(family, next.index, identity);
             }
             return next;
         }
         if (strategy === 'hybrid') {
             const healthTracker = getHealthTracker();
             const tokenTracker = getTokenTracker();
-            const accountsWithMetrics = this.accounts
-                .filter(acc => acc.enabled !== false)
-                .map(acc => {
+            const eligibleAccounts = this.preferAccountOutsideParent(this.accounts.filter(acc => acc.enabled !== false), family, identity);
+            const accountsWithMetrics = eligibleAccounts.map(acc => {
                 clearExpiredRateLimits(acc);
                 return {
                     index: acc.index,
                     lastUsed: acc.lastUsed,
                     healthScore: healthTracker.getScore(acc.index),
                     isRateLimited: isRateLimitedForFamily(acc, family, model) ||
-                        isOverSoftQuotaThreshold(acc, family, softQuotaThresholdPercent, softQuotaCacheTtlMs, model),
+                        isOverSoftQuotaThreshold(acc, family, effectiveSoftQuotaThreshold, softQuotaCacheTtlMs, model),
                     isCoolingDown: this.isAccountCoolingDown(acc),
                 };
             });
             // Get current account index for stickiness
-            const currentIndex = this.currentAccountIndexByFamily[family] ?? null;
+            const currentIndex = this.getActiveIndex(family, identity);
             const selectedIndex = selectHybridAccount(accountsWithMetrics, tokenTracker, currentIndex);
             if (selectedIndex !== null) {
                 const selected = this.accounts[selectedIndex];
                 if (selected) {
                     selected.lastUsed = nowMs();
                     this.markTouchedForQuota(selected, quotaKey);
-                    this.currentAccountIndexByFamily[family] = selected.index;
+                    this.setActiveIndex(family, selected.index, identity);
                     return selected;
                 }
             }
@@ -425,50 +548,57 @@ export class AccountManager {
         // Fallback: sticky selection (used when hybrid finds no candidates)
         // PID-based offset for multi-session distribution (opt-in)
         // Different sessions (PIDs) will prefer different starting accounts
-        if (pidOffsetEnabled && !this.sessionOffsetApplied[family] && this.accounts.length > 1) {
+        const offsetApplied = identity
+            ? this.getRequestSessionState(identity).offsetAppliedByFamily
+            : this.sessionOffsetApplied;
+        if (pidOffsetEnabled && !offsetApplied[family] && this.accounts.length > 1) {
             const pidOffset = process.pid % this.accounts.length;
-            const baseIndex = this.currentAccountIndexByFamily[family] ?? 0;
+            const activeIndex = this.getActiveIndex(family, identity);
+            const baseIndex = activeIndex >= 0 ? activeIndex : this.getCursor(family, identity);
             const newIndex = (baseIndex + pidOffset) % this.accounts.length;
             debugLogToFile(`[Account] Applying PID offset: pid=${process.pid} offset=${pidOffset} family=${family} index=${baseIndex}->${newIndex}`);
-            this.currentAccountIndexByFamily[family] = newIndex;
-            this.sessionOffsetApplied[family] = true;
+            this.setActiveIndex(family, newIndex, identity);
+            offsetApplied[family] = true;
         }
-        const current = this.getCurrentAccountForFamily(family);
+        const current = this.getCurrentAccountForFamily(family, identity);
         if (current) {
             clearExpiredRateLimits(current);
             const isLimitedForRequestedStyle = isRateLimitedForHeaderStyle(current, family, headerStyle, model);
-            const isOverThreshold = isOverSoftQuotaThreshold(current, family, softQuotaThresholdPercent, softQuotaCacheTtlMs, model);
+            const isOverThreshold = isOverSoftQuotaThreshold(current, family, effectiveSoftQuotaThreshold, softQuotaCacheTtlMs, model);
             if (!isLimitedForRequestedStyle && !isOverThreshold && !this.isAccountCoolingDown(current)) {
                 this.markTouchedForQuota(current, quotaKey);
                 return current;
             }
         }
-        const next = this.getNextForFamily(family, model, headerStyle, softQuotaThresholdPercent, softQuotaCacheTtlMs);
+        const next = this.getNextForFamily(family, model, headerStyle, effectiveSoftQuotaThreshold, softQuotaCacheTtlMs, identity);
         if (next) {
             this.markTouchedForQuota(next, quotaKey);
-            this.currentAccountIndexByFamily[family] = next.index;
+            this.setActiveIndex(family, next.index, identity);
         }
         return next;
     }
-    getNextForFamily(family, model, headerStyle = "antigravity", softQuotaThresholdPercent = 100, softQuotaCacheTtlMs = 10 * 60 * 1000) {
-        const available = this.accounts.filter((a) => {
-            clearExpiredRateLimits(a);
-            return a.enabled !== false &&
-                !isRateLimitedForHeaderStyle(a, family, headerStyle, model) &&
-                !isOverSoftQuotaThreshold(a, family, softQuotaThresholdPercent, softQuotaCacheTtlMs, model) &&
-                !this.isAccountCoolingDown(a);
+    getNextForFamily(family, model, headerStyle = "antigravity", softQuotaThresholdPercent = 100, softQuotaCacheTtlMs = 10 * 60 * 1000, identity) {
+        const effectiveSoftQuotaThreshold = this.getEffectiveSoftQuotaThreshold(softQuotaThresholdPercent);
+        const allAvailable = this.accounts.filter((account) => {
+            clearExpiredRateLimits(account);
+            return account.enabled !== false &&
+                !isRateLimitedForHeaderStyle(account, family, headerStyle, model) &&
+                !isOverSoftQuotaThreshold(account, family, effectiveSoftQuotaThreshold, softQuotaCacheTtlMs, model) &&
+                !this.isAccountCoolingDown(account);
         });
+        const available = this.preferAccountOutsideParent(allAvailable, family, identity);
         if (available.length === 0) {
             return null;
         }
-        const sessionUsed = available.filter(a => this.sessionUsedAccounts.has(a.index));
+        const usedAccounts = this.getUsedAccounts(identity);
+        const sessionUsed = available.filter(account => usedAccounts.has(account.index));
         const candidates = sessionUsed.length > 0 ? sessionUsed : available;
-        const cursor = this.cursorByFamily[family];
+        const cursor = this.getCursor(family, identity);
         const account = candidates[cursor % candidates.length];
         if (!account) {
             return null;
         }
-        this.cursorByFamily[family] = cursor + 1;
+        this.advanceCursor(family, identity);
         return account;
     }
     markRateLimited(account, retryAfterMs, family, headerStyle = "antigravity", model) {
@@ -486,16 +616,16 @@ export class AccountManager {
             account.lastUsed = nowMs();
         }
     }
-    recordSessionUsage(accountIndex) {
-        this.sessionUsedAccounts.add(accountIndex);
+    recordSessionUsage(accountIndex, identity) {
+        this.getUsedAccounts(identity).add(accountIndex);
     }
-    wasUsedInSession(accountIndex) {
-        return this.sessionUsedAccounts.has(accountIndex);
+    wasUsedInSession(accountIndex, identity) {
+        return this.getUsedAccounts(identity).has(accountIndex);
     }
-    shouldProactivelyRotate(family, model, thresholdPercent, cacheTtlMs) {
+    shouldProactivelyRotate(family, model, thresholdPercent, cacheTtlMs, identity) {
         if (thresholdPercent <= 0)
             return false;
-        const current = this.getCurrentAccountForFamily(family);
+        const current = this.getCurrentAccountForFamily(family, identity);
         if (!current || !current.cachedQuota || current.cachedQuotaUpdatedAt == null)
             return false;
         const age = nowMs() - current.cachedQuotaUpdatedAt;
@@ -508,9 +638,9 @@ export class AccountManager {
         const remainingPercent = Math.max(0, Math.min(100, groupData.remainingFraction * 100));
         return remainingPercent < thresholdPercent;
     }
-    proactivelyRotateForFamily(family, model, headerStyle, softQuotaThresholdPercent, softQuotaCacheTtlMs) {
-        const currentIndex = this.currentAccountIndexByFamily[family];
-        const candidates = this.accounts.filter(acc => {
+    proactivelyRotateForFamily(family, model, headerStyle, softQuotaThresholdPercent, softQuotaCacheTtlMs, identity) {
+        const currentIndex = this.getActiveIndex(family, identity);
+        const candidates = this.preferAccountOutsideParent(this.accounts.filter(acc => {
             if (acc.enabled === false)
                 return false;
             if (acc.index === currentIndex)
@@ -523,10 +653,11 @@ export class AccountManager {
             if (this.isAccountCoolingDown(acc))
                 return false;
             return true;
-        });
+        }), family, identity);
         if (candidates.length === 0)
             return null;
-        const warmCandidates = candidates.filter(a => this.sessionUsedAccounts.has(a.index));
+        const usedAccounts = this.getUsedAccounts(identity);
+        const warmCandidates = candidates.filter(account => usedAccounts.has(account.index));
         const pool = warmCandidates.length > 0 ? warmCandidates : candidates;
         const quotaGroup = resolveQuotaGroup(family, model);
         pool.sort((a, b) => {
@@ -539,7 +670,7 @@ export class AccountManager {
             return null;
         const quotaKey = getQuotaKey(family, headerStyle, model);
         this.markTouchedForQuota(selected, quotaKey);
-        this.currentAccountIndexByFamily[family] = selected.index;
+        this.setActiveIndex(family, selected.index, identity);
         return selected;
     }
     markRateLimitedWithReason(account, family, headerStyle, model, reason, retryAfterMs, failureTtlMs = 3600_000) {
@@ -679,6 +810,9 @@ export class AccountManager {
         if (!account) {
             return false;
         }
+        if (enabled && account.accountIneligible) {
+            return false;
+        }
         account.enabled = enabled;
         if (!enabled) {
             for (const family of Object.keys(this.currentAccountIndexByFamily)) {
@@ -696,9 +830,18 @@ export class AccountManager {
         if (!account) {
             return false;
         }
+        const timestamp = nowMs();
         account.verificationRequired = true;
-        account.verificationRequiredAt = nowMs();
+        account.verificationRequiredAt = timestamp;
         account.verificationRequiredReason = reason?.trim() || undefined;
+        if (account.accountIneligible === true ||
+            account.accountIneligibleAt !== undefined ||
+            account.accountIneligibleReason !== undefined) {
+            account.accountIneligible = false;
+            account.accountIneligibleAt = undefined;
+            account.accountIneligibleReason = undefined;
+            account.eligibilityStateUpdatedAt = timestamp;
+        }
         const normalizedVerifyUrl = verifyUrl?.trim();
         if (normalizedVerifyUrl) {
             account.verificationUrl = normalizedVerifyUrl;
@@ -711,23 +854,56 @@ export class AccountManager {
         }
         return true;
     }
-    clearAccountVerificationRequired(accountIndex, enableAccount = false) {
+    markAccountIneligible(accountIndex, reason) {
+        const account = this.accounts[accountIndex];
+        if (!account) {
+            return false;
+        }
+        const timestamp = nowMs();
+        account.accountIneligible = true;
+        account.accountIneligibleAt = timestamp;
+        account.accountIneligibleReason = reason?.trim() || "Google marked this account as ineligible.";
+        account.eligibilityStateUpdatedAt = timestamp;
+        account.verificationRequired = false;
+        account.verificationRequiredAt = undefined;
+        account.verificationRequiredReason = undefined;
+        account.verificationUrl = undefined;
+        if (account.enabled !== false) {
+            this.setAccountEnabled(accountIndex, false);
+        }
+        else {
+            this.requestSaveToDisk();
+        }
+        return true;
+    }
+    clearAccountAccessBlocks(accountIndex, enableAccount = false) {
         const account = this.accounts[accountIndex];
         if (!account) {
             return false;
         }
         const wasVerificationRequired = account.verificationRequired === true;
-        const hadMetadata = (account.verificationRequiredAt !== undefined ||
+        const wasIneligible = account.accountIneligible === true;
+        const hadMetadata = wasVerificationRequired || wasIneligible ||
+            account.verificationRequiredAt !== undefined ||
             account.verificationRequiredReason !== undefined ||
-            account.verificationUrl !== undefined);
+            account.verificationUrl !== undefined ||
+            account.accountIneligibleAt !== undefined ||
+            account.accountIneligibleReason !== undefined ||
+            account.eligibilityStateUpdatedAt !== undefined;
         account.verificationRequired = false;
         account.verificationRequiredAt = undefined;
         account.verificationRequiredReason = undefined;
         account.verificationUrl = undefined;
-        if (enableAccount && wasVerificationRequired && account.enabled === false) {
+        account.accountIneligible = false;
+        account.accountIneligibleAt = undefined;
+        account.accountIneligibleReason = undefined;
+        if (wasIneligible || account.eligibilityStateUpdatedAt !== undefined) {
+            account.eligibilityStateUpdatedAt = nowMs();
+        }
+        if (enableAccount && (wasVerificationRequired || wasIneligible) && account.enabled === false) {
             this.setAccountEnabled(accountIndex, true);
         }
-        else if (wasVerificationRequired || hadMetadata) {
+        else if (hadMetadata) {
             this.requestSaveToDisk();
         }
         return true;
@@ -755,6 +931,7 @@ export class AccountManager {
             this.cursorByFamily = { claude: 0, gemini: 0 };
             this.currentAccountIndexByFamily.claude = -1;
             this.currentAccountIndexByFamily.gemini = -1;
+            this.requestSessionStates.clear();
             return true;
         }
         for (const family of ["claude", "gemini"]) {
@@ -768,6 +945,24 @@ export class AccountManager {
             if (this.currentAccountIndexByFamily[family] >= this.accounts.length) {
                 this.currentAccountIndexByFamily[family] = -1;
             }
+            for (const state of this.requestSessionStates.values()) {
+                const currentIndex = state.currentAccountIndexByFamily[family];
+                if (currentIndex === idx) {
+                    state.currentAccountIndexByFamily[family] = -1;
+                }
+                else if (currentIndex > idx) {
+                    state.currentAccountIndexByFamily[family] -= 1;
+                }
+                if (state.cursorByFamily[family] > idx) {
+                    state.cursorByFamily[family] -= 1;
+                }
+                state.cursorByFamily[family] %= this.accounts.length;
+            }
+        }
+        for (const state of this.requestSessionStates.values()) {
+            state.usedAccounts = new Set([...state.usedAccounts]
+                .filter((accountIndex) => accountIndex !== idx)
+                .map((accountIndex) => accountIndex > idx ? accountIndex - 1 : accountIndex));
         }
         return true;
     }
@@ -829,10 +1024,10 @@ export class AccountManager {
     getAccounts() {
         return [...this.accounts];
     }
-    async saveToDisk() {
+    buildStorageSnapshot() {
         const claudeIndex = Math.max(0, this.currentAccountIndexByFamily.claude);
         const geminiIndex = Math.max(0, this.currentAccountIndexByFamily.gemini);
-        const storage = {
+        return {
             version: 4,
             accounts: this.accounts.map((a) => ({
                 email: a.email,
@@ -852,13 +1047,28 @@ export class AccountManager {
                 verificationRequiredAt: a.verificationRequiredAt,
                 verificationRequiredReason: a.verificationRequiredReason,
                 verificationUrl: a.verificationUrl,
-            })), activeIndex: claudeIndex,
+                accountIneligible: a.accountIneligible,
+                accountIneligibleAt: a.accountIneligibleAt,
+                accountIneligibleReason: a.accountIneligibleReason,
+                eligibilityStateUpdatedAt: a.eligibilityStateUpdatedAt,
+            })),
+            activeIndex: claudeIndex,
             activeIndexByFamily: {
                 claude: claudeIndex,
                 gemini: geminiIndex,
             },
         };
-        await saveAccounts(storage);
+    }
+    async saveToDisk() {
+        await saveAccounts(this.buildStorageSnapshot());
+    }
+    /**
+     * Persist via full-file replace (no merge). Required after destructive
+     * operations (account removal) so a deleted account is not resurrected by
+     * mergeAccountStorage re-reading it from disk.
+     */
+    async saveToDiskReplace() {
+        await saveAccountsReplace(this.buildStorageSnapshot());
     }
     requestSaveToDisk() {
         if (this.savePending) {
@@ -1086,7 +1296,7 @@ export class AccountManager {
         };
     }
     isAccountOverSoftQuota(account, family, thresholdPercent, cacheTtlMs, model) {
-        return isOverSoftQuotaThreshold(account, family, thresholdPercent, cacheTtlMs, model);
+        return isOverSoftQuotaThreshold(account, family, this.getEffectiveSoftQuotaThreshold(thresholdPercent), cacheTtlMs, model);
     }
     getAccountsForQuotaCheck() {
         return this.accounts.map((a) => ({
@@ -1116,7 +1326,7 @@ export class AccountManager {
         if (thresholdPercent >= 100)
             return false;
         const enabled = this.accounts.filter(a => a.enabled !== false);
-        if (enabled.length === 0)
+        if (enabled.length <= 1)
             return false;
         return enabled.every(a => isOverSoftQuotaThreshold(a, family, thresholdPercent, cacheTtlMs, model));
     }
@@ -1132,6 +1342,8 @@ export class AccountManager {
         const enabled = this.accounts.filter(a => a.enabled !== false);
         if (enabled.length === 0)
             return null;
+        if (enabled.length === 1)
+            return 0;
         // If any account is available (not over threshold), no wait needed
         const available = enabled.filter(a => !isOverSoftQuotaThreshold(a, family, thresholdPercent, cacheTtlMs, model));
         if (available.length > 0)