opencode-antigravity-auth-tweaked 1.9.4 → 1.9.5

package/dist/src/plugin.js

@@ -1,33 +1,35 @@
 import { exec } from "node:child_process";
+import { readFileSync } from "node:fs";
 import { tool } from "@opencode-ai/plugin";
-import { ANTIGRAVITY_DEFAULT_PROJECT_ID, ANTIGRAVITY_ENDPOINT_FALLBACKS, ANTIGRAVITY_ENDPOINT_PROD, ANTIGRAVITY_PROVIDER_ID, getAntigravityHeaders, } from "./constants";
-import { authorizeAntigravity, exchangeAntigravity } from "./antigravity/oauth";
-import { accessTokenExpired, isOAuthAuth, parseRefreshParts, formatRefreshParts } from "./plugin/auth";
-import { promptAddAnotherAccount, promptLoginMode } from "./plugin/cli";
-import { ensureProjectContext } from "./plugin/project";
-import { startAntigravityDebugRequest, logAntigravityDebugResponse, logAccountContext, logRateLimitEvent, logRateLimitSnapshot, logResponseBody, logModelFamily, isDebugEnabled, getLogFilePath, initializeDebug, } from "./plugin/debug";
-import { buildThinkingWarmupBody, isGenerativeLanguageRequest, prepareAntigravityRequest, transformAntigravityResponse, } from "./plugin/request";
-import { decodeEscapedText, normalizeGoogleVerificationUrl, selectBestVerificationUrl, extractVerificationErrorDetails, parseDurationToMs, extractRateLimitBodyInfo, extractRetryInfoFromBody, extractMessageFromRawBody, retryAfterMsFromResponse, } from "./plugin/error-extraction";
-import { resolveModelWithTier } from "./plugin/transform/model-resolver";
-import { isEmptyResponseBody, createSyntheticErrorResponse, } from "./plugin/request-helpers";
-import { EmptyResponseError } from "./plugin/errors";
-import { AntigravityTokenRefreshError, refreshAccessToken } from "./plugin/token";
-import { startOAuthListener } from "./plugin/server";
-import { clearAccounts, loadAccounts, saveAccounts, saveAccountsReplace } from "./plugin/storage";
-import { AccountManager, parseRateLimitReason, calculateBackoffMs, computeSoftQuotaCacheTtlMs } from "./plugin/accounts";
-import { createAutoUpdateCheckerHook } from "./hooks/auto-update-checker";
-import { loadConfig, initRuntimeConfig, wasConfigCreated, getUserConfigPath } from "./plugin/config";
-import { createSessionRecoveryHook, getRecoverySuccessToast } from "./plugin/recovery";
-import { checkAccountsQuota } from "./plugin/quota";
-import { initDiskSignatureCache } from "./plugin/cache";
-import { createProactiveRefreshQueue } from "./plugin/refresh-queue";
-import { initLogger, createLogger } from "./plugin/logger";
-import { initHealthTracker, getHealthTracker, initTokenTracker, getTokenTracker } from "./plugin/rotation";
-import { getConcurrencyTracker } from "./plugin/concurrency";
-import { getSessionAccountManager } from "./plugin/sessions";
-import { initAntigravityVersion } from "./plugin/version";
-import { executeSearch } from "./plugin/search";
-import { initToastService, toast, setChildSession } from "./plugin/ui/toast";
+import { ANTIGRAVITY_DEFAULT_PROJECT_ID, ANTIGRAVITY_ENDPOINT_FALLBACKS, ANTIGRAVITY_ENDPOINT_PROD, ANTIGRAVITY_PROVIDER_ID, getAntigravityHeaders, } from "./constants.js";
+import { authorizeAntigravity, exchangeAntigravity } from "./antigravity/oauth.js";
+import { accessTokenExpired, isOAuthAuth, parseRefreshParts, formatRefreshParts } from "./plugin/auth.js";
+import { promptAddAnotherAccount, promptLoginMode } from "./plugin/cli.js";
+import { ensureProjectContext } from "./plugin/project.js";
+import { startAntigravityDebugRequest, logAntigravityDebugResponse, logAccountContext, logRateLimitEvent, logRateLimitSnapshot, logResponseBody, logModelFamily, isDebugEnabled, getLogFilePath, initializeDebug, } from "./plugin/debug.js";
+import { buildThinkingWarmupBody, isGenerativeLanguageRequest, prepareAntigravityRequest, transformAntigravityResponse, } from "./plugin/request.js";
+import { decodeEscapedText, normalizeGoogleVerificationUrl, selectBestVerificationUrl, extractVerificationErrorDetails, parseDurationToMs, extractRateLimitBodyInfo, extractRetryInfoFromBody, extractMessageFromRawBody, retryAfterMsFromResponse, } from "./plugin/error-extraction.js";
+import { resolveModelWithTier } from "./plugin/transform/model-resolver.js";
+import { isEmptyResponseBody, createSyntheticErrorResponse, } from "./plugin/request-helpers.js";
+import { EmptyResponseError } from "./plugin/errors.js";
+import { AntigravityTokenRefreshError, refreshAccessToken } from "./plugin/token.js";
+import { startOAuthListener } from "./plugin/server.js";
+import { clearAccounts, loadAccounts, saveAccounts, saveAccountsReplace } from "./plugin/storage.js";
+import { AccountManager, parseRateLimitReason, calculateBackoffMs, computeSoftQuotaCacheTtlMs } from "./plugin/accounts.js";
+import { ProactiveQuotaSync } from "./plugin/quota-sync.js";
+import { createAutoUpdateCheckerHook } from "./hooks/auto-update-checker/index.js";
+import { loadConfig, initRuntimeConfig, wasConfigCreated, getUserConfigPath } from "./plugin/config/index.js";
+import { createSessionRecoveryHook, getRecoverySuccessToast } from "./plugin/recovery.js";
+import { checkAccountsQuota } from "./plugin/quota.js";
+import { initDiskSignatureCache } from "./plugin/cache.js";
+import { createProactiveRefreshQueue } from "./plugin/refresh-queue.js";
+import { initLogger, createLogger } from "./plugin/logger.js";
+import { initHealthTracker, getHealthTracker, initTokenTracker, getTokenTracker } from "./plugin/rotation.js";
+import { getConcurrencyTracker } from "./plugin/concurrency.js";
+import { getSessionAccountManager } from "./plugin/sessions.js";
+import { initAntigravityVersion } from "./plugin/version.js";
+import { executeSearch } from "./plugin/search.js";
+import { initToastService, toast, setChildSession } from "./plugin/ui/toast.js";
 const MAX_OAUTH_ACCOUNTS = 10;
 const MAX_WARMUP_SESSIONS = 1000;
 const MAX_WARMUP_RETRIES = 2;
@@ -36,6 +38,25 @@ function getCapacityBackoffDelay(consecutiveFailures) {
     const index = Math.min(consecutiveFailures, CAPACITY_BACKOFF_TIERS_MS.length - 1);
     return CAPACITY_BACKOFF_TIERS_MS[Math.max(0, index)] ?? 5000;
 }
+/**
+ * Map RateLimitReason to health score penalty.
+ */
+function getPenaltyForReason(reason) {
+    switch (reason) {
+        case "QUOTA_EXHAUSTED":
+            return -15;
+        case "ACCESS_DENIED":
+            return -50;
+        case "VERIFICATION_REQUIRED":
+            return -50;
+        case "SAFETY_BLOCKED":
+            return -30;
+        case "RATE_LIMIT_EXCEEDED":
+            return -10;
+        default:
+            return -10;
+    }
+}
 /**
  * Extracts sessionId from a Generative Language request payload if possible.
  */
@@ -55,78 +76,8 @@ function preparedRequestSessionId(input) {
 const warmupAttemptedSessionIds = new Set();
 const warmupSucceededSessionIds = new Set();
 const log = createLogger("plugin");
-// Module-level toast debounce to persist across requests (fixes toast spam)
-const rateLimitToastCooldowns = new Map();
-const RATE_LIMIT_TOAST_COOLDOWN_MS = 5000;
-const MAX_TOAST_COOLDOWN_ENTRIES = 100;
-// Track if "all accounts blocked" toasts were shown to prevent spam in while loop
-let softQuotaToastShown = false;
-let rateLimitToastShown = false;
 // Module-level reference to AccountManager for access from auth.login
 let activeAccountManager = null;
-function cleanupToastCooldowns() {
-    if (rateLimitToastCooldowns.size > MAX_TOAST_COOLDOWN_ENTRIES) {
-        const now = Date.now();
-        for (const [key, time] of rateLimitToastCooldowns) {
-            if (now - time > RATE_LIMIT_TOAST_COOLDOWN_MS * 2) {
-                rateLimitToastCooldowns.delete(key);
-            }
-        }
-    }
-}
-function shouldShowRateLimitToast(message) {
-    cleanupToastCooldowns();
-    const toastKey = message.replace(/\d+/g, "X");
-    const lastShown = rateLimitToastCooldowns.get(toastKey) ?? 0;
-    const now = Date.now();
-    if (now - lastShown < RATE_LIMIT_TOAST_COOLDOWN_MS) {
-        return false;
-    }
-    rateLimitToastCooldowns.set(toastKey, now);
-    return true;
-}
-function resetAllAccountsBlockedToasts() {
-    softQuotaToastShown = false;
-    rateLimitToastShown = false;
-}
-const quotaRefreshInProgressByEmail = new Set();
-async function triggerAsyncQuotaRefreshForAccount(accountManager, accountIndex, client, providerId, intervalMinutes) {
-    if (intervalMinutes <= 0)
-        return;
-    const accounts = accountManager.getAccounts();
-    const account = accounts[accountIndex];
-    if (!account || account.enabled === false)
-        return;
-    const accountKey = account.email ?? `idx-${accountIndex}`;
-    if (quotaRefreshInProgressByEmail.has(accountKey))
-        return;
-    const intervalMs = intervalMinutes * 60 * 1000;
-    const age = account.cachedQuotaUpdatedAt != null
-        ? Date.now() - account.cachedQuotaUpdatedAt
-        : Infinity;
-    if (age < intervalMs)
-        return;
-    quotaRefreshInProgressByEmail.add(accountKey);
-    try {
-        const accountsForCheck = accountManager.getAccountsForQuotaCheck();
-        const singleAccount = accountsForCheck[accountIndex];
-        if (!singleAccount) {
-            quotaRefreshInProgressByEmail.delete(accountKey);
-            return;
-        }
-        const results = await checkAccountsQuota([singleAccount], client, providerId);
-        if (results[0]?.status === "ok" && results[0]?.quota?.groups) {
-            accountManager.updateQuotaCache(accountIndex, results[0].quota.groups);
-            accountManager.requestSaveToDisk();
-        }
-    }
-    catch (err) {
-        log.debug(`quota-refresh-failed email=${accountKey}`, { error: String(err) });
-    }
-    finally {
-        quotaRefreshInProgressByEmail.delete(accountKey);
-    }
-}
 function trackWarmupAttempt(sessionId) {
     if (warmupSucceededSessionIds.has(sessionId)) {
         return false;
@@ -163,7 +114,6 @@ function isWSL() {
     if (process.platform !== "linux")
         return false;
     try {
-        const { readFileSync } = require("node:fs");
         const release = readFileSync("/proc/version", "utf8").toLowerCase();
         return release.includes("microsoft") || release.includes("wsl");
     }
@@ -175,7 +125,6 @@ function isWSL2() {
     if (!isWSL())
         return false;
     try {
-        const { readFileSync } = require("node:fs");
         const version = readFileSync("/proc/version", "utf8").toLowerCase();
         return version.includes("wsl2") || version.includes("microsoft-standard");
     }
@@ -889,6 +838,10 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                 // Note: AccountManager now ensures the current auth is always included in accounts
                 const accountManager = await AccountManager.loadFromDisk(auth);
                 activeAccountManager = accountManager;
+                const quotaSync = new ProactiveQuotaSync(accountManager, client, providerId);
+                if (config.quota_refresh_interval_minutes > 0) {
+                    quotaSync.startPeriodicSync(config.quota_refresh_interval_minutes * 60 * 1000);
+                }
                 if (accountManager.getAccountCount() > 0) {
                     accountManager.requestSaveToDisk();
                 }
@@ -953,9 +906,9 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                         const quietMode = config.quiet_mode;
                         const toastScope = config.toast_scope;
                         // Helper to show toast without blocking on abort (respects quiet_mode and toast_scope via ToastService)
-                        const showToast = async (message, variant) => {
-                            // ToastService handles quiet_mode, toast_scope, and isChildSession
-                            await toast.info(message, { variant, signal: abortSignal });
+                        const showToast = async (message, variant, verbosity = "normal", debounceMs, debounceKey) => {
+                            // ToastService handles quiet_mode, toast_scope, isChildSession, and debouncing
+                            await toast.info(message, { variant, signal: abortSignal, verbosity, debounceMs, debounceKey });
                         };
                         const hasOtherAccountWithAntigravity = (currentAccount) => {
                             if (family !== "gemini")
@@ -964,7 +917,10 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                             return accountManager.hasOtherAccountWithAntigravityAvailable(currentAccount.index, family, model);
                         };
                         let shouldSwitchAccount = false;
-                        while (true) {
+                        let retryCount = 0;
+                        const maxRetries = 20;
+                        while (retryCount < maxRetries) {
+                            retryCount++;
                             // Check for abort at the start of each iteration
                             checkAborted();
                             const accountCount = accountManager.getAccountCount();
@@ -989,7 +945,8 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                             if (!account) {
                                 if (accountManager.areAllAccountsOverSoftQuota(family, config.soft_quota_threshold_percent, softQuotaCacheTtlMs, model)) {
                                     const threshold = config.soft_quota_threshold_percent;
-                                    const softQuotaWaitMs = accountManager.getMinWaitTimeForSoftQuota(family, threshold, softQuotaCacheTtlMs, model);
+                                    const softQuotaInfo = accountManager.getDetailedMinWaitTimeForSoftQuota(family, threshold, softQuotaCacheTtlMs, model);
+                                    const softQuotaWaitMs = softQuotaInfo?.waitMs ?? null;
                                     const maxWaitMs = (config.max_rate_limit_wait_seconds ?? 300) * 1000;
                                     if (softQuotaWaitMs === null || (maxWaitMs > 0 && softQuotaWaitMs > maxWaitMs)) {
                                         const waitTimeFormatted = softQuotaWaitMs ? formatWaitTime(softQuotaWaitMs) : "unknown";
@@ -998,18 +955,16 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                             `Quota resets in ${waitTimeFormatted}. ` +
                                             `Add more accounts, wait for quota reset, or set soft_quota_threshold_percent: 100 to disable.`);
                                     }
-                                    const waitSecValue = Math.max(1, Math.ceil(softQuotaWaitMs / 1000));
                                     pushDebug(`all-over-soft-quota family=${family} accounts=${accountCount} waitMs=${softQuotaWaitMs}`);
-                                    if (!softQuotaToastShown) {
-                                        await showToast(`All ${accountCount} account(s) over ${threshold}% quota. Waiting ${formatWaitTime(softQuotaWaitMs)}...`, "warning");
-                                        softQuotaToastShown = true;
-                                    }
+                                    const earliestLabel = softQuotaInfo?.accountLabel ? ` (Account ${softQuotaInfo.accountLabel})` : "";
+                                    await showToast(`All ${accountCount} account(s) over ${threshold}% quota for ${family}. Earliest reset in ${formatWaitTime(softQuotaWaitMs)}${earliestLabel}.`, "warning", "normal", 60000, `soft-quota-${family}`);
                                     await sleep(softQuotaWaitMs, abortSignal);
                                     continue;
                                 }
                                 const strictWait = !allowQuotaFallback;
                                 // All accounts are rate-limited - wait and retry
-                                const waitMs = accountManager.getMinWaitTimeForFamily(family, model, preferredHeaderStyle, strictWait) || 60_000;
+                                const waitInfo = accountManager.getDetailedMinWaitTimeForFamily(family, model, preferredHeaderStyle, strictWait);
+                                const waitMs = waitInfo?.waitMs ?? 60_000;
                                 const waitSecValue = Math.max(1, Math.ceil(waitMs / 1000));
                                 pushDebug(`all-rate-limited family=${family} accounts=${accountCount} waitMs=${waitMs}`);
                                 if (isDebugEnabled()) {
@@ -1031,16 +986,18 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                         `Quota resets in ${waitTimeFormatted}. ` +
                                         `Add more accounts with \`opencode auth login\` or wait and retry.`);
                                 }
-                                if (!rateLimitToastShown) {
-                                    await showToast(`All ${accountCount} account(s) rate-limited for ${family}. Waiting ${waitSecValue}s...`, "warning");
-                                    rateLimitToastShown = true;
-                                }
+                                const earliestLabel = waitInfo?.accountLabel ? ` (Account ${waitInfo.accountLabel})` : "";
+                                await showToast(`All ${accountCount} account(s) rate-limited for ${family}. Earliest reset in ${formatWaitTime(waitMs)}${earliestLabel}.`, "warning", "normal", 60000, `rate-limit-${family}`);
                                 // Wait for the rate-limit cooldown to expire, then retry
                                 await sleep(waitMs, abortSignal);
                                 continue;
                             }
-                            // Account is available - reset the toast flag
-                            resetAllAccountsBlockedToasts();
+                            // Account is available
+                            if (account.verificationRequired) {
+                                const reason = account.verificationRequiredReason || "Google requires account verification.";
+                                const urlMsg = account.verificationUrl ? ` URL: ${account.verificationUrl}` : "";
+                                await showToast(`⚠ Account ${account.email || account.index + 1} needs verification: ${reason}${urlMsg}. Run 'opencode auth login' and use 'Verify accounts'.`, "warning", "minimal", 60000, `verify-needed-${account.index}`);
+                            }
                             pushDebug(`selected idx=${account.index} email=${account.email ?? ""} family=${family} accounts=${accountCount} strategy=${config.account_selection_strategy}`);
                             if (isDebugEnabled()) {
                                 logAccountContext("Selected", {
@@ -1052,13 +1009,12 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                 });
                             }
                             // Show toast when switching to a different account (debounced, quiet_mode handled by showToast)
-                            if (accountCount > 1 && accountManager.shouldShowAccountToast(account.index)) {
+                            if (accountCount > 1) {
                                 const accountLabel = account.email || `Account ${account.index + 1}`;
                                 // Calculate position among enabled accounts (not absolute index)
                                 const enabledAccounts = accountManager.getEnabledAccounts();
                                 const enabledPosition = enabledAccounts.findIndex(a => a.index === account.index) + 1;
-                                await showToast(`Using ${accountLabel} (${enabledPosition}/${accountCount})`, "info");
-                                accountManager.markToastShown(account.index);
+                                await showToast(`Using ${accountLabel} (${enabledPosition}/${accountCount})`, "info", "normal", 30000, `account-switch-${account.index}`);
                             }
                             accountManager.requestSaveToDisk();
                             let authRecord = accountManager.toAuthDetails(account);
@@ -1241,7 +1197,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                             alternateStyle,
                                         });
                                         if (fallbackStyle) {
-                                            await toast.info(`Antigravity quota exhausted on all accounts. Using Gemini CLI quota.`, { variant: "warning" });
+                                            await toast.info(`Antigravity quota exhausted on all accounts. Using Gemini CLI quota.`, { variant: "warning", verbosity: "normal" });
                                             headerStyle = fallbackStyle;
                                             pushDebug(`all-accounts antigravity exhausted, quota fallback: ${headerStyle}`);
                                         }
@@ -1262,7 +1218,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                     if (fallbackStyle) {
                                         const quotaName = headerStyle === "gemini-cli" ? "Gemini CLI" : "Antigravity";
                                         const altQuotaName = fallbackStyle === "gemini-cli" ? "Gemini CLI" : "Antigravity";
-                                        await toast.info(`${quotaName} quota exhausted, using ${altQuotaName} quota`, { variant: "warning" });
+                                        await toast.info(`${quotaName} quota exhausted, using ${altQuotaName} quota`, { variant: "warning", verbosity: "normal" });
                                         headerStyle = fallbackStyle;
                                         pushDebug(`quota fallback: ${headerStyle}`);
                                     }
@@ -1428,7 +1384,8 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                                 pushDebug(`429/5xx NO MESSAGE - rawBody preview: ${bodyInfo.rawBody.slice(0, 200)}`);
                                             logRateLimitEvent(account.index, account.email, family, response.status, effectiveDelayMs, bodyInfo);
                                             await logResponseBody(debugContext, response, response.status);
-                                            getHealthTracker().recordRateLimit(account.index);
+                                            const penalty = getPenaltyForReason(rateLimitReason);
+                                            getHealthTracker().recordRateLimit(account.index, penalty);
                                             // Define display reason for user feedback
                                             // Never show "UNKNOWN" - show the actual server message or "NO_BODY" instead
                                             let displayReason;
@@ -1457,7 +1414,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                                 const totalWaitMs = effectiveDelayMs + extraWaitMs;
                                                 const waitSec = Math.ceil(totalWaitMs / 1000);
                                                 pushDebug(`Rate limited (${rateLimitReason}), waiting ${totalWaitMs}ms (${effectiveDelayMs} + ${extraWaitMs} jitter)`);
-                                                await showToast(`⏳ Rate limited (${displayReason}). Waiting ${waitSec}s to retry same account...`, "warning");
+                                                await showToast(`⏳ Rate limited (${displayReason}). Waiting ${waitSec}s to retry same account...`, "warning", "verbose", 30000, `retry-same-account-${account.index}`);
                                                 // If this is a repeated hit, try regenerating fingerprint as a mitigation
                                                 if (attempt > 1) {
                                                     pushDebug(`Regenerating fingerprint for account ${account.index} after ${attempt} consecutive hits`);
@@ -1478,7 +1435,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                                     // Check if any other account has Antigravity quota for this model
                                                     if (hasOtherAccountWithAntigravity(account)) {
                                                         pushDebug(`antigravity exhausted on account ${account.index}, but available on others. Switching account.`);
-                                                        await showToast(`Quota exhausted. Switching account in 5s...`, "warning");
+                                                        await showToast(`Quota exhausted. Switching account in 5s...`, "warning", "normal", 30000, "quota-exhausted-switch");
                                                         await sleep(SWITCH_ACCOUNT_DELAY_MS, abortSignal);
                                                         shouldSwitchAccount = true;
                                                         currentAccountDone = true;
@@ -1496,7 +1453,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                                         });
                                                         if (fallbackStyle) {
                                                             const safeModelName = model || "this model";
-                                                            await toast.info(`Antigravity quota exhausted for ${safeModelName}. Switching to Gemini CLI quota...`, { variant: "warning" });
+                                                            await toast.info(`Antigravity quota exhausted for ${safeModelName}. Switching to Gemini CLI quota...`, { variant: "warning", verbosity: "normal", debounceMs: 30000, debounceKey: "quota-fallback" });
                                                             headerStyle = fallbackStyle;
                                                             pushDebug(`quota fallback: ${headerStyle}`);
                                                             continue;
@@ -1513,7 +1470,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                                         });
                                                         if (fallbackStyle) {
                                                             const safeModelName = model || "this model";
-                                                            await toast.info(`Gemini CLI quota exhausted for ${safeModelName}. Switching to Antigravity quota...`, { variant: "warning" });
+                                                            await toast.info(`Gemini CLI quota exhausted for ${safeModelName}. Switching to Antigravity quota...`, { variant: "warning", verbosity: "normal", debounceMs: 30000, debounceKey: "quota-fallback" });
                                                             headerStyle = fallbackStyle;
                                                             pushDebug(`quota fallback: ${headerStyle}`);
                                                             continue;
@@ -1529,7 +1486,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                                 const toastMsg = rateLimitReason === "QUOTA_EXHAUSTED"
                                                     ? `Quota exhausted${quotaMsg}. Switching account in 5s...`
                                                     : `Quota reached (${displayReason}) for ${accountLabel}. Switching account in 5s...${quotaMsg}`;
-                                                await showToast(toastMsg, "error");
+                                                await showToast(toastMsg, "error", "normal", 30000, "quota-reached-switch");
                                                 await sleep(SWITCH_ACCOUNT_DELAY_MS, abortSignal);
                                             }
                                             else {
@@ -1539,7 +1496,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                                     const quotaMsg = bodyInfo.quotaResetTime
                                                         ? ` (quota resets ${bodyInfo.quotaResetTime})`
                                                         : ``;
-                                                    await showToast(`Quota exhausted${quotaMsg}. Add another account or wait until quota resets.`, "error");
+                                                    await showToast(`Quota exhausted${quotaMsg}. Add another account or wait until quota resets.`, "error", "minimal");
                                                     // Don't retry - just fail and let the user handle it
                                                     lastFailure = createFailureContext(response);
                                                     break;
@@ -1548,7 +1505,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                                     // Other errors - use exponential backoff (1s, 2s, 4s, 8s... max 60s)
                                                     const expBackoffMs = Math.min(FIRST_RETRY_DELAY_MS * Math.pow(2, attempt - 1), 60000);
                                                     const expBackoffFormatted = expBackoffMs >= 1000 ? `${Math.round(expBackoffMs / 1000)}s` : `${expBackoffMs}ms`;
-                                                    await showToast(`Quota reached (${displayReason}). Retrying in ${expBackoffFormatted} (attempt ${attempt})...`, "error");
+                                                    await showToast(`Quota reached (${displayReason}). Retrying in ${expBackoffFormatted} (attempt ${attempt})...`, "error", "verbose");
                                                     await sleep(expBackoffMs, abortSignal);
                                                 }
                                             }
@@ -1565,18 +1522,15 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                             const errorBodyText = await response.clone().text().catch(() => "");
                                             const extracted = extractVerificationErrorDetails(errorBodyText);
                                             if (extracted.validationRequired) {
-                                                const verificationReason = extracted.message ?? "Google requires account verification.";
+                                                const verificationReason = extracted.message || "Google requires account verification.";
                                                 const cooldownMs = 10 * 60 * 1000;
                                                 accountManager.markAccountVerificationRequired(account.index, verificationReason, extracted.verifyUrl);
                                                 accountManager.markAccountCoolingDown(account, cooldownMs, "validation-required");
                                                 accountManager.markRateLimited(account, cooldownMs, family, headerStyle, model);
                                                 const label = account.email || `Account ${account.index + 1}`;
-                                                if (accountManager.shouldShowAccountToast(account.index, 60000)) {
-                                                    await toast.info(`⚠ ${label} needs verification. Run 'opencode auth login' and use Verify accounts.`, { variant: "warning" });
-                                                    accountManager.markToastShown(account.index);
-                                                }
+                                                await toast.info(`🚨 Verification Required for ${label}: ${verificationReason}. Please run 'opencode auth login' and follow the 'Verify accounts' flow to restore access.`, { variant: "error", force: true, verbosity: "minimal" });
                                                 pushDebug(`verification-required: disabled account ${account.index}`);
-                                                getHealthTracker().recordFailure(account.index);
+                                                getHealthTracker().recordFailure(account.index, getPenaltyForReason("VERIFICATION_REQUIRED"));
                                                 lastFailure = createFailureContext(response);
                                                 shouldSwitchAccount = true;
                                                 currentAccountDone = true;
@@ -1596,7 +1550,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                             account.consecutiveFailures = 0;
                                             getHealthTracker().recordSuccess(account.index);
                                             accountManager.markAccountUsed(account.index);
-                                            void triggerAsyncQuotaRefreshForAccount(accountManager, account.index, client, providerId, config.quota_refresh_interval_minutes);
+                                            quotaSync.enqueue(account.index);
                                         }
                                         logAntigravityDebugResponse(debugContext, response, {
                                             note: response.ok ? "Success" : `Error ${response.status}`,
@@ -1611,7 +1565,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                                 const cloned = response.clone();
                                                 const bodyText = await cloned.text();
                                                 if (bodyText.includes("Prompt is too long") || bodyText.includes("prompt_too_long")) {
-                                                    await toast.info("Context too long - use /compact to reduce size", { variant: "warning" });
+                                                    await toast.info("Context too long - use /compact to reduce size", { variant: "warning", debounceMs: 10000, debounceKey: "context-too-long" });
                                                     const errorMessage = `[Antigravity Error] Context is too long for this model.\n\nPlease use /compact to reduce context size, then retry your request.\n\nAlternatively, you can:\n- Use /clear to start fresh\n- Use /undo to remove recent messages\n- Switch to a model with larger context window`;
                                                     return createSyntheticErrorResponse(errorMessage, prepared.requestedModel);
                                                 }
@@ -1633,7 +1587,7 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                                 emptyResponseAttempts.set(emptyAttemptKey, currentAttempts);
                                                 pushDebug(`empty-response: attempt ${currentAttempts}/${maxAttempts}`);
                                                 if (currentAttempts < maxAttempts) {
-                                                    await toast.info(`Empty response received. Retrying (${currentAttempts}/${maxAttempts})...`, { variant: "warning" });
+                                                    await toast.info(`Empty response received. Retrying (${currentAttempts}/${maxAttempts})...`, { variant: "warning", verbosity: "verbose" });
                                                     await sleep(retryDelayMs, abortSignal);
                                                     continue; // Retry the endpoint loop
                                                 }
@@ -1650,10 +1604,10 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                         const contextError = transformedResponse.headers.get("x-antigravity-context-error");
                                         if (contextError) {
                                             if (contextError === "prompt_too_long") {
-                                                await toast.info("Context too long - use /compact to reduce size, or trim your request", { variant: "warning" });
+                                                await toast.info("Context too long - use /compact to reduce size, or trim your request", { variant: "warning", debounceMs: 10000, debounceKey: "context-too-long" });
                                             }
                                             else if (contextError === "tool_pairing") {
-                                                await toast.info("Tool call/result mismatch - use /compact to fix, or /undo last message", { variant: "warning" });
+                                                await toast.info("Tool call/result mismatch - use /compact to fix, or /undo last message", { variant: "warning", debounceMs: 10000, debounceKey: "tool-pairing-error" });
                                             }
                                         }
                                         return transformedResponse;
@@ -1703,11 +1657,11 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                             pushDebug(`endpoint-error: cooldown ${cooldownMs}ms after ${failures} failures`);
                                         }
                                         if (accountCount > 1) {
-                                            await showToast(`Request failed for ${accountLabel} (${errorMsg}). Switching account in 5s...`, "error");
+                                            await showToast(`Request failed for ${accountLabel} (${errorMsg}). Switching account in 5s...`, "error", "normal");
                                             await sleep(SWITCH_ACCOUNT_DELAY_MS, abortSignal);
                                         }
                                         else {
-                                            await showToast(`Request failed: ${errorMsg}. Retrying in 5s...`, "error");
+                                            await showToast(`Request failed: ${errorMsg}. Retrying in 5s...`, "error", "verbose");
                                             await sleep(SWITCH_ACCOUNT_DELAY_MS, abortSignal);
                                         }
                                         shouldSwitchAccount = true;