@slkiser/opencode-quota 3.2.0 → 3.4.0

package/dist/plugin.js

@@ -6,7 +6,7 @@
  * Supports GitHub Copilot and Google (via opencode-antigravity-auth).
  */
 import { DEFAULT_CONFIG } from "./lib/types.js";
-import { loadConfig, createLoadConfigMeta } from "./lib/config.js";
+import { createLoadConfigMeta } from "./lib/config.js";
 import { clearCache, getOrFetchWithCacheControl } from "./lib/cache.js";
 import { formatQuotaRows } from "./lib/format.js";
 import { formatQuotaCommand } from "./lib/quota-command-format.js";
@@ -28,6 +28,8 @@ import { renderCommandHeading } from "./lib/format-utils.js";
 import { sanitizeDisplayText } from "./lib/display-sanitize.js";
 import { ALL_WINDOWS_FORMAT_STYLE, SINGLE_WINDOW_PER_PROVIDER_FORMAT_STYLE, resolveQuotaFormatStyle, } from "./lib/quota-format-style.js";
 import { collectQuotaRenderData, collectQuotaStatusLiveProbes, matchesQuotaProviderCurrentSelection, resolveQuotaRenderSelection, } from "./lib/quota-render-data.js";
+import { createQuotaProviderRuntimeContext, createQuotaRuntimeRequestContext, resolveQuotaRuntimeContext, } from "./lib/quota-runtime-context.js";
+const DEFERRED_QUOTA_REFRESH_DELAYS_MS = [3_000, 15_000, 60_000, 300_000];
 /** All token report command specifications */
 const TOKEN_REPORT_COMMANDS = [
     {
@@ -158,8 +160,65 @@ export const QuotaToastPlugin = async ({ client }) => {
     let configLoaded = false;
     let configInFlight = null;
     let configMeta = createLoadConfigMeta();
+    let runtimeProviders = getProviders();
     // Track last session token error for /quota_status diagnostics
     let lastSessionTokenError;
+    const deferredQuotaRefreshes = new Map();
+    function getDeferredQuotaRefreshDelayMs(attempts) {
+        const index = Math.min(Math.max(0, attempts), DEFERRED_QUOTA_REFRESH_DELAYS_MS.length - 1);
+        return DEFERRED_QUOTA_REFRESH_DELAYS_MS[index];
+    }
+    function clearDeferredQuotaRefresh(sessionID) {
+        const state = deferredQuotaRefreshes.get(sessionID);
+        if (state?.timer) {
+            clearTimeout(state.timer);
+        }
+        deferredQuotaRefreshes.delete(sessionID);
+    }
+    function clearDeferredQuotaRefreshTimer(state) {
+        if (!state.timer)
+            return;
+        clearTimeout(state.timer);
+        state.timer = null;
+    }
+    function scheduleDeferredQuotaRefresh(params) {
+        let state = deferredQuotaRefreshes.get(params.sessionID);
+        if (!state) {
+            state = {
+                sessionID: params.sessionID,
+                attempts: 0,
+                reason: params.reason,
+                queuedAtMs: Date.now(),
+                timer: null,
+                inFlight: false,
+            };
+            deferredQuotaRefreshes.set(params.sessionID, state);
+        }
+        else {
+            if (params.incrementAttempts) {
+                state.attempts += 1;
+            }
+            state.reason = params.reason;
+            clearDeferredQuotaRefreshTimer(state);
+        }
+        const delayMs = getDeferredQuotaRefreshDelayMs(state.attempts);
+        state.timer = setTimeout(() => {
+            void runDeferredQuotaRefresh(params.sessionID);
+        }, delayMs);
+        state.timer.unref?.();
+        void log("Deferred quota refresh scheduled", {
+            sessionID: params.sessionID,
+            reason: params.reason,
+            attempts: state.attempts,
+            delayMs,
+        });
+    }
+    async function runDeferredQuotaRefresh(sessionID) {
+        const state = deferredQuotaRefreshes.get(sessionID);
+        if (!state || state.inFlight)
+            return;
+        await showQuotaToast(sessionID, "deferred.retry", { deferredRetry: true });
+    }
     function asRecord(value) {
         return value && typeof value === "object" ? value : null;
     }
@@ -224,13 +283,42 @@ export const QuotaToastPlugin = async ({ client }) => {
         }
         return false;
     }
+    function getPluginRuntimeRootHints() {
+        const cwd = process.cwd();
+        return {
+            workspaceRoot: cwd,
+            configRoot: cwd,
+            fallbackDirectory: cwd,
+        };
+    }
+    async function resolvePluginRuntimeContext(params = {}) {
+        if (!configLoaded) {
+            await refreshConfig();
+        }
+        return resolveQuotaRuntimeContext({
+            client: typedClient,
+            roots: getPluginRuntimeRootHints(),
+            config,
+            configMeta,
+            providers: runtimeProviders,
+            sessionID: params.sessionID,
+            sessionMeta: params.sessionMeta,
+            resolveSessionMeta: (sessionID) => getSessionModelMeta(sessionID),
+            includeSessionMeta: params.includeSessionMeta,
+        });
+    }
     async function refreshConfig() {
         if (configInFlight)
             return configInFlight;
         configInFlight = (async () => {
             try {
-                configMeta = createLoadConfigMeta();
-                config = await loadConfig(typedClient, configMeta);
+                const runtime = await resolveQuotaRuntimeContext({
+                    client: typedClient,
+                    roots: getPluginRuntimeRootHints(),
+                });
+                configMeta = runtime.configMeta;
+                config = runtime.config;
+                runtimeProviders = runtime.providers;
                 setPricingSnapshotAutoRefresh(config.pricingSnapshot.autoRefresh);
                 setPricingSnapshotSelection(config.pricingSnapshot.source);
                 configLoaded = true;
@@ -239,6 +327,8 @@ export const QuotaToastPlugin = async ({ client }) => {
             catch {
                 // Leave configLoaded=false so we can retry on next trigger.
                 config = DEFAULT_CONFIG;
+                configMeta = createLoadConfigMeta();
+                runtimeProviders = getProviders();
                 setPricingSnapshotAutoRefresh(DEFAULT_CONFIG.pricingSnapshot.autoRefresh);
                 setPricingSnapshotSelection(DEFAULT_CONFIG.pricingSnapshot.source);
             }
@@ -394,11 +484,12 @@ export const QuotaToastPlugin = async ({ client }) => {
         }
         return "current session";
     }
-    async function buildQuotaCommandUnavailableMessage(params = {}) {
+    async function buildQuotaCommandUnavailableMessage(runtime) {
         const selection = await resolveQuotaRenderSelection({
-            client: typedClient,
-            config,
-            request: params,
+            client: runtime.client,
+            config: runtime.config,
+            request: createQuotaRuntimeRequestContext(runtime),
+            providers: runtime.providers,
         });
         if (!selection) {
             return "Quota unavailable\n\nNo enabled quota providers are configured.\n\nRun /quota_status for diagnostics.";
@@ -461,177 +552,349 @@ export const QuotaToastPlugin = async ({ client }) => {
     function clearToastCacheForSession(params) {
         clearCache(buildToastCacheKey(params));
     }
-    async function fetchQuotaMessage(params) {
+    function isProviderFetchFailureOnly(errors) {
+        return (errors.length > 0 && errors.every((error) => error.message === "Failed to read quota data"));
+    }
+    async function fetchQuotaMessageResult(params) {
         // Ensure we have loaded config at least once. If load fails, we keep trying
-        // on subsequent triggers.
+        // on subsequent triggers and queue a deferred retry for toast paths.
         if (!configLoaded) {
             await refreshConfig();
         }
+        if (!configLoaded) {
+            return {
+                message: config.debug
+                    ? formatDebugInfo({
+                        trigger: params.trigger,
+                        reason: "config load failed",
+                        enabledProviders: config.enabledProviders,
+                    })
+                    : null,
+                cacheRenderedMessage: false,
+                retryable: true,
+                retryReason: "config_load_failed",
+                hasQuotaRows: false,
+            };
+        }
         if (!config.enabled) {
-            return config.debug
-                ? formatDebugInfo({ trigger: params.trigger, reason: "disabled", enabledProviders: [] })
-                : null;
+            return {
+                message: config.debug
+                    ? formatDebugInfo({ trigger: params.trigger, reason: "disabled", enabledProviders: [] })
+                    : null,
+                cacheRenderedMessage: false,
+                retryable: false,
+                hasQuotaRows: false,
+            };
         }
         if (config.enabledProviders !== "auto" && config.enabledProviders.length === 0) {
-            return config.debug
-                ? formatDebugInfo({
-                    trigger: params.trigger,
-                    reason: "enabledProviders empty",
-                    enabledProviders: [],
-                })
-                : null;
+            return {
+                message: config.debug
+                    ? formatDebugInfo({
+                        trigger: params.trigger,
+                        reason: "enabledProviders empty",
+                        enabledProviders: [],
+                    })
+                    : null,
+                cacheRenderedMessage: false,
+                retryable: false,
+                hasQuotaRows: false,
+            };
         }
-        const quotaRequestContext = {
+        const runtime = await resolvePluginRuntimeContext({
             sessionID: params.sessionID,
-            sessionMeta: config.onlyCurrentModel && params.sessionID
-                ? (params.sessionMeta ?? (await getSessionModelMeta(params.sessionID)))
-                : undefined,
-        };
+            sessionMeta: params.sessionMeta,
+            includeSessionMeta: (config) => config.onlyCurrentModel,
+        });
+        const runtimeConfig = runtime.config;
+        const quotaRequestContext = createQuotaRuntimeRequestContext(runtime);
         const quotaResult = await collectQuotaRenderData({
-            client: typedClient,
-            config,
+            client: runtime.client,
+            config: runtimeConfig,
             request: quotaRequestContext,
             surfaceExplicitProviderIssues: true,
-            formatStyle: resolveQuotaFormatStyle(config.formatStyle),
+            formatStyle: resolveQuotaFormatStyle(runtimeConfig.formatStyle),
+            bypassProviderCache: params.bypassProviderCache,
+            providers: runtime.providers,
         });
         const { selection, availability, active, attemptedAny, hasExplicitProviderIssues, data } = quotaResult;
-        if (config.showSessionTokens && params.sessionID) {
+        if (runtimeConfig.showSessionTokens && params.sessionID) {
             lastSessionTokenError = quotaResult.sessionTokenError;
         }
         const currentModel = selection?.currentModel;
         const errors = data?.errors ?? [];
+        const hasProviderQuotaRows = Boolean(data?.entries.length);
+        const hasQuotaRows = Boolean(hasProviderQuotaRows || data?.sessionTokens);
+        const providerFetchFailureOnly = attemptedAny && isProviderFetchFailureOnly(errors);
+        const retryableAvailabilityFailure = active.length === 0 && availability.some((item) => !item.ok && item.error === true);
         if (active.length === 0 && !(hasExplicitProviderIssues && errors.length > 0)) {
-            return config.debug
+            const message = runtimeConfig.debug
                 ? formatDebugInfo({
                     trigger: params.trigger,
                     reason: "no enabled providers available",
                     currentModel,
-                    enabledProviders: config.enabledProviders,
+                    enabledProviders: runtimeConfig.enabledProviders,
                     availability: availability.map((item) => ({
                         id: item.provider.id,
                         ok: item.ok,
                     })),
                 })
                 : null;
+            const retryableNoProviders = selection?.isAutoMode === true || retryableAvailabilityFailure;
+            return {
+                message,
+                cacheRenderedMessage: false,
+                retryable: retryableNoProviders,
+                retryReason: retryableNoProviders ? "no_available_providers" : undefined,
+                hasQuotaRows: false,
+            };
         }
-        if (data?.entries.length) {
+        if (hasQuotaRows) {
             const formatted = formatQuotaRows({
                 version: "1.0.0",
-                layout: config.layout,
-                entries: data.entries,
-                errors: data.errors,
-                style: resolveQuotaFormatStyle(config.formatStyle),
-                percentDisplayMode: config.percentDisplayMode,
-                sessionTokens: data.sessionTokens,
+                layout: runtimeConfig.layout,
+                entries: data?.entries ?? [],
+                errors: data?.errors ?? [],
+                style: resolveQuotaFormatStyle(runtimeConfig.formatStyle),
+                percentDisplayMode: runtimeConfig.percentDisplayMode,
+                sessionTokens: data?.sessionTokens,
             });
-            if (!config.debug)
-                return formatted;
-            const debugFooter = `\n\n[debug] src=${configMeta.source} providers=${config.enabledProviders === "auto" ? "(auto)" : config.enabledProviders.join(",") || "(none)"} avail=${availability
+            const retryableMaskedProviderFailure = !hasProviderQuotaRows && providerFetchFailureOnly;
+            if (!runtimeConfig.debug) {
+                return {
+                    message: formatted,
+                    cacheRenderedMessage: true,
+                    retryable: retryableMaskedProviderFailure,
+                    retryReason: retryableMaskedProviderFailure ? "provider_fetch_failed" : undefined,
+                    hasQuotaRows: true,
+                };
+            }
+            const debugFooter = `\n\n[debug] src=${configMeta.source} providers=${runtimeConfig.enabledProviders === "auto" ? "(auto)" : runtimeConfig.enabledProviders.join(",") || "(none)"} avail=${availability
                 .map((item) => `${item.provider.id}:${item.ok ? "ok" : "no"}`)
                 .join(" ")}`;
-            return formatted + debugFooter;
+            return {
+                message: formatted + debugFooter,
+                cacheRenderedMessage: false,
+                retryable: retryableMaskedProviderFailure,
+                retryReason: retryableMaskedProviderFailure ? "provider_fetch_failed" : undefined,
+                hasQuotaRows: true,
+            };
         }
         // Show errors even without entries when:
         // 1. showOnBothFail is enabled and at least one provider attempted (existing behavior)
         // 2. OR we're in explicit mode and have "Not configured"/"Unavailable" errors (new behavior)
-        if ((config.showOnBothFail && attemptedAny && errors.length > 0) || hasExplicitProviderIssues) {
+        if ((runtimeConfig.showOnBothFail && attemptedAny && errors.length > 0) ||
+            hasExplicitProviderIssues) {
             const errorLines = errors.map((error) => `${error.label}: ${error.message}`).join("\n");
-            if (!config.debug)
-                return errorLines || "Quota unavailable";
-            return ((errorLines || "Quota unavailable") +
-                "\n\n" +
-                formatDebugInfo({
+            const retryableFetchFailure = !hasExplicitProviderIssues && providerFetchFailureOnly;
+            const retryableFailure = retryableFetchFailure || retryableAvailabilityFailure;
+            const retryReason = retryableFetchFailure
+                ? "provider_fetch_failed"
+                : retryableAvailabilityFailure
+                    ? "no_available_providers"
+                    : undefined;
+            const message = !runtimeConfig.debug
+                ? errorLines || "Quota unavailable"
+                : (errorLines || "Quota unavailable") +
+                    "\n\n" +
+                    formatDebugInfo({
+                        trigger: params.trigger,
+                        reason: hasExplicitProviderIssues
+                            ? "providers missing/unavailable"
+                            : "all providers failed",
+                        currentModel,
+                        enabledProviders: runtimeConfig.enabledProviders,
+                        availability: availability.map((item) => ({
+                            id: item.provider.id,
+                            ok: item.ok,
+                        })),
+                    });
+            return {
+                message,
+                cacheRenderedMessage: false,
+                retryable: retryableFailure,
+                retryReason,
+                hasQuotaRows: false,
+            };
+        }
+        const retryableNoData = providerFetchFailureOnly ||
+            (selection?.isAutoMode === true && active.length > 0 && errors.length === 0);
+        return {
+            message: runtimeConfig.debug
+                ? formatDebugInfo({
                     trigger: params.trigger,
-                    reason: hasExplicitProviderIssues
-                        ? "providers missing/unavailable"
-                        : "all providers failed",
+                    reason: "no entries",
                     currentModel,
-                    enabledProviders: config.enabledProviders,
+                    enabledProviders: runtimeConfig.enabledProviders,
                     availability: availability.map((item) => ({
                         id: item.provider.id,
                         ok: item.ok,
                     })),
-                }));
+                })
+                : null,
+            cacheRenderedMessage: false,
+            retryable: retryableNoData,
+            retryReason: providerFetchFailureOnly
+                ? "provider_fetch_failed"
+                : retryableNoData
+                    ? "no_reportable_data"
+                    : undefined,
+            hasQuotaRows: false,
+        };
+    }
+    async function fetchQuotaMessage(params) {
+        const result = await fetchQuotaMessageResult(params);
+        return result.message;
+    }
+    async function reconcileDeferredQuotaRefresh(params) {
+        const existing = deferredQuotaRefreshes.get(params.sessionID);
+        if (!params.result.retryable) {
+            if (existing) {
+                clearDeferredQuotaRefresh(params.sessionID);
+                await log("Deferred quota refresh cleared", {
+                    sessionID: params.sessionID,
+                    trigger: params.trigger,
+                    reason: params.result.hasQuotaRows ? "quota_rows_available" : "not_retryable",
+                });
+            }
+            return;
         }
-        return config.debug
-            ? formatDebugInfo({
-                trigger: params.trigger,
-                reason: "no entries",
-                currentModel,
-                enabledProviders: config.enabledProviders,
-                availability: availability.map((item) => ({
-                    id: item.provider.id,
-                    ok: item.ok,
-                })),
-            })
-            : null;
+        if (!params.result.retryReason) {
+            return;
+        }
+        scheduleDeferredQuotaRefresh({
+            sessionID: params.sessionID,
+            reason: params.result.retryReason,
+            incrementAttempts: params.consumedDeferredRetry,
+        });
     }
     /**
      * Show quota toast for a session
      */
-    async function showQuotaToast(sessionID, trigger) {
+    async function showQuotaToast(sessionID, trigger, options = {}) {
         if (!configLoaded) {
             await refreshConfig();
         }
-        // Check if subagent session
-        if (await isSubagentSession(sessionID)) {
-            await log("Skipping toast for subagent session", { sessionID, trigger });
-            return;
-        }
-        // Get or fetch quota (with caching/throttling)
-        // If debug is enabled, bypass caching so the toast reflects current state.
-        function shouldCacheToastMessage(msg) {
-            // Cache when we have any quota row (which always includes a "NN%" token).
-            // Do not cache when output is only error rows (rendered as "label: message").
-            const lines = msg.split("\n");
-            return lines.some((l) => /\b\d{1,3}%\b/.test(l) && !/:\s/.test(l));
-        }
-        const sessionMeta = await getSessionModelMeta(sessionID);
-        const bypassMessageCache = config.debug
-            ? true
-            : await shouldBypassToastCacheForLiveLocalUsage({ trigger, sessionID, sessionMeta });
-        const toastCacheKey = buildToastCacheKey({ sessionID, sessionMeta });
-        const message = bypassMessageCache
-            ? await fetchQuotaMessage({ trigger, sessionID, sessionMeta })
-            : await getOrFetchWithCacheControl(toastCacheKey, async () => {
-                const msg = await fetchQuotaMessage({ trigger, sessionID, sessionMeta });
-                const cache = msg ? shouldCacheToastMessage(msg) : true;
-                return { message: msg, cache };
-            }, config.minIntervalMs);
-        if (!message) {
-            await log("No quota message to display", { trigger });
-            return;
-        }
-        if (!config.enableToast) {
-            await log("Toast disabled (enableToast=false)", { trigger });
-            return;
+        const pendingDeferred = deferredQuotaRefreshes.get(sessionID);
+        const consumedDeferredRetry = options.deferredRetry === true || Boolean(pendingDeferred);
+        if (pendingDeferred) {
+            if (pendingDeferred.inFlight && !options.deferredRetry) {
+                await log("Skipping duplicate deferred quota refresh", { sessionID, trigger });
+                return;
+            }
+            pendingDeferred.inFlight = true;
+            clearDeferredQuotaRefreshTimer(pendingDeferred);
         }
-        // Show toast
         try {
-            await typedClient.tui.showToast({
-                body: {
-                    message: sanitizeDisplayText(message),
-                    variant: "info",
-                    duration: config.toastDurationMs,
-                },
+            // Check if session is a subagent session
+            if (await isSubagentSession(sessionID)) {
+                if (consumedDeferredRetry) {
+                    clearDeferredQuotaRefresh(sessionID);
+                }
+                await log("Skipping toast for subagent session", { sessionID, trigger });
+                return;
+            }
+            // Get or fetch quota (with caching/throttling)
+            // If debug is enabled, bypass caching so the toast reflects current state.
+            function shouldCacheToastMessage(msg) {
+                // Cache when we have any quota row (which always includes a "NN%" token).
+                // Do not cache when output is only error rows (rendered as "label: message").
+                const lines = msg.split("\n");
+                return lines.some((l) => /\b\d+%\b/.test(l) && !/:\s/.test(l));
+            }
+            const sessionMeta = await getSessionModelMeta(sessionID);
+            const bypassForLiveLocalUsage = await shouldBypassToastCacheForLiveLocalUsage({
+                trigger,
+                sessionID,
+                sessionMeta,
             });
-            await log("Displayed quota toast", { message, trigger });
-        }
-        catch (err) {
-            await log("Failed to show toast", {
-                error: err instanceof Error ? err.message : String(err),
+            const bypassMessageCache = config.debug || consumedDeferredRetry || bypassForLiveLocalUsage;
+            const bypassProviderCache = consumedDeferredRetry || bypassForLiveLocalUsage;
+            const toastCacheKey = buildToastCacheKey({ sessionID, sessionMeta });
+            let fetchResult;
+            const fetchForToast = () => fetchQuotaMessageResult({
+                trigger,
+                sessionID,
+                sessionMeta,
+                bypassProviderCache,
             });
+            const message = bypassMessageCache
+                ? await (async () => {
+                    fetchResult = await fetchForToast();
+                    return fetchResult.message;
+                })()
+                : await (async () => {
+                    const fetched = {};
+                    const cachedMessage = await getOrFetchWithCacheControl(toastCacheKey, async () => {
+                        const result = await fetchForToast();
+                        fetched.result = result;
+                        const cache = result.message
+                            ? result.cacheRenderedMessage && shouldCacheToastMessage(result.message)
+                            : result.cacheRenderedMessage;
+                        return { message: result.message, cache };
+                    }, config.minIntervalMs);
+                    fetchResult = fetched.result;
+                    return cachedMessage;
+                })();
+            if (fetchResult) {
+                await reconcileDeferredQuotaRefresh({
+                    sessionID,
+                    result: fetchResult,
+                    consumedDeferredRetry,
+                    trigger,
+                });
+            }
+            if (options.deferredRetry && fetchResult && !fetchResult.hasQuotaRows) {
+                await log("Deferred quota refresh did not produce reportable data", {
+                    sessionID,
+                    trigger,
+                    retryable: fetchResult.retryable,
+                    retryReason: fetchResult.retryReason,
+                });
+                return;
+            }
+            if (!message) {
+                await log("No quota message to display", { trigger });
+                return;
+            }
+            if (!config.enableToast) {
+                await log("Toast disabled (enableToast=false)", { trigger });
+                return;
+            }
+            // Show toast
+            try {
+                await typedClient.tui.showToast({
+                    body: {
+                        message: sanitizeDisplayText(message),
+                        variant: "info",
+                        duration: config.toastDurationMs,
+                    },
+                });
+                await log("Displayed quota toast", { message, trigger });
+            }
+            catch (err) {
+                await log("Failed to show toast", {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        finally {
+            const state = deferredQuotaRefreshes.get(sessionID);
+            if (state) {
+                state.inFlight = false;
+            }
         }
     }
-    async function fetchQuotaCommandData(params = {}) {
+    async function fetchQuotaCommandData(runtime) {
+        const request = createQuotaRuntimeRequestContext(runtime);
         const quotaResult = await collectQuotaRenderData({
-            client: typedClient,
-            config,
-            request: params,
+            client: runtime.client,
+            config: runtime.config,
+            request,
             surfaceExplicitProviderIssues: false,
             formatStyle: ALL_WINDOWS_FORMAT_STYLE,
+            providers: runtime.providers,
         });
-        if (config.showSessionTokens && params.sessionID) {
+        if (runtime.config.showSessionTokens && request.sessionID) {
             lastSessionTokenError = quotaResult.sessionTokenError;
         }
         return quotaResult.data;
@@ -656,11 +919,15 @@ export const QuotaToastPlugin = async ({ client }) => {
         });
     }
     async function buildStatusReport(params) {
-        await refreshConfig();
-        if (!config.enabled)
+        const runtime = await resolvePluginRuntimeContext({
+            sessionID: params.sessionID,
+            includeSessionMeta: true,
+        });
+        const runtimeConfig = runtime.config;
+        if (!runtimeConfig.enabled)
             return null;
         await kickPricingRefresh({ reason: "status", maxWaitMs: 750 });
-        const currentSession = await getSessionModelMeta(params.sessionID);
+        const currentSession = runtime.session.sessionMeta ?? {};
         const currentModel = currentSession.modelID;
         const currentProviderID = currentSession.providerID;
         const sessionModelLookup = !params.sessionID
@@ -668,24 +935,13 @@ export const QuotaToastPlugin = async ({ client }) => {
             : currentModel
                 ? "ok"
                 : "not_found";
-        const isAutoMode = config.enabledProviders === "auto";
-        const providers = getProviders();
+        const isAutoMode = runtimeConfig.enabledProviders === "auto";
+        const providers = runtime.providers;
+        const providerContext = createQuotaProviderRuntimeContext(runtime);
         const availability = await Promise.all(providers.map(async (p) => {
             let ok = false;
             try {
-                ok = await p.isAvailable({
-                    client: typedClient,
-                    config: {
-                        googleModels: config.googleModels,
-                        anthropicBinaryPath: config.anthropicBinaryPath,
-                        alibabaCodingPlanTier: config.alibabaCodingPlanTier,
-                        cursorPlan: config.cursorPlan,
-                        cursorIncludedApiUsd: config.cursorIncludedApiUsd,
-                        cursorBillingCycleStartDay: config.cursorBillingCycleStartDay,
-                        currentModel,
-                        currentProviderID,
-                    },
-                });
+                ok = await p.isAvailable(providerContext);
             }
             catch {
                 ok = false;
@@ -693,7 +949,7 @@ export const QuotaToastPlugin = async ({ client }) => {
             return {
                 id: p.id,
                 // In auto mode, a provider is effectively "enabled" if it's available.
-                enabled: isAutoMode ? ok : config.enabledProviders.includes(p.id),
+                enabled: isAutoMode ? ok : runtimeConfig.enabledProviders.includes(p.id),
                 available: ok,
                 matchesCurrentModel: currentModel || isCursorProviderId(currentProviderID)
                     ? matchesQuotaProviderCurrentSelection({
@@ -716,12 +972,9 @@ export const QuotaToastPlugin = async ({ client }) => {
         if (liveProbeProviders.length > 0) {
             try {
                 providerLiveProbes = await collectQuotaStatusLiveProbes({
-                    client: typedClient,
-                    config,
-                    request: {
-                        sessionID: params.sessionID,
-                        sessionMeta: currentSession,
-                    },
+                    client: runtime.client,
+                    config: runtimeConfig,
+                    request: createQuotaRuntimeRequestContext(runtime),
                     formatStyle: SINGLE_WINDOW_PER_PROVIDER_FORMAT_STYLE,
                     providers: liveProbeProviders,
                 });
@@ -743,20 +996,24 @@ export const QuotaToastPlugin = async ({ client }) => {
         const refresh = params.refreshGoogleTokens
             ? await refreshGoogleTokensForAllAccounts({ skewMs: params.skewMs, force: params.force })
             : null;
-        const tuiDiagnostics = await inspectTuiConfig();
+        const tuiDiagnostics = await inspectTuiConfig({ roots: runtime.roots });
         return await buildQuotaStatusReport({
             tuiDiagnostics,
-            configSource: configMeta.source,
-            configPaths: configMeta.paths,
-            networkSettingSources: configMeta.networkSettingSources,
-            enabledProviders: config.enabledProviders,
-            anthropicBinaryPath: config.anthropicBinaryPath,
-            alibabaCodingPlanTier: config.alibabaCodingPlanTier,
-            cursorPlan: config.cursorPlan,
-            cursorIncludedApiUsd: config.cursorIncludedApiUsd,
-            cursorBillingCycleStartDay: config.cursorBillingCycleStartDay,
-            pricingSnapshotSource: config.pricingSnapshot.source,
-            onlyCurrentModel: config.onlyCurrentModel,
+            configSource: runtime.configMeta.source,
+            configPaths: runtime.configMeta.paths,
+            globalConfigPaths: runtime.configMeta.globalConfigPaths,
+            workspaceConfigPaths: runtime.configMeta.workspaceConfigPaths,
+            settingSources: runtime.configMeta.settingSources,
+            configIssues: runtime.configMeta.configIssues,
+            enabledProviders: runtimeConfig.enabledProviders,
+            anthropicBinaryPath: runtimeConfig.anthropicBinaryPath,
+            alibabaCodingPlanTier: runtimeConfig.alibabaCodingPlanTier,
+            cursorPlan: runtimeConfig.cursorPlan,
+            cursorIncludedApiUsd: runtimeConfig.cursorIncludedApiUsd,
+            cursorBillingCycleStartDay: runtimeConfig.cursorBillingCycleStartDay,
+            opencodeGoWindows: runtimeConfig.opencodeGoWindows,
+            pricingSnapshotSource: runtimeConfig.pricingSnapshot.source,
+            onlyCurrentModel: runtimeConfig.onlyCurrentModel,
             currentModel,
             sessionModelLookup,
             providerAvailability: availability,
@@ -770,6 +1027,7 @@ export const QuotaToastPlugin = async ({ client }) => {
                 }
                 : { attempted: false },
             sessionTokenError: lastSessionTokenError,
+            geminiCliClient: typedClient,
             generatedAtMs: params.generatedAtMs,
         });
     }
@@ -832,19 +1090,21 @@ export const QuotaToastPlugin = async ({ client }) => {
     async function handleQuotaSlashCommand(input) {
         const sessionID = input.sessionID;
         const generatedAtMs = Date.now();
-        const quotaRequestContext = {
+        const sessionMeta = sessionID ? await getSessionModelMeta(sessionID) : undefined;
+        const runtime = await resolvePluginRuntimeContext({
             sessionID,
-            sessionMeta: sessionID ? await getSessionModelMeta(sessionID) : undefined,
-        };
-        const reportData = await fetchQuotaCommandData(quotaRequestContext);
+            sessionMeta,
+            includeSessionMeta: (config) => config.onlyCurrentModel,
+        });
+        const reportData = await fetchQuotaCommandData(runtime);
         if (!reportData) {
             if (!configLoaded) {
                 return await injectCommandOutputAndHandle(sessionID, "Quota unavailable (config not loaded, try again)");
             }
-            if (!config.enabled) {
+            if (!runtime.config.enabled) {
                 return await injectCommandOutputAndHandle(sessionID, "Quota disabled in config (enabled: false)");
             }
-            return await injectCommandOutputAndHandle(sessionID, await buildQuotaCommandUnavailableMessage(quotaRequestContext));
+            return await injectCommandOutputAndHandle(sessionID, await buildQuotaCommandUnavailableMessage(runtime));
         }
         return await injectCommandOutputAndHandle(sessionID, formatQuotaCommand({
             ...reportData,
@@ -1087,8 +1347,10 @@ export const QuotaToastPlugin = async ({ client }) => {
             if (!configLoaded) {
                 await refreshConfig();
             }
-            if (!config.enabled)
+            if (!config.enabled) {
+                clearDeferredQuotaRefresh(sessionID);
                 return;
+            }
             if (event.type === "session.idle" && config.showOnIdle) {
                 await showQuotaToast(sessionID, "session.idle");
             }
@@ -1103,8 +1365,10 @@ export const QuotaToastPlugin = async ({ client }) => {
             if (!configLoaded) {
                 await refreshConfig();
             }
-            if (!config.enabled)
+            if (!config.enabled) {
+                clearDeferredQuotaRefresh(input.sessionID);
                 return;
+            }
             if (isSuccessfulQuestionExecution(output)) {
                 const sessionMeta = await getSessionModelMeta(input.sessionID);
                 const model = sessionMeta.modelID;