@cortexkit/opencode-antigravity-auth 1.1.0 → 2.0.1

package/dist/src/plugin/quota.js

@@ -1,251 +1,382 @@
-import { ANTIGRAVITY_ENDPOINT_FALLBACKS, ANTIGRAVITY_PROVIDER_ID, buildGeminiCliUserAgent, } from "../constants";
-import { fetchWithAgyCliTransport } from "./agy-transport";
-import { accessTokenExpired, formatRefreshParts, parseRefreshParts } from "./auth";
-import { buildAntigravityHarnessUserAgent } from "./fingerprint";
-import { logQuotaFetch, logQuotaStatus } from "./debug";
-import { ensureProjectContext } from "./project";
-import { getQuotaGroupForModel } from "./model-registry";
-import { refreshAccessToken } from "./token";
-import { getModelFamily } from "./transform/model-resolver";
-const FETCH_TIMEOUT_MS = 10000;
-function buildAuthFromAccount(account) {
+/**
+ * OpenCode adapter for the harness-agnostic quota manager.
+ *
+ * Re-exports the core `QuotaManager` types and helpers so call sites in
+ * `plugin.ts` and other modules don't need to switch imports. Also wires up
+ * the host-specific fetch callback that handles:
+ *   1. Token refresh via the existing `refreshAccessToken` path.
+ *   2. Persisting rotated refresh tokens via `client.auth.set` (matching
+ *      legacy behavior).
+ *   3. Resolving project context via `ensureProjectContext`.
+ *
+ * The legacy `checkAccountsQuota(accounts, client, providerId)` export is
+ * retained as a compatibility wrapper that creates a short-lived manager
+ * with `force: true` — manual quota screens must always refresh, even if
+ * the background manager has backed off.
+ */
+import { aggregateGeminiCliQuota, aggregateQuota, aggregateQuotaSummary, createQuotaManager, defaultKeyOf, fetchAvailableModels, fetchGeminiCliQuota, fetchQuotaSummary, getHealthTracker, } from '@cortexkit/antigravity-auth-core';
+import { ANTIGRAVITY_ENDPOINT_FALLBACKS, ANTIGRAVITY_PROVIDER_ID, buildGeminiCliUserAgent, } from '../constants';
+import { buildSidebarMachineStateFromAccounts, isAccountCurrent, setSidebarMachineState, } from '../sidebar-state';
+import { accessTokenExpired, formatRefreshParts, parseRefreshParts, } from './auth';
+import { logQuotaFetch, logQuotaStatus } from './debug';
+import { buildAntigravityHarnessUserAgent } from './fingerprint';
+import { createLogger } from './logger';
+import { ensureProjectContext, loadManagedProject } from './project';
+import { refreshAccessToken } from './token';
+// Re-export the public surface so existing imports from `./quota` keep working.
+const log = createLogger('quota');
+export { classifyQuotaGroup, createQuotaManager, defaultKeyOf, } from '@cortexkit/antigravity-auth-core';
+/**
+ * Build an OpenCode-wired quota manager.
+ *
+ * The returned manager owns its cache, in-flight dedupe, and backoff state.
+ * Register its `dispose()` with `PluginLifecycle` so refreshes abort on plugin
+ * shutdown.
+ *
+ * The wrapper observes `refreshAccount` / `refreshAccounts` and pushes a
+ * redacted sidebar snapshot after every refresh (success or backoff) so
+ * the TUI's next poll renders the freshest cached quota. The snapshot is
+ * sourced from the live AccountManager view (`getAccountsForSidebar`) so
+ * it carries the just-updated percentages; before bootstrapping it is a
+ * no-op.
+ */
+export function createOpenCodeQuotaManager(client, providerId = ANTIGRAVITY_PROVIDER_ID, options = {}) {
+    const fetchAccountQuota = makeFetchAccountQuota(client, providerId, options.fetchVia);
+    const manager = createQuotaManager({
+        fetchAccountQuota,
+        keyOf: options.keyOf ?? defaultKeyOf,
+        baseBackoffMs: options.baseBackoffMs,
+        maxBackoffMs: options.maxBackoffMs,
+        fetchTimeoutMs: options.fetchTimeoutMs,
+    });
+    const originalRefreshAccount = manager.refreshAccount;
+    const originalRefreshAccounts = manager.refreshAccounts;
+    const getAccountsForSidebar = options.getAccountsForSidebar;
+    const getActiveIndexByFamily = options.getActiveIndexByFamily;
+    let disposed = false;
+    const inFlight = new Set();
+    const pushAfterRefresh = async (account) => {
+        if (!getAccountsForSidebar)
+            return;
+        await pushSidebarQuotaSnapshot(getAccountsForSidebar, manager.getBackoffUntil(account), getActiveIndexByFamily).catch(() => {
+            // Sidebar persistence remains best-effort when lock contention
+            // outlives its retry budget.
+        });
+    };
+    const track = (operation) => {
+        inFlight.add(operation);
+        void operation.then(() => inFlight.delete(operation), () => inFlight.delete(operation));
+        return operation;
+    };
+    const dispose = async () => {
+        if (disposed)
+            return;
+        disposed = true;
+        await manager.dispose();
+        await Promise.allSettled(inFlight);
+    };
     return {
-        type: "oauth",
-        refresh: formatRefreshParts({
-            refreshToken: account.refreshToken,
-            projectId: account.projectId,
-            managedProjectId: account.managedProjectId,
-        }),
-        access: undefined,
-        expires: undefined,
+        ...manager,
+        async refreshAccount(account, refreshOptions) {
+            const shouldPush = !disposed;
+            return track((async () => {
+                const result = await originalRefreshAccount(account, refreshOptions);
+                if (shouldPush)
+                    await pushAfterRefresh(account);
+                return result;
+            })());
+        },
+        async refreshAccounts(accounts, refreshOptions) {
+            const shouldPush = !disposed;
+            return track((async () => {
+                const results = await originalRefreshAccounts(accounts, refreshOptions);
+                // Push one snapshot per batch — the AccountManager's view is updated
+                // by the caller (oauth-methods / fetch-interceptor) BEFORE we read
+                // here, so a single post-batch snapshot captures the full diff.
+                const lastAccount = accounts[accounts.length - 1];
+                if (shouldPush && lastAccount)
+                    await pushAfterRefresh(lastAccount);
+                return results;
+            })());
+        },
+        dispose,
     };
 }
-function normalizeRemainingFraction(value) {
-    // If value is missing or invalid, treat as exhausted (0%)
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-        return 0;
+/**
+ * Compatibility wrapper used by code paths that want a one-shot check across
+ * the full account pool with no shared cache.
+ *
+ * Equivalent to spinning up a short-lived manager with `force: true` so
+ * manual quota dialogs always reflect the latest data even if the background
+ * manager has backed off.
+ */
+export async function checkAccountsQuotaWith(accounts, fetchAccountQuota) {
+    const manager = createQuotaManager({
+        fetchAccountQuota,
+        keyOf: defaultKeyOf,
+    });
+    try {
+        return await manager.refreshAccounts(accounts, {
+            indexFor: (account) => accounts.indexOf(account),
+            force: true,
+        });
     }
-    if (value < 0)
-        return 0;
-    if (value > 1)
-        return 1;
-    return value;
-}
-function parseResetTime(resetTime) {
-    if (!resetTime)
-        return null;
-    const timestamp = Date.parse(resetTime);
-    if (!Number.isFinite(timestamp)) {
-        return null;
+    finally {
+        manager.dispose();
     }
-    return timestamp;
 }
-export function classifyQuotaGroup(modelName, displayName) {
-    const registryGroup = getQuotaGroupForModel(modelName);
-    if (registryGroup) {
-        return registryGroup;
+export async function checkAccountsQuotaStandalone(accounts, options) {
+    if (!options.refresh) {
+        return accounts.map((account, index) => ({
+            index,
+            email: account.email,
+            status: account.enabled === false ? 'disabled' : 'ok',
+            disabled: account.enabled === false,
+            quota: {
+                groups: account.cachedQuota ?? {},
+                modelCount: Object.keys(account.cachedQuota ?? {}).length,
+            },
+        }));
     }
-    const combined = `${modelName} ${displayName ?? ""}`.toLowerCase();
-    if (combined.includes("claude")) {
-        return "claude";
+    return checkAccountsQuotaWith(accounts, makeFetchAccountQuota(undefined, ANTIGRAVITY_PROVIDER_ID));
+}
+export async function checkAccountsQuota(accounts, client, providerId = ANTIGRAVITY_PROVIDER_ID) {
+    return checkAccountsQuotaWith(accounts, makeFetchAccountQuota(client, providerId));
+}
+/**
+ * Push a quota refresh into the sidebar. Called by every quota refresh
+ * call site (manual `/antigravity-quota`, the `check` menu action, and the
+ * background refresh in `fetch-interceptor`) AFTER the results have been
+ * folded back into the AccountManager's cached quota. The function reads
+ * the live account snapshot through `getAccounts` so the redacted entry
+ * carries the just-refreshed percentages — not the previous tick's stale
+ * numbers and not `undefined`.
+ *
+ * The mapping is deliberately tolerant: if `getAccounts` returns `null`
+ * (e.g. before the plugin has finished bootstrapping) the call is a no-op.
+ * On lock contention the error is logged-and-swallowed so a quota dialog
+ * never fails just because the sidebar file is busy.
+ */
+export async function pushSidebarQuotaSnapshot(getAccounts, backoffUntil = 0, getActiveIndexByFamily) {
+    const accounts = getAccounts();
+    if (!accounts || accounts.length === 0)
+        return;
+    const activeByFamily = getActiveIndexByFamily?.() ?? null;
+    try {
+        await setSidebarMachineState(buildSidebarMachineStateFromAccounts(accounts.map((entry) => ({
+            index: entry.index,
+            label: entry.label,
+            enabled: entry.enabled,
+            current: activeByFamily
+                ? isAccountCurrent(entry.index, activeByFamily)
+                : false,
+            coolingDownUntil: entry.coolingDownUntil,
+            cachedQuota: entry.cachedQuota,
+            cachedQuotaAccountId: entry.cachedQuotaAccountId,
+            currentQuotaAccountId: entry.currentQuotaAccountId,
+            healthScore: getHealthTracker().getScore(entry.index),
+            tier: entry.tier,
+        })), {
+            checkedAt: Date.now(),
+            quotaBackoffUntil: backoffUntil > 0 ? backoffUntil : undefined,
+        }));
     }
-    const isGemini3 = combined.includes("gemini-3") || combined.includes("gemini 3");
-    if (!isGemini3) {
-        return null;
+    catch (error) {
+        log.debug('sidebar-quota-write-failed', { error: String(error) });
     }
-    const family = getModelFamily(modelName);
-    return family === "gemini-flash" ? "gemini-flash" : "gemini-pro";
 }
-function aggregateQuota(models) {
-    const groups = {};
-    const perModel = [];
-    if (!models) {
-        return { groups, perModel, modelCount: 0 };
-    }
-    let totalCount = 0;
-    for (const [modelName, entry] of Object.entries(models)) {
-        const group = classifyQuotaGroup(modelName, entry.displayName ?? entry.modelName);
-        const quotaInfo = entry.quotaInfo;
-        const remainingFraction = quotaInfo
-            ? normalizeRemainingFraction(quotaInfo.remainingFraction)
-            : undefined;
-        const resetTime = quotaInfo?.resetTime;
-        const resetTimestamp = parseResetTime(resetTime);
-        totalCount += 1;
-        // Always preserve per-model data regardless of group classification
-        perModel.push({
-            modelId: modelName,
-            displayName: entry.displayName ?? entry.modelName,
-            group,
-            remainingFraction: remainingFraction ?? 0,
-            resetTime,
+/**
+ * Legacy fallback: fetchAvailableModels → aggregateQuota. Used when
+ * `fetchQuotaSummary` rejects (network, 403, etc.). Extracted so the
+ * concurrent fetch path can reuse the same fallback logic without
+ * duplicating the catch chain.
+ */
+async function fetchLegacyModelsFallback(options) {
+    try {
+        const modelsResponse = await fetchAvailableModels({
+            accessToken: options.accessToken,
+            projectId: options.projectId,
+            endpoints: ANTIGRAVITY_ENDPOINT_FALLBACKS,
+            userAgent: buildAntigravityHarnessUserAgent(),
+            timeoutMs: 10_000,
+            ...(options.fetchVia ? { fetchVia: options.fetchVia } : {}),
         });
-        if (!group) {
-            continue;
+        if (modelsResponse.models) {
+            return aggregateQuota(modelsResponse.models);
         }
-        const existing = groups[group];
-        const nextCount = (existing?.modelCount ?? 0) + 1;
-        const nextRemaining = remainingFraction === undefined
-            ? existing?.remainingFraction
-            : existing?.remainingFraction === undefined
-                ? remainingFraction
-                : Math.min(existing.remainingFraction, remainingFraction);
-        let nextResetTime = existing?.resetTime;
-        if (resetTimestamp !== null) {
-            if (!existing?.resetTime) {
-                nextResetTime = resetTime;
-            }
-            else {
-                const existingTimestamp = parseResetTime(existing.resetTime);
-                if (existingTimestamp === null || resetTimestamp < existingTimestamp) {
-                    nextResetTime = resetTime;
-                }
-            }
-        }
-        groups[group] = {
-            remainingFraction: nextRemaining,
-            resetTime: nextResetTime,
-            modelCount: nextCount,
+        return {
+            groups: {},
+            modelCount: 0,
+            error: 'Failed to fetch Antigravity quota (legacy fallback)',
         };
     }
-    // Sort per-model entries by model ID for consistent display
-    perModel.sort((a, b) => a.modelId.localeCompare(b.modelId));
-    return { groups, perModel, modelCount: totalCount };
-}
-async function fetchWithTimeout(url, options, timeoutMs = FETCH_TIMEOUT_MS) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-        return await fetch(url, { ...options, signal: controller.signal });
-    }
-    finally {
-        clearTimeout(timeout);
+    catch {
+        return {
+            groups: {},
+            modelCount: 0,
+            error: 'Failed to fetch Antigravity quota',
+        };
     }
 }
-async function fetchAvailableModels(accessToken, projectId) {
-    const quotaUserAgent = buildAntigravityHarnessUserAgent();
-    const errors = [];
-    for (const endpoint of ANTIGRAVITY_ENDPOINT_FALLBACKS) {
-        const body = projectId ? { project: projectId } : {};
+function makeFetchAccountQuota(client, providerId, fetchVia) {
+    return async (account, signal) => {
+        const index = 0;
+        const disabled = account.enabled === false;
+        if (disabled) {
+            return {
+                index,
+                email: account.email,
+                status: 'disabled',
+                disabled: true,
+            };
+        }
+        if (signal.aborted) {
+            return {
+                index,
+                email: account.email,
+                status: 'error',
+                error: signal.reason instanceof Error ? signal.reason.message : 'aborted',
+            };
+        }
+        let auth = buildAuthFromAccount(account);
+        let rotatedRefresh;
         try {
-            const response = await fetchWithAgyCliTransport(`${endpoint}/v1internal:fetchAvailableModels`, {
-                method: "POST",
-                headers: {
-                    "User-Agent": quotaUserAgent,
-                    Authorization: `Bearer ${accessToken}`,
-                    "Content-Type": "application/json",
-                    "Accept-Encoding": "gzip",
-                },
-                body: JSON.stringify(body),
-            }, { timeoutMs: FETCH_TIMEOUT_MS });
-            if (response.ok) {
-                return (await response.json());
+            if (accessTokenExpired(auth)) {
+                const refreshed = await refreshAccessToken(auth, client, providerId);
+                if (!refreshed) {
+                    throw new Error('Token refresh failed');
+                }
+                if (refreshed.refresh !== auth.refresh) {
+                    rotatedRefresh = refreshed.refresh;
+                }
+                auth = refreshed;
             }
-            const status = response.status;
-            // 403: retry once without project (like AntigravityManager)
-            if (status === 403 && projectId) {
+            const projectContext = await ensureProjectContext(auth);
+            auth = projectContext.auth;
+            const updatedAccount = applyAccountUpdates(account, auth, projectContext.capturedTier);
+            if (rotatedRefresh && client) {
+                await persistRotatedRefresh(client, providerId, auth).catch(() => { });
+            }
+            let quotaResult;
+            let fellBackToLegacy = false;
+            const authParts = parseRefreshParts(auth.refresh);
+            // Bare refresh tokens have no packed project IDs — fall back to the
+            // account record. The real managedProjectId lives on the persisted
+            // account, not in the packed refresh string.
+            const managedProjectId = authParts.managedProjectId ?? account.managedProjectId;
+            // Two independent payload contracts: the windowed summary
+            // (with legacy fallback) and the gemini-CLI quota. They share
+            // access + project but target different endpoints, so the
+            // two 10s timeouts ran back-to-back for ~20s per account on
+            // modal open. Run them concurrently; either rejection is
+            // handled by its own branch and the result is still merged.
+            const fetchSummaryPayload = (async () => {
                 try {
-                    const retryResponse = await fetchWithAgyCliTransport(`${endpoint}/v1internal:fetchAvailableModels`, {
-                        method: "POST",
-                        headers: {
-                            "User-Agent": quotaUserAgent,
-                            Authorization: `Bearer ${accessToken}`,
-                            "Content-Type": "application/json",
-                            "Accept-Encoding": "gzip",
-                        },
-                        body: JSON.stringify({}),
-                    }, { timeoutMs: FETCH_TIMEOUT_MS });
-                    if (retryResponse.ok) {
-                        return (await retryResponse.json());
-                    }
+                    const summaryResult = await fetchQuotaSummary({
+                        accessToken: auth.access ?? '',
+                        managedProjectId,
+                        projectId: projectContext.effectiveProjectId,
+                        endpoints: ANTIGRAVITY_ENDPOINT_FALLBACKS,
+                        userAgent: buildAntigravityHarnessUserAgent(),
+                        timeoutMs: 10_000,
+                        ...(fetchVia ? { fetchVia } : {}),
+                    });
+                    return {
+                        result: aggregateQuotaSummary(summaryResult.summary),
+                        fellBackToLegacy: summaryResult.fellBackToLegacy ?? false,
+                    };
                 }
                 catch {
-                    // Fall through to next endpoint
+                    return {
+                        result: await fetchLegacyModelsFallback({
+                            accessToken: auth.access ?? '',
+                            projectId: projectContext.effectiveProjectId,
+                            fetchVia,
+                        }),
+                        fellBackToLegacy: true,
+                    };
                 }
-            }
-            // 429/5xx: fall through to next endpoint
-            if (status === 429 || status >= 500) {
-                const message = await response.text().catch(() => "");
-                const snippet = message.trim().slice(0, 200);
-                errors.push(`fetchAvailableModels ${status} at ${endpoint}${snippet ? `: ${snippet}` : ""}`);
-                continue;
-            }
-            // Other errors (4xx): don't retry on different endpoint
-            const message = await response.text().catch(() => "");
-            const snippet = message.trim().slice(0, 200);
-            errors.push(`fetchAvailableModels ${status} at ${endpoint}${snippet ? `: ${snippet}` : ""}`);
-            break;
-        }
-        catch (error) {
-            // Network error or timeout: fall through to next endpoint
-            errors.push(`fetchAvailableModels network error at ${endpoint}: ${error instanceof Error ? error.message : String(error)}`);
-            continue;
-        }
-    }
-    throw new Error(errors.join("; ") || "fetchAvailableModels failed");
-}
-async function fetchGeminiCliQuota(accessToken, projectId) {
-    // Use Gemini CLI user-agent to get CLI quota buckets (not Antigravity buckets)
-    const geminiCliUserAgent = buildGeminiCliUserAgent();
-    for (const endpoint of ANTIGRAVITY_ENDPOINT_FALLBACKS) {
-        const body = projectId ? { project: projectId } : {};
-        try {
-            const response = await fetchWithTimeout(`${endpoint}/v1internal:retrieveUserQuota`, {
-                method: "POST",
-                headers: {
-                    Authorization: `Bearer ${accessToken}`,
-                    "Content-Type": "application/json",
-                    "User-Agent": geminiCliUserAgent,
-                },
-                body: JSON.stringify(body),
+            })();
+            // CLI fetch is independent of the summary fetch. A CLI failure must
+            // NOT kill the summary result, but it also must not be laundered into
+            // "No Gemini CLI quota available" (a permanent-looking status) when
+            // the real cause is a transient network error. Capture the error
+            // message separately so the annotated result can carry it.
+            let geminiCliFetchError;
+            const fetchGeminiCliPayload = fetchGeminiCliQuota({
+                accessToken: auth.access ?? '',
+                projectId: projectContext.effectiveProjectId,
+                endpoints: ANTIGRAVITY_ENDPOINT_FALLBACKS,
+                userAgent: buildGeminiCliUserAgent(),
+                timeoutMs: 10_000,
+                ...(fetchVia ? { fetchVia } : {}),
+            }).catch((error) => {
+                geminiCliFetchError =
+                    error instanceof Error ? error.message : String(error);
+                log.debug('fetchGeminiCliQuota failed', { error: geminiCliFetchError });
+                return { buckets: undefined };
             });
-            if (response.ok) {
-                return (await response.json());
-            }
-            const status = response.status;
-            // 429/5xx: fall through to next endpoint
-            if (status === 429 || status >= 500) {
-                continue;
+            const [summary, geminiCliResponse] = await Promise.all([
+                fetchSummaryPayload,
+                fetchGeminiCliPayload,
+            ]);
+            quotaResult = summary.result;
+            fellBackToLegacy = summary.fellBackToLegacy;
+            const geminiCliQuotaResult = aggregateGeminiCliQuota(geminiCliResponse);
+            const annotated = geminiCliResponse.buckets === undefined ||
+                geminiCliResponse.buckets.length === 0
+                ? {
+                    ...geminiCliQuotaResult,
+                    error: 
+                    // A real fetch exception is a transient failure, not a
+                    // "no CLI configured" scenario — propagate the actual message.
+                    geminiCliFetchError ??
+                        (geminiCliQuotaResult.models.length === 0
+                            ? 'No Gemini CLI quota available'
+                            : undefined),
+                }
+                : geminiCliQuotaResult;
+            for (const [family, groupQuota] of Object.entries(quotaResult.groups)) {
+                const remainingPercent = (groupQuota.remainingFraction ?? 0) * 100;
+                logQuotaStatus(account.email, index, remainingPercent, family);
             }
-            // Other errors: don't retry on different endpoint
-            return { buckets: [] };
+            const legacyTag = fellBackToLegacy ? ' legacy=1' : '';
+            logQuotaFetch('complete', 1, `ok=1 errors=0${legacyTag}`);
+            return {
+                index,
+                email: account.email,
+                status: 'ok',
+                disabled: false,
+                quota: quotaResult,
+                geminiCliQuota: annotated,
+                updatedAccount,
+            };
         }
-        catch {
-            // Network error or timeout: fall through to next endpoint
-            continue;
+        catch (error) {
+            logQuotaFetch('error', undefined, `account=${account.email ?? index} error=${error instanceof Error ? error.message : String(error)}`);
+            return {
+                index,
+                email: account.email,
+                status: 'error',
+                error: error instanceof Error ? error.message : String(error),
+                disabled: false,
+            };
         }
-    }
-    // All endpoints failed
-    return { buckets: [] };
+    };
 }
-function aggregateGeminiCliQuota(response) {
-    const models = [];
-    if (!response.buckets || response.buckets.length === 0) {
-        return { models };
-    }
-    for (const bucket of response.buckets) {
-        if (!bucket.modelId) {
-            continue;
-        }
-        // Filter to relevant Gemini CLI quota models (premium tier)
-        const modelId = bucket.modelId;
-        const isRelevantModel = modelId.startsWith("gemini-3-") ||
-            modelId.startsWith("gemini-3.") ||
-            modelId.startsWith("gemini-2.5-");
-        if (!isRelevantModel) {
-            continue;
-        }
-        models.push({
-            modelId: bucket.modelId,
-            remainingFraction: normalizeRemainingFraction(bucket.remainingFraction),
-            resetTime: bucket.resetTime,
-        });
-    }
-    // Sort by model ID for consistent display
-    models.sort((a, b) => a.modelId.localeCompare(b.modelId));
-    return { models };
+function buildAuthFromAccount(account) {
+    return {
+        type: 'oauth',
+        refresh: formatRefreshParts({
+            refreshToken: account.refreshToken,
+            projectId: account.projectId,
+            managedProjectId: account.managedProjectId,
+        }),
+        access: undefined,
+        expires: undefined,
+    };
 }
-function applyAccountUpdates(account, auth) {
+function applyAccountUpdates(account, auth, capturedTier) {
     const parts = parseRefreshParts(auth.refresh);
     if (!parts.refreshToken) {
         return undefined;
@@ -255,82 +386,83 @@ function applyAccountUpdates(account, auth) {
         refreshToken: parts.refreshToken,
         projectId: parts.projectId ?? account.projectId,
         managedProjectId: parts.managedProjectId ?? account.managedProjectId,
+        // Persist the captured tier alongside the project-context write. Only
+        // present when the loadCodeAssist payload returned a non-empty currentTier.id.
+        ...(capturedTier
+            ? {
+                capturedTierId: capturedTier.id,
+                ...(capturedTier.paidId !== undefined
+                    ? { capturedPaidTierId: capturedTier.paidId }
+                    : {}),
+                capturedTierAt: capturedTier.capturedAt,
+            }
+            : {}),
     };
     const changed = updated.refreshToken !== account.refreshToken ||
         updated.projectId !== account.projectId ||
-        updated.managedProjectId !== account.managedProjectId;
+        updated.managedProjectId !== account.managedProjectId ||
+        updated.capturedTierId !== account.capturedTierId ||
+        updated.capturedPaidTierId !== account.capturedPaidTierId ||
+        // capturedAt represents when the tier was LAST CONFIRMED, not when it
+        // changed -- always update it on a successful observation so consumers
+        // can gate staleness on that timestamp even when the id stays the same.
+        (capturedTier !== undefined &&
+            updated.capturedTierAt !== account.capturedTierAt);
     return changed ? updated : undefined;
 }
-export async function checkAccountsQuota(accounts, client, providerId = ANTIGRAVITY_PROVIDER_ID) {
-    const results = [];
-    logQuotaFetch("start", accounts.length);
-    for (const [index, account] of accounts.entries()) {
-        const disabled = account.enabled === false;
-        let auth = buildAuthFromAccount(account);
+async function persistRotatedRefresh(client, providerId, auth) {
+    await client.auth.set({
+        path: { id: providerId },
+        body: {
+            type: 'oauth',
+            refresh: auth.refresh,
+            access: auth.access ?? '',
+            expires: auth.expires ?? 0,
+        },
+    });
+}
+/**
+ * Build a per-account tier-loader callback for the background poller.
+ *
+ * Calls `loadManagedProject` (loadCodeAssist) directly, bypassing the
+ * `ensureProjectContext` cache that fast-paths on `managedProjectId` and
+ * never returns a tier for existing accounts. One call per account per 24 h.
+ *
+ * Uses the same token-refresh infrastructure as `makeFetchAccountQuota` so
+ * an expired access token does not silently fail the tier lookup.
+ *
+ * `loadManagedProject` uses the production TLS transport (`fetchWithAgyCliTransport`)
+ * and is not interceptable via `fetchVia` -- the same design constraint applies to
+ * `ensureProjectContext`. Tier lookup is best-effort; any failure resolves `null`.
+ */
+export function makeTierLoader(client, providerId) {
+    return async (account) => {
         try {
+            let auth = buildAuthFromAccount(account);
             if (accessTokenExpired(auth)) {
                 const refreshed = await refreshAccessToken(auth, client, providerId);
-                if (!refreshed) {
-                    throw new Error("Token refresh failed");
-                }
+                if (!refreshed)
+                    return null;
                 auth = refreshed;
             }
-            const projectContext = await ensureProjectContext(auth);
-            auth = projectContext.auth;
-            const updatedAccount = applyAccountUpdates(account, auth);
-            let quotaResult;
-            let geminiCliQuotaResult;
-            // Fetch both Antigravity and Gemini CLI quotas in parallel
-            const [antigravityResponse, geminiCliResponse] = await Promise.all([
-                fetchAvailableModels(auth.access ?? "", projectContext.effectiveProjectId)
-                    .catch((error) => ({ models: undefined })),
-                fetchGeminiCliQuota(auth.access ?? "", projectContext.effectiveProjectId),
-            ]);
-            // Process Antigravity quota
-            if (antigravityResponse.models === undefined) {
-                quotaResult = {
-                    groups: {},
-                    modelCount: 0,
-                    error: "Failed to fetch Antigravity quota",
-                };
-            }
-            else {
-                quotaResult = aggregateQuota(antigravityResponse.models);
-            }
-            // Process Gemini CLI quota
-            geminiCliQuotaResult = aggregateGeminiCliQuota(geminiCliResponse);
-            if (geminiCliResponse.buckets === undefined || geminiCliResponse.buckets.length === 0) {
-                geminiCliQuotaResult.error = geminiCliQuotaResult.models.length === 0
-                    ? "No Gemini CLI quota available"
-                    : undefined;
-            }
-            results.push({
-                index,
-                email: account.email,
-                status: "ok",
-                disabled,
-                quota: quotaResult,
-                geminiCliQuota: geminiCliQuotaResult,
-                updatedAccount,
-            });
-            // Log quota status for each family
-            for (const [family, groupQuota] of Object.entries(quotaResult.groups)) {
-                const remainingPercent = (groupQuota.remainingFraction ?? 0) * 100;
-                logQuotaStatus(account.email, index, remainingPercent, family);
-            }
+            const accessToken = auth.access;
+            if (!accessToken)
+                return null;
+            const payload = await loadManagedProject(accessToken);
+            if (!payload?.currentTier?.id)
+                return null;
+            const paidTierId = typeof payload.paidTier === 'string'
+                ? payload.paidTier
+                : payload.paidTier?.id;
+            return {
+                id: payload.currentTier.id,
+                ...(paidTierId ? { paidId: paidTierId } : {}),
+                capturedAt: Date.now(),
+            };
         }
-        catch (error) {
-            results.push({
-                index,
-                email: account.email,
-                status: "error",
-                disabled,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            logQuotaFetch("error", undefined, `account=${account.email ?? index} error=${error instanceof Error ? error.message : String(error)}`);
+        catch {
+            return null;
         }
-    }
-    logQuotaFetch("complete", accounts.length, `ok=${results.filter(r => r.status === "ok").length} errors=${results.filter(r => r.status === "error").length}`);
-    return results;
+    };
 }
 //# sourceMappingURL=quota.js.map