@jsonstudio/rcc 0.89.1968 → 0.89.2202

package/dist/manager/modules/quota/antigravity-quota-manager.js

@@ -1,22 +1,25 @@
-import fs from 'node:fs';
-import path from 'node:path';
 import { homedir } from 'node:os';
-import fsAsync from 'node:fs/promises';
-import { fetchAntigravityQuotaSnapshot, loadAntigravityAccessToken } from '../../../providers/core/runtime/antigravity-quota-client.js';
-import { scanProviderTokenFiles } from '../../../providers/auth/token-scanner/index.js';
-import { resolveAntigravityApiBase } from '../../../providers/auth/antigravity-userinfo-helper.js';
 import * as llmsBridge from '../../../modules/llmswitch/bridge.js';
-import { loadProviderQuotaSnapshot } from '../../quota/provider-quota-store.js';
+import { assertCoreQuotaManagerApis } from './antigravity-quota-core.js';
+import { buildAntigravitySnapshotKey, computeResetAt, extractAntigravityAlias, isAntigravityModelProtected, parseAntigravityProviderKey, parseAntigravitySnapshotKey, readProtectedModelsFromTokenFile } from './antigravity-quota-helpers.js';
+import { createQuotaStore, loadAntigravitySnapshotFromDisk, saveAntigravitySnapshotToDisk } from './antigravity-quota-persistence.js';
+import { applyAntigravityQuotaToCore, refreshAllAntigravityQuotas, syncAntigravityTokensFromDisk } from './antigravity-quota-sync.js';
+import { getSnapshotRecordByAliasAndModel, handleQuotaPersistenceIssue, reconcileProtectedStates, scheduleNextRefresh as scheduleNextQuotaRefresh, subscribeToProviderCenters as subscribeQuotaProviderCenters } from './antigravity-quota-runtime.js';
+const ANTIGRAVITY_PROTECTED_REASON = 'protected';
 export class QuotaManagerModule {
     id = 'quota';
     snapshot = {};
     antigravityTokens = new Map();
+    antigravityProtectedModels = new Map();
+    registeredProviderKeys = new Set();
     refreshTimer = null;
     quotaRoutingEnabled = true;
     refreshFailures = 0;
     refreshDisabled = false;
     providerErrorUnsub = null;
     providerSuccessUnsub = null;
+    quotaStorePersistenceStatus = 'unknown';
+    quotaStoreLastUnbindReason = null;
     coreQuotaManager = null;
     quotaStorePath = null;
     resolveHomeDir() {
@@ -27,59 +30,58 @@ export class QuotaManagerModule {
         return homedir();
     }
     async init(context) {
-        this.snapshot = this.loadSnapshotFromDisk();
+        this.snapshot = loadAntigravitySnapshotFromDisk(() => this.resolveHomeDir());
         this.quotaRoutingEnabled = context.quotaRoutingEnabled !== false;
-        // IMPORTANT: prune persisted quota aliases using current token files on disk.
-        // We must not “invent” aliases; admin UI should only show aliases that have a token file.
-        // This is cheap (local fs read) and prevents stale entries like antigravity://a1/... lingering forever.
         try {
             await this.syncAntigravityTokensFromDisk();
         }
         catch {
             // best-effort; never block server init
         }
-        // Core-owned quota manager: host provides only persistence I/O.
-        // When quota routing is enabled, this must be available; otherwise Virtual Router quotaView becomes non-deterministic.
         if (!this.quotaRoutingEnabled) {
             this.coreQuotaManager = null;
             return;
         }
-        const store = this.createQuotaStore();
+        const store = createQuotaStore({
+            resolveHomeDir: () => this.resolveHomeDir(),
+            onStorePath: (filePath) => {
+                this.quotaStorePath = filePath;
+            },
+            onStatus: (status) => {
+                this.quotaStorePersistenceStatus = status;
+                if (status === 'loaded') {
+                    this.quotaStoreLastUnbindReason = null;
+                }
+            },
+            onSessionUnbindIssue: (reason) => {
+                this.handleSessionUnbindForQuotaPersistenceIssue(reason);
+            }
+        });
         this.coreQuotaManager = (await llmsBridge.createCoreQuotaManager({ store }));
-        const mgrAny = this.coreQuotaManager;
-        const missingApis = !mgrAny ||
-            typeof mgrAny.getQuotaView !== 'function' ||
-            typeof mgrAny.getSnapshot !== 'function' ||
-            typeof mgrAny.updateProviderPoolState !== 'function' ||
-            typeof mgrAny.resetProvider !== 'function' ||
-            typeof mgrAny.recoverProvider !== 'function' ||
-            typeof mgrAny.disableProvider !== 'function';
-        if (missingApis) {
-            const detail = {
-                hasMgr: Boolean(mgrAny),
-                getQuotaView: typeof mgrAny?.getQuotaView,
-                getSnapshot: typeof mgrAny?.getSnapshot,
-                updateProviderPoolState: typeof mgrAny?.updateProviderPoolState,
-                resetProvider: typeof mgrAny?.resetProvider,
-                recoverProvider: typeof mgrAny?.recoverProvider,
-                disableProvider: typeof mgrAny?.disableProvider
-            };
-            throw new Error(`core quota manager missing expected APIs: ${JSON.stringify(detail)}`);
-        }
+        assertCoreQuotaManagerApis(this.coreQuotaManager);
         if (this.coreQuotaManager && typeof this.coreQuotaManager.hydrateFromStore === 'function') {
             await this.coreQuotaManager.hydrateFromStore().catch(() => { });
         }
-        // Apply persisted Antigravity snapshot into the unified quota view (best-effort),
-        // so restarts don't temporarily “forget” known depleted keys.
+        if (this.quotaStorePersistenceStatus === 'missing' || this.quotaStorePersistenceStatus === 'load_error') {
+            this.handleSessionUnbindForQuotaPersistenceIssue(`quota_store_${this.quotaStorePersistenceStatus}`);
+        }
         try {
             const nowMs = Date.now();
             for (const [key, record] of Object.entries(this.snapshot)) {
-                const parsed = this.parseAntigravitySnapshotKey(key);
+                const parsed = parseAntigravitySnapshotKey(key);
                 if (!parsed) {
                     continue;
                 }
-                this.applyAntigravityQuotaToCore(`antigravity.${parsed.alias}.${parsed.modelId}`, record, nowMs);
+                applyAntigravityQuotaToCore({
+                    coreQuotaManager: this.coreQuotaManager,
+                    providerKey: `antigravity.${parsed.alias}.${parsed.modelId}`,
+                    record,
+                    nowMs,
+                    protectedReason: ANTIGRAVITY_PROTECTED_REASON,
+                    isProviderProtected: (providerKey) => this.isAntigravityProviderProtected(providerKey)
+                });
             }
+            this.reconcileProtectedStatesForRegisteredProviders();
         }
         catch {
             // ignore snapshot apply failures
@@ -89,15 +91,12 @@ export class QuotaManagerModule {
         if (!this.quotaRoutingEnabled) {
             return;
         }
-        // Subscribe provider error/success streams -> core quota manager.
         try {
             void this.subscribeToProviderCenters();
         }
         catch {
             // ignore subscription failures
         }
-        // IMPORTANT: startup must never block server initialization.
-        // Run the initial refresh best-effort in the background; axios timeouts apply per request.
         const refreshPromise = this.refreshAllAntigravityQuotas()
             .then((result) => {
             if (result.attempted > 0 && result.successCount === 0) {
@@ -113,7 +112,6 @@ export class QuotaManagerModule {
         void this.scheduleNextRefresh().catch(() => {
             // ignore scheduling failures
         });
-        // In Jest, await the refresh to keep unit tests deterministic.
         if (process.env.JEST_WORKER_ID || process.env.NODE_ENV === 'test') {
             return refreshPromise;
         }
@@ -128,14 +126,18 @@ export class QuotaManagerModule {
             try {
                 this.providerErrorUnsub();
             }
-            catch { /* ignore */ }
+            catch {
+                // ignore
+            }
             this.providerErrorUnsub = null;
         }
         if (this.providerSuccessUnsub) {
             try {
                 this.providerSuccessUnsub();
             }
-            catch { /* ignore */ }
+            catch {
+                // ignore
+            }
             this.providerSuccessUnsub = null;
         }
         try {
@@ -146,12 +148,10 @@ export class QuotaManagerModule {
         catch {
             // ignore persistence failures
         }
-        this.saveSnapshotToDisk();
+        void this.saveSnapshotToDisk().catch(() => {
+            // best-effort; ignore persistence errors
+        });
     }
-    /**
-     * Admin operation: force-refresh quota snapshots immediately (best-effort).
-     * Exposed via daemon-admin endpoint `/quota/refresh`.
-     */
     async refreshNow() {
         const refreshedAt = Date.now();
         try {
@@ -170,19 +170,15 @@ export class QuotaManagerModule {
         catch {
             // ignore scheduling failures
         }
-        return { refreshedAt, tokenCount: this.antigravityTokens.size, recordCount: Object.keys(this.snapshot).length };
+        return {
+            refreshedAt,
+            tokenCount: this.antigravityTokens.size,
+            recordCount: Object.keys(this.snapshot).length
+        };
     }
-    /**
-     * daemon-admin "reset" semantics for quota module = refresh now.
-     * Keeps module UX consistent across admin actions.
-     */
     async reset() {
         return await this.refreshNow();
     }
-    /**
-     * 用于 antigravity：注册需要追踪配额的 alias/token。
-     * 多次调用同一 alias 会覆盖最新配置。
-     */
     registerAntigravityToken(alias, tokenFile, apiBase) {
         const cleanAlias = alias.trim();
         const cleanToken = tokenFile.trim();
@@ -195,10 +191,20 @@ export class QuotaManagerModule {
             tokenFile: cleanToken,
             apiBase: cleanBase
         });
+        void readProtectedModelsFromTokenFile(cleanToken)
+            .then((protectedModels) => {
+            if (protectedModels.size > 0) {
+                this.antigravityProtectedModels.set(cleanAlias, protectedModels);
+            }
+            else {
+                this.antigravityProtectedModels.delete(cleanAlias);
+            }
+            this.reconcileProtectedStatesForRegisteredProviders();
+        })
+            .catch(() => {
+            // best-effort only
+        });
     }
-    /**
-     * 用于 antigravity：根据 alias+model 更新配额快照。
-     */
     updateAntigravityQuota(alias, quota) {
         const aliasId = alias.trim();
         if (!aliasId) {
@@ -207,41 +213,44 @@ export class QuotaManagerModule {
         const now = Date.now();
         const next = { ...this.snapshot };
         for (const [modelId, info] of Object.entries(quota.models)) {
-            const key = this.buildAntigravityKey(aliasId, modelId);
+            const key = buildAntigravitySnapshotKey(aliasId, modelId);
             const record = {
                 remainingFraction: Number.isFinite(info.remainingFraction) ? info.remainingFraction : null,
                 fetchedAt: quota.fetchedAt
             };
-            const resetAt = this.computeResetAt(info.resetTimeRaw);
-            // Keep resetAt even if it's already in the past so admin UI can inspect drift/staleness.
-            // Routing gate still treats `resetAt <= now` as unknown quota and will block entry.
+            const resetAt = computeResetAt(info.resetTimeRaw);
             if (resetAt) {
                 record.resetAt = resetAt;
             }
             next[key] = record;
-            const providerKey = `antigravity.${aliasId}.${modelId}`;
-            // Unified quota routing: update pool state directly (quotaView becomes the single source of truth).
-            this.applyAntigravityQuotaToCore(providerKey, record, now);
+            applyAntigravityQuotaToCore({
+                coreQuotaManager: this.coreQuotaManager,
+                providerKey: `antigravity.${aliasId}.${modelId}`,
+                record,
+                nowMs: now,
+                protectedReason: ANTIGRAVITY_PROTECTED_REASON,
+                isProviderProtected: (providerKey) => this.isAntigravityProviderProtected(providerKey)
+            });
         }
         this.snapshot = next;
-        this.saveSnapshotToDisk();
+        void this.saveSnapshotToDisk().catch(() => {
+            // best-effort; ignore persistence errors
+        });
     }
-    /**
-     * 判断给定 providerKey+model 是否有可用配额（仅针对 antigravity 语义）。
-     */
     hasQuotaForAntigravity(providerKey, modelId) {
-        const alias = this.extractAntigravityAlias(providerKey);
+        const alias = extractAntigravityAlias(providerKey);
         if (!alias || !modelId) {
             return true;
         }
-        const key = this.buildAntigravityKey(alias, modelId);
+        if (this.isAntigravityModelProtected(alias, modelId)) {
+            return false;
+        }
+        const key = buildAntigravitySnapshotKey(alias, modelId);
         const record = this.snapshot[key];
         if (!record) {
-            // 没有任何配额记录时视为“无配额”，禁止进入路由池。
             return false;
         }
         const now = Date.now();
-        // 如果已经超过 resetAt，但尚未刷新到新一轮配额，视为配额状态未知，同样禁止。
         if (record.resetAt && record.resetAt <= now) {
             return false;
         }
@@ -253,16 +262,12 @@ export class QuotaManagerModule {
     getRawSnapshot() {
         return { ...this.snapshot };
     }
-    /**
-     * VirtualRouter consumes this via HubPipeline `quotaView` injection.
-     */
     getQuotaView() {
         const mgr = this.coreQuotaManager;
         if (!mgr || typeof mgr.getQuotaView !== 'function') {
             return () => null;
         }
         try {
-            // IMPORTANT: call as a bound method; core quota manager uses `this.states`.
             return mgr.getQuotaView();
         }
         catch {
@@ -270,8 +275,6 @@ export class QuotaManagerModule {
         }
     }
     getQuotaViewReadOnly() {
-        // Current core quota view is already side-effect free for routing semantics;
-        // keep the same view function to avoid duplicate logic.
         return this.getQuotaView();
     }
     getAdminSnapshot() {
@@ -282,6 +285,9 @@ export class QuotaManagerModule {
             : {};
         return providers;
     }
+    getCoreQuotaManager() {
+        return this.quotaRoutingEnabled ? this.coreQuotaManager : null;
+    }
     registerProviderStaticConfig(providerKey, config = {}) {
         const key = typeof providerKey === 'string' ? providerKey.trim() : '';
         if (!key)
@@ -298,8 +304,10 @@ export class QuotaManagerModule {
             ...(authType === 'apikey' || authType === 'oauth' ? { authType: authType } : {}),
             ...(apikeyDailyResetTime ? { apikeyDailyResetTime } : {})
         };
+        this.registeredProviderKeys.add(key);
         try {
             this.coreQuotaManager?.registerProviderStaticConfig?.(key, cfg);
+            this.reconcileProtectedStatesForRegisteredProviders();
         }
         catch {
             // ignore
@@ -332,406 +340,101 @@ export class QuotaManagerModule {
         await mgr.persistNow?.().catch(() => { });
         return { ok: true };
     }
-    buildAntigravityKey(alias, modelId) {
-        return `antigravity://${alias}/${modelId}`;
+    isAntigravityModelProtected(alias, modelId) {
+        return isAntigravityModelProtected(this.antigravityProtectedModels, alias, modelId);
     }
-    parseAntigravitySnapshotKey(key) {
-        const raw = typeof key === 'string' ? key.trim() : '';
-        if (!raw.toLowerCase().startsWith('antigravity://')) {
-            return null;
-        }
-        const rest = raw.slice('antigravity://'.length);
-        const idx = rest.indexOf('/');
-        if (idx <= 0) {
-            return null;
-        }
-        const alias = rest.slice(0, idx).trim();
-        const modelId = rest.slice(idx + 1).trim();
-        if (!alias || !modelId) {
-            return null;
-        }
-        return { alias, modelId };
-    }
-    extractAntigravityAlias(providerKey) {
-        if (!providerKey || typeof providerKey !== 'string') {
-            return null;
-        }
-        const trimmed = providerKey.trim();
-        if (!trimmed.toLowerCase().startsWith('antigravity.')) {
-            return null;
-        }
-        const segments = trimmed.split('.');
-        if (segments.length < 2) {
-            return null;
-        }
-        return segments[1];
-    }
-    computeResetAt(raw) {
-        if (!raw || typeof raw !== 'string' || !raw.trim()) {
-            return undefined;
-        }
-        const value = raw.trim();
-        try {
-            const normalized = value.endsWith('Z') ? value.replace(/Z$/, '+00:00') : value;
-            const parsed = Date.parse(normalized);
-            if (!Number.isFinite(parsed) || parsed <= 0) {
-                return undefined;
-            }
-            return parsed;
-        }
-        catch {
-            return undefined;
+    isAntigravityProviderProtected(providerKey) {
+        const parsed = parseAntigravityProviderKey(providerKey);
+        if (!parsed) {
+            return false;
         }
+        return this.isAntigravityModelProtected(parsed.alias, parsed.modelId);
     }
-    async refreshAllAntigravityQuotas() {
-        await this.syncAntigravityTokensFromDisk();
-        if (this.antigravityTokens.size === 0) {
-            return { attempted: 0, successCount: 0, failureCount: 0 };
-        }
-        let attempted = 0;
-        let successCount = 0;
-        let failureCount = 0;
-        for (const { alias, tokenFile, apiBase } of this.antigravityTokens.values()) {
-            try {
-                const accessToken = await loadAntigravityAccessToken(tokenFile);
-                if (!accessToken) {
-                    continue;
-                }
-                attempted += 1;
-                const snapshot = await fetchAntigravityQuotaSnapshot(apiBase, accessToken, { alias });
-                if (!snapshot) {
-                    failureCount += 1;
-                    continue;
-                }
-                this.updateAntigravityQuota(alias, snapshot);
-                successCount += 1;
-            }
-            catch {
-                failureCount += 1;
-                // 单个 alias 失败不影响其他 alias 的刷新
+    reconcileProtectedStatesForRegisteredProviders() {
+        reconcileProtectedStates({
+            coreQuotaManager: this.coreQuotaManager,
+            protectedReason: ANTIGRAVITY_PROTECTED_REASON,
+            registeredProviderKeys: this.registeredProviderKeys,
+            adminSnapshot: this.getAdminSnapshot(),
+            isModelProtected: (alias, modelId) => this.isAntigravityModelProtected(alias, modelId),
+            getSnapshotRecord: (alias, modelId) => getSnapshotRecordByAliasAndModel(this.snapshot, alias, modelId),
+            applyQuotaRecord: (providerKey, record) => {
+                applyAntigravityQuotaToCore({
+                    coreQuotaManager: this.coreQuotaManager,
+                    providerKey,
+                    record,
+                    nowMs: Date.now(),
+                    protectedReason: ANTIGRAVITY_PROTECTED_REASON,
+                    isProviderProtected: (key) => this.isAntigravityProviderProtected(key)
+                });
             }
-        }
-        return { attempted, successCount, failureCount };
-    }
-    applyAntigravityQuotaToCore(providerKey, record, nowMs) {
-        const mgr = this.coreQuotaManager;
-        if (!mgr || typeof mgr.updateProviderPoolState !== 'function') {
-            return;
-        }
-        const remaining = record.remainingFraction;
-        const resetAt = typeof record.resetAt === 'number' && Number.isFinite(record.resetAt) ? record.resetAt : null;
-        const withinResetWindow = typeof resetAt === 'number' && resetAt > nowMs;
-        const hasQuota = typeof remaining === 'number' && Number.isFinite(remaining) && remaining > 0 && (resetAt === null || withinResetWindow);
-        if (hasQuota) {
-            mgr.updateProviderPoolState({ providerKey, inPool: true, reason: 'ok', cooldownUntil: null, blacklistUntil: null });
-            return;
-        }
-        mgr.updateProviderPoolState({
-            providerKey,
-            inPool: false,
-            reason: 'quotaDepleted',
-            cooldownUntil: null,
-            blacklistUntil: null
         });
     }
-    createQuotaStore() {
-        const dir = this.resolveQuotaManagerDir();
-        const filePath = path.join(dir, 'quota-manager.json');
-        this.quotaStorePath = filePath;
-        return {
-            load: async () => {
-                // Preferred: new snapshot.
-                try {
-                    const raw = await fsAsync.readFile(filePath, 'utf8');
-                    const parsed = JSON.parse(String(raw || '').trim() || 'null');
-                    if (parsed && typeof parsed === 'object' && parsed.providers && typeof parsed.providers === 'object') {
-                        return parsed;
-                    }
-                }
-                catch {
-                    // ignore
-                }
-                // Fallback: migrate from legacy provider-quota snapshot if present.
-                try {
-                    const legacy = await loadProviderQuotaSnapshot();
-                    if (legacy && legacy.providers && typeof legacy.providers === 'object') {
-                        const nowMs = Date.now();
-                        return {
-                            savedAtMs: Number.isFinite(Date.parse(legacy.updatedAt)) ? Date.parse(legacy.updatedAt) : nowMs,
-                            providers: legacy.providers
-                        };
-                    }
-                }
-                catch {
-                    // ignore
-                }
-                return null;
+    async refreshAllAntigravityQuotas() {
+        return await refreshAllAntigravityQuotas({
+            tokens: this.antigravityTokens,
+            syncTokensFromDisk: async () => {
+                await this.syncAntigravityTokensFromDisk();
             },
-            save: async (snapshot) => {
-                try {
-                    await fsAsync.mkdir(dir, { recursive: true });
-                }
-                catch {
-                    // ignore
-                }
-                const tmp = `${filePath}.tmp`;
-                const text = `${JSON.stringify(snapshot, null, 2)}\n`;
-                try {
-                    await fsAsync.writeFile(tmp, text, 'utf8');
-                    await fsAsync.rename(tmp, filePath);
-                }
-                catch {
-                    try {
-                        await fsAsync.unlink(tmp);
-                    }
-                    catch { /* ignore */ }
-                }
+            updateAntigravityQuota: (alias, quota) => {
+                this.updateAntigravityQuota(alias, quota);
             }
-        };
+        });
     }
-    resolveQuotaManagerDir() {
-        const base = path.join(this.resolveHomeDir(), '.routecodex', 'quota');
-        try {
-            fs.mkdirSync(base, { recursive: true });
-        }
-        catch {
-            // ignore
-        }
-        return base;
+    handleSessionUnbindForQuotaPersistenceIssue(reason) {
+        this.quotaStoreLastUnbindReason = handleQuotaPersistenceIssue({
+            reason,
+            lastReason: this.quotaStoreLastUnbindReason,
+            quotaStorePath: this.quotaStorePath,
+            clearSessionAliasPins: () => llmsBridge.clearAntigravitySessionAliasPins?.({ hydrate: true })
+        });
     }
     async subscribeToProviderCenters() {
-        const mgr = this.coreQuotaManager;
-        if (!mgr) {
-            return;
-        }
-        let errorCenter = null;
-        try {
-            errorCenter = (await llmsBridge.getProviderErrorCenter());
-        }
-        catch {
-            errorCenter = null;
-        }
-        if (errorCenter && typeof errorCenter.subscribe === 'function' && typeof mgr.onProviderError === 'function') {
-            try {
-                this.providerErrorUnsub = errorCenter.subscribe((ev) => {
-                    try {
-                        mgr.onProviderError?.(ev);
-                    }
-                    catch { /* ignore */ }
-                });
-            }
-            catch {
-                this.providerErrorUnsub = null;
-            }
-        }
-        let successCenter = null;
-        try {
-            successCenter = (await llmsBridge.getProviderSuccessCenter());
-        }
-        catch {
-            successCenter = null;
-        }
-        if (successCenter && typeof successCenter.subscribe === 'function' && typeof mgr.onProviderSuccess === 'function') {
-            try {
-                this.providerSuccessUnsub = successCenter.subscribe((ev) => {
-                    try {
-                        mgr.onProviderSuccess?.(ev);
-                    }
-                    catch { /* ignore */ }
-                });
-            }
-            catch {
-                this.providerSuccessUnsub = null;
-            }
-        }
+        const { providerErrorUnsub, providerSuccessUnsub } = await subscribeQuotaProviderCenters({
+            bridge: llmsBridge,
+            coreQuotaManager: this.coreQuotaManager
+        });
+        this.providerErrorUnsub = providerErrorUnsub;
+        this.providerSuccessUnsub = providerSuccessUnsub;
     }
-    /**
-     * 每 5 分钟刷新一次 quota（固定间隔）。
-     * 启动时会立即刷新一次，随后由该定时器维持周期刷新。
-     */
     async scheduleNextRefresh() {
-        if (this.refreshTimer) {
-            clearTimeout(this.refreshTimer);
-            this.refreshTimer = null;
-        }
-        if (this.refreshDisabled) {
-            return;
-        }
-        const baseIntervalMs = 5 * 60 * 1000;
-        const delayMs = baseIntervalMs;
-        this.refreshTimer = setTimeout(() => {
-            void this.refreshAllAntigravityQuotas()
-                .then((result) => {
-                if (result.attempted > 0 && result.successCount === 0) {
-                    this.refreshFailures += 1;
-                    if (this.refreshFailures >= 3) {
-                        this.refreshDisabled = true;
-                    }
-                }
-                else if (result.successCount > 0) {
-                    this.refreshFailures = 0;
-                }
-            })
-                .catch(() => {
-                this.refreshFailures += 1;
-                if (this.refreshFailures >= 3) {
-                    this.refreshDisabled = true;
-                }
-            })
-                .finally(() => {
-                if (!this.refreshDisabled) {
-                    void this.scheduleNextRefresh().catch(() => {
-                        // ignore reschedule failure
-                    });
-                }
-            });
-        }, delayMs);
-        this.refreshTimer.unref?.();
+        this.refreshTimer = scheduleNextQuotaRefresh({
+            currentTimer: this.refreshTimer,
+            getRefreshDisabled: () => this.refreshDisabled,
+            getRefreshFailures: () => this.refreshFailures,
+            refreshAllAntigravityQuotas: () => this.refreshAllAntigravityQuotas(),
+            onRefreshFailuresChange: (nextFailures) => {
+                this.refreshFailures = nextFailures;
+            },
+            onRefreshDisabledChange: (nextDisabled) => {
+                this.refreshDisabled = nextDisabled;
+            },
+            onReschedule: () => {
+                void this.scheduleNextRefresh().catch(() => {
+                    // ignore reschedule failure
+                });
+            }
+        });
     }
-    /**
-     * 自动从本地 auth 目录扫描 antigravity OAuth token，并同步到内存注册表。
-     * 这确保「每个 token」都能定期刷新 quota，而不依赖额外的显式注册流程。
-     */
     async syncAntigravityTokensFromDisk() {
-        let matches = [];
-        try {
-            matches = await scanProviderTokenFiles('antigravity');
-        }
-        catch {
-            matches = [];
-        }
-        if (!matches.length) {
-            this.antigravityTokens.clear();
-            // No token files -> no valid aliases -> drop any persisted snapshot rows.
-            if (this.snapshot && Object.keys(this.snapshot).length) {
-                this.snapshot = {};
-                this.saveSnapshotToDisk();
-            }
-            return;
-        }
-        const base = resolveAntigravityApiBase();
-        const next = new Map();
-        const legacyAliases = [];
-        for (const match of matches) {
-            // IMPORTANT: alias must match providerKey alias used by VirtualRouter/provider registry:
-            // providerKey is `antigravity.<alias>.<modelId>`, where `<alias>` comes from user config entries.
-            // Do not prefix with sequence number here, otherwise QUOTA_* events will target keys that routing never uses.
-            const alias = (match.alias && match.alias !== 'default' ? match.alias : String(match.sequence)).trim();
-            if (!alias) {
-                continue;
-            }
-            const legacyAlias = match.alias && match.alias !== 'default' ? `${match.sequence}-${match.alias}`.trim() : null;
-            if (legacyAlias) {
-                legacyAliases.push(legacyAlias);
-            }
-            next.set(alias, {
-                alias,
-                tokenFile: match.filePath,
-                apiBase: base
+        const result = await syncAntigravityTokensFromDisk({
+            currentTokens: this.antigravityTokens,
+            currentSnapshot: this.snapshot,
+            parseSnapshotKey: parseAntigravitySnapshotKey,
+            readProtectedModelsFromTokenFile
+        });
+        this.antigravityTokens = result.tokens;
+        this.antigravityProtectedModels = result.protectedModels;
+        this.snapshot = result.snapshot;
+        if (result.snapshotChanged) {
+            void this.saveSnapshotToDisk().catch(() => {
+                // best-effort; ignore persistence errors
             });
         }
-        // 若已有显式注册的 alias，保留其覆盖权
-        for (const [alias, reg] of this.antigravityTokens.entries()) {
-            if (!next.has(alias)) {
-                next.set(alias, reg);
-            }
-        }
-        this.antigravityTokens = next;
-        // Cleanup legacy snapshot keys created by older builds (sequence-prefixed alias like "1-foo").
-        // Those keys never match VirtualRouter providerKey aliases and only cause duplicate/stale rows in admin views.
-        if (legacyAliases.length && this.snapshot && typeof this.snapshot === 'object') {
-            const legacyPrefixes = legacyAliases.map((a) => `antigravity://${a}/`);
-            const rawEntries = Object.entries(this.snapshot);
-            let changed = false;
-            const cleaned = {};
-            for (const [key, value] of rawEntries) {
-                const drop = legacyPrefixes.some((prefix) => key.startsWith(prefix));
-                if (drop) {
-                    changed = true;
-                    continue;
-                }
-                cleaned[key] = value;
-            }
-            if (changed) {
-                this.snapshot = cleaned;
-                this.saveSnapshotToDisk();
-            }
-        }
-        // Cleanup stale snapshot keys for aliases that no longer exist on disk.
-        // This prevents “phantom aliases” (e.g. a1) from showing up in admin UI when the token file is gone.
-        if (this.snapshot && typeof this.snapshot === 'object') {
-            const allowedAliases = new Set(Array.from(this.antigravityTokens.keys()));
-            const rawEntries = Object.entries(this.snapshot);
-            let changed = false;
-            const cleaned = {};
-            for (const [key, value] of rawEntries) {
-                const parsed = this.parseAntigravitySnapshotKey(key);
-                if (parsed && !allowedAliases.has(parsed.alias)) {
-                    changed = true;
-                    continue;
-                }
-                cleaned[key] = value;
-            }
-            if (changed) {
-                this.snapshot = cleaned;
-                this.saveSnapshotToDisk();
-            }
-        }
+        this.reconcileProtectedStatesForRegisteredProviders();
     }
-    resolveStatePath() {
-        const baseDir = path.join(this.resolveHomeDir(), '.routecodex', 'state', 'quota');
-        try {
-            fs.mkdirSync(baseDir, { recursive: true });
-        }
-        catch {
-            // best effort
-        }
-        return path.join(baseDir, 'antigravity.json');
-    }
-    loadSnapshotFromDisk() {
-        const filePath = this.resolveStatePath();
-        try {
-            if (!fs.existsSync(filePath)) {
-                return {};
-            }
-            const content = fs.readFileSync(filePath, 'utf8');
-            const parsed = content.trim() ? JSON.parse(content) : {};
-            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-                return {};
-            }
-            const raw = parsed;
-            const result = {};
-            for (const [key, value] of Object.entries(raw)) {
-                if (!value || typeof value !== 'object') {
-                    continue;
-                }
-                let remainingFraction = null;
-                if (typeof value.remainingFraction === 'number') {
-                    remainingFraction = value.remainingFraction ?? null;
-                }
-                let resetAt;
-                if (typeof value.resetAt === 'number') {
-                    resetAt = value.resetAt;
-                }
-                const fetchedAt = typeof value.fetchedAt === 'number'
-                    ? value.fetchedAt
-                    : Date.now();
-                result[key] = { remainingFraction, resetAt, fetchedAt };
-            }
-            return result;
-        }
-        catch {
-            return {};
-        }
-    }
-    saveSnapshotToDisk() {
-        const filePath = this.resolveStatePath();
-        try {
-            fs.writeFileSync(filePath, `${JSON.stringify(this.snapshot, null, 2)}\n`, 'utf8');
-        }
-        catch {
-            // best effort
-        }
+    async saveSnapshotToDisk() {
+        await saveAntigravitySnapshotToDisk(() => this.resolveHomeDir(), this.snapshot);
     }
 }
 //# sourceMappingURL=antigravity-quota-manager.js.map