@slkiser/opencode-quota 2.6.2 → 2.9.0

package/dist/plugin.js

@@ -16,12 +16,13 @@ import { aggregateUsage } from "./lib/quota-stats.js";
 import { fetchSessionTokensForDisplay } from "./lib/session-tokens.js";
 import { formatQuotaStatsReport } from "./lib/quota-stats-format.js";
 import { buildQuotaStatusReport } from "./lib/quota-status.js";
-import { maybeRefreshPricingSnapshot } from "./lib/modelsdev-pricing.js";
+import { getPricingSnapshotMeta, getPricingSnapshotSource, getRuntimePricingRefreshStatePath, getRuntimePricingSnapshotPath, maybeRefreshPricingSnapshot, setPricingSnapshotAutoRefresh, setPricingSnapshotSelection, } from "./lib/modelsdev-pricing.js";
 import { refreshGoogleTokensForAllAccounts } from "./lib/google.js";
 import { getQuotaProviderDisplayLabel } from "./lib/provider-metadata.js";
 import { DEFAULT_ALIBABA_AUTH_CACHE_MAX_AGE_MS, isAlibabaModelId, resolveAlibabaCodingPlanAuthCached, } from "./lib/alibaba-auth.js";
 import { isQwenCodeModelId, resolveQwenLocalPlanCached, } from "./lib/qwen-auth.js";
 import { recordAlibabaCodingPlanCompletion, recordQwenCompletion, } from "./lib/qwen-local-quota.js";
+import { isCursorModelId, isCursorProviderId } from "./lib/cursor-pricing.js";
 import { parseOptionalJsonArgs, parseQuotaBetweenArgs, startOfLocalDayMs, startOfNextLocalDayMs, formatYmd, } from "./lib/command-parsing.js";
 import { handled } from "./lib/command-handled.js";
 import { renderCommandHeading } from "./lib/format-utils.js";
@@ -30,7 +31,7 @@ const TOKEN_REPORT_COMMANDS = [
     {
         id: "tokens_today",
         template: "/tokens_today",
-        description: "Token + official API cost summary for today (calendar day, local timezone).",
+        description: "Token + deterministic cost summary for today (calendar day, local timezone).",
         title: "Tokens used (Today) (/tokens_today)",
         metadataTitle: "Tokens used (Today)",
         kind: "today",
@@ -38,7 +39,7 @@ const TOKEN_REPORT_COMMANDS = [
     {
         id: "tokens_daily",
         template: "/tokens_daily",
-        description: "Token + official API cost summary for the last 24 hours (rolling).",
+        description: "Token + deterministic cost summary for the last 24 hours (rolling).",
         title: "Tokens used (Last 24 Hours) (/tokens_daily)",
         metadataTitle: "Tokens used (Last 24 Hours)",
         kind: "rolling",
@@ -47,7 +48,7 @@ const TOKEN_REPORT_COMMANDS = [
     {
         id: "tokens_weekly",
         template: "/tokens_weekly",
-        description: "Token + official API cost summary for the last 7 days (rolling).",
+        description: "Token + deterministic cost summary for the last 7 days (rolling).",
         title: "Tokens used (Last 7 Days) (/tokens_weekly)",
         metadataTitle: "Tokens used (Last 7 Days)",
         kind: "rolling",
@@ -56,7 +57,7 @@ const TOKEN_REPORT_COMMANDS = [
     {
         id: "tokens_monthly",
         template: "/tokens_monthly",
-        description: "Token + official API cost summary for the last 30 days (rolling).",
+        description: "Token + deterministic cost summary for the last 30 days (rolling).",
         title: "Tokens used (Last 30 Days) (/tokens_monthly)",
         metadataTitle: "Tokens used (Last 30 Days)",
         kind: "rolling",
@@ -65,7 +66,7 @@ const TOKEN_REPORT_COMMANDS = [
     {
         id: "tokens_all",
         template: "/tokens_all",
-        description: "Token + official API cost summary for all locally saved OpenCode history.",
+        description: "Token + deterministic cost summary for all locally saved OpenCode history.",
         title: "Tokens used (All Time) (/tokens_all)",
         metadataTitle: "Tokens used (All Time)",
         kind: "all",
@@ -75,7 +76,7 @@ const TOKEN_REPORT_COMMANDS = [
     {
         id: "tokens_session",
         template: "/tokens_session",
-        description: "Token + official API cost summary for current session only.",
+        description: "Token + deterministic cost summary for current session only.",
         title: "Tokens used (Current Session) (/tokens_session)",
         metadataTitle: "Tokens used (Current Session)",
         kind: "session",
@@ -83,7 +84,7 @@ const TOKEN_REPORT_COMMANDS = [
     {
         id: "tokens_between",
         template: "/tokens_between",
-        description: "Token + cost report between two YYYY-MM-DD dates (local timezone, inclusive).",
+        description: "Token + deterministic cost report between two YYYY-MM-DD dates (local timezone, inclusive).",
         titleForRange: (startYmd, endYmd) => {
             return `Tokens used (${formatYmd(startYmd)} .. ${formatYmd(endYmd)}) (/tokens_between)`;
         },
@@ -106,7 +107,7 @@ function isTokenReportCommand(cmd) {
 // =============================================================================
 // Plugin Implementation
 // =============================================================================
-const LOCAL_REQUEST_PLAN_PROVIDER_IDS = new Set(["qwen-code", "alibaba-coding-plan"]);
+const LIVE_LOCAL_USAGE_PROVIDER_IDS = new Set(["qwen-code", "alibaba-coding-plan", "cursor"]);
 /**
  * Main plugin export
  */
@@ -152,20 +153,45 @@ export const QuotaToastPlugin = async ({ client }) => {
     let lastSessionTokenError;
     const providerFetchCache = new Map();
     function getQuotaCommandCache() {
-        let quotaCache = globalThis.__opencodeQuotaCommandCache;
-        if (!quotaCache) {
-            quotaCache = { body: "", timestamp: 0 };
-            globalThis.__opencodeQuotaCommandCache = quotaCache;
+        const existing = globalThis.__opencodeQuotaCommandCache;
+        if (existing instanceof Map) {
+            return existing;
         }
+        const quotaCache = new Map();
+        globalThis.__opencodeQuotaCommandCache = quotaCache;
         return quotaCache;
     }
     function clearQuotaCommandCache() {
-        const quotaCache = globalThis.__opencodeQuotaCommandCache;
-        if (!quotaCache)
-            return;
-        quotaCache.body = "";
-        quotaCache.timestamp = 0;
-        quotaCache.inFlight = undefined;
+        getQuotaCommandCache().clear();
+    }
+    function buildQuotaCommandCacheKey(params) {
+        const enabledProviders = config.enabledProviders === "auto" ? "auto" : config.enabledProviders.join(",");
+        const googleModels = config.googleModels.join(",");
+        const currentModel = config.onlyCurrentModel && params.sessionID ? params.sessionMeta?.modelID ?? "" : "";
+        const currentProviderID = config.onlyCurrentModel && params.sessionID ? params.sessionMeta?.providerID ?? "" : "";
+        return [
+            `sessionID=${params.sessionID ?? ""}`,
+            `showSessionTokens=${config.showSessionTokens ? "yes" : "no"}`,
+            `onlyCurrentModel=${config.onlyCurrentModel ? "yes" : "no"}`,
+            `enabledProviders=${enabledProviders}`,
+            `googleModels=${googleModels}`,
+            `alibabaTier=${config.alibabaCodingPlanTier}`,
+            `cursorPlan=${config.cursorPlan}`,
+            `cursorIncludedApiUsd=${config.cursorIncludedApiUsd ?? ""}`,
+            `cursorBillingCycleStartDay=${config.cursorBillingCycleStartDay ?? ""}`,
+            `currentModel=${currentModel}`,
+            `currentProviderID=${currentProviderID}`,
+        ].join("|");
+    }
+    function pruneQuotaCommandCache(ttlMs, nowMs) {
+        const quotaCache = getQuotaCommandCache();
+        for (const [cacheKey, entry] of quotaCache.entries()) {
+            if (entry.inFlight)
+                continue;
+            if (entry.timestamp <= 0 || ttlMs <= 0 || nowMs - entry.timestamp >= ttlMs) {
+                quotaCache.delete(cacheKey);
+            }
+        }
     }
     function asRecord(value) {
         return value && typeof value === "object" ? value : null;
@@ -210,14 +236,18 @@ export const QuotaToastPlugin = async ({ client }) => {
         const style = ctx.config.toastStyle ?? "classic";
         const googleModels = ctx.config.googleModels.join(",");
         const alibabaCodingPlanTier = ctx.config.alibabaCodingPlanTier;
+        const cursorPlan = ctx.config.cursorPlan;
+        const cursorIncludedApiUsd = ctx.config.cursorIncludedApiUsd ?? "";
+        const cursorBillingCycleStartDay = ctx.config.cursorBillingCycleStartDay ?? "";
         const onlyCurrentModel = ctx.config.onlyCurrentModel ? "yes" : "no";
         const currentModel = ctx.config.currentModel ?? "";
-        return `${providerId}|style=${style}|googleModels=${googleModels}|alibabaTier=${alibabaCodingPlanTier}|onlyCurrentModel=${onlyCurrentModel}|currentModel=${currentModel}`;
+        const currentProviderID = ctx.config.currentProviderID ?? "";
+        return `${providerId}|style=${style}|googleModels=${googleModels}|alibabaTier=${alibabaCodingPlanTier}|cursorPlan=${cursorPlan}|cursorIncludedApiUsd=${cursorIncludedApiUsd}|cursorBillingCycleStartDay=${cursorBillingCycleStartDay}|onlyCurrentModel=${onlyCurrentModel}|currentModel=${currentModel}|currentProviderID=${currentProviderID}`;
     }
     async function fetchProviderWithCache(params) {
         const { provider, ctx, ttlMs } = params;
-        // Local request-plan providers should update per completion for accurate rolling counters.
-        if (LOCAL_REQUEST_PLAN_PROVIDER_IDS.has(provider.id)) {
+        // Live local-usage providers should update per completion for accurate local reports.
+        if (LIVE_LOCAL_USAGE_PROVIDER_IDS.has(provider.id)) {
             return await provider.fetch(ctx);
         }
         const cacheKey = makeProviderFetchCacheKey(provider.id, ctx);
@@ -255,30 +285,67 @@ export const QuotaToastPlugin = async ({ client }) => {
         });
         return promise;
     }
-    async function shouldBypassToastCacheForLocalRequestPlan(trigger, sessionID) {
+    function makeProviderFetchFailure(provider) {
+        return {
+            attempted: true,
+            entries: [],
+            errors: [
+                {
+                    label: getQuotaProviderDisplayLabel(provider.id),
+                    message: "Failed to read quota data",
+                },
+            ],
+        };
+    }
+    async function fetchProviderResults(params) {
+        const settled = await Promise.allSettled(params.providers.map((provider) => fetchProviderWithCache({
+            provider,
+            ctx: params.ctx,
+            ttlMs: params.ttlMs,
+        })));
+        return settled.map((result, index) => result.status === "fulfilled"
+            ? result.value
+            : makeProviderFetchFailure(params.providers[index]));
+    }
+    function getExplicitNoDataMessage(provider) {
+        if (provider.id === "cursor") {
+            return "No local usage yet";
+        }
+        return "Not configured";
+    }
+    function isProviderEnabled(providerId) {
+        return config.enabledProviders === "auto" || config.enabledProviders.includes(providerId);
+    }
+    async function shouldBypassToastCacheForLiveLocalUsage(params) {
+        const { trigger, sessionID } = params;
         if (trigger !== "question")
             return false;
-        const currentModel = await getCurrentModel(sessionID);
+        const currentSession = params.sessionMeta ?? (await getSessionModelMeta(sessionID));
+        const currentModel = currentSession.modelID;
         if (isQwenCodeModelId(currentModel)) {
             const plan = await resolveQwenLocalPlanCached();
-            return (plan.state === "qwen_free" &&
-                (config.enabledProviders === "auto" || config.enabledProviders.includes("qwen-code")));
+            return plan.state === "qwen_free" && isProviderEnabled("qwen-code");
         }
         if (isAlibabaModelId(currentModel)) {
             const plan = await resolveAlibabaCodingPlanAuthCached({
                 maxAgeMs: DEFAULT_ALIBABA_AUTH_CACHE_MAX_AGE_MS,
                 fallbackTier: config.alibabaCodingPlanTier,
             });
-            return (plan.state === "configured" &&
-                (config.enabledProviders === "auto" ||
-                    config.enabledProviders.includes("alibaba-coding-plan")));
+            return plan.state === "configured" && isProviderEnabled("alibaba-coding-plan");
+        }
+        if (isCursorProviderId(currentSession.providerID) || isCursorModelId(currentModel)) {
+            return isProviderEnabled("cursor");
         }
         return false;
     }
-    async function shouldBypassQuotaCommandCache(sessionID) {
+    async function shouldBypassQuotaCommandCache(sessionID, sessionMeta) {
         if (config.debug || !sessionID)
             return config.debug;
-        return await shouldBypassToastCacheForLocalRequestPlan("question", sessionID);
+        return await shouldBypassToastCacheForLiveLocalUsage({
+            trigger: "question",
+            sessionID,
+            sessionMeta,
+        });
     }
     async function refreshConfig() {
         if (configInFlight)
@@ -287,11 +354,15 @@ export const QuotaToastPlugin = async ({ client }) => {
             try {
                 configMeta = createLoadConfigMeta();
                 config = await loadConfig(typedClient, configMeta);
+                setPricingSnapshotAutoRefresh(config.pricingSnapshot.autoRefresh);
+                setPricingSnapshotSelection(config.pricingSnapshot.source);
                 configLoaded = true;
             }
             catch {
                 // Leave configLoaded=false so we can retry on next trigger.
                 config = DEFAULT_CONFIG;
+                setPricingSnapshotAutoRefresh(DEFAULT_CONFIG.pricingSnapshot.autoRefresh);
+                setPricingSnapshotSelection(DEFAULT_CONFIG.pricingSnapshot.source);
             }
             finally {
                 configInFlight = null;
@@ -301,7 +372,10 @@ export const QuotaToastPlugin = async ({ client }) => {
     }
     async function kickPricingRefresh(params) {
         try {
-            const refreshPromise = maybeRefreshPricingSnapshot({ reason: params.reason });
+            const refreshPromise = maybeRefreshPricingSnapshot({
+                reason: params.reason,
+                snapshotSelection: config.pricingSnapshot.source,
+            });
             const guardedRefreshPromise = refreshPromise.catch(() => undefined);
             if (!params.maxWaitMs || params.maxWaitMs <= 0) {
                 void guardedRefreshPromise;
@@ -340,6 +414,11 @@ export const QuotaToastPlugin = async ({ client }) => {
                         enabledProviders: config.enabledProviders,
                         minIntervalMs: config.minIntervalMs,
                         googleModels: config.googleModels,
+                        cursorPlan: config.cursorPlan,
+                        cursorIncludedApiUsd: config.cursorIncludedApiUsd,
+                        cursorBillingCycleStartDay: config.cursorBillingCycleStartDay,
+                        pricingSnapshotSource: config.pricingSnapshot.source,
+                        pricingSnapshotAutoRefresh: config.pricingSnapshot.autoRefresh,
                         showOnIdle: config.showOnIdle,
                         showOnQuestion: config.showOnQuestion,
                         showOnCompact: config.showOnCompact,
@@ -387,22 +466,38 @@ export const QuotaToastPlugin = async ({ client }) => {
         }
     }
     /**
-     * Get the current model from the active session.
+     * Get the current model metadata from the active session.
      *
      * Only uses session-scoped model lookup. Does NOT fall back to
      * client.config.get() because that returns the global/default model
      * which can be stale across sessions.
      */
-    async function getCurrentModel(sessionID) {
+    async function getSessionModelMeta(sessionID) {
         if (!sessionID)
-            return undefined;
+            return {};
         try {
             const sessionResp = await typedClient.session.get({ path: { id: sessionID } });
-            return sessionResp.data?.modelID;
+            return {
+                modelID: sessionResp.data?.modelID,
+                providerID: sessionResp.data?.providerID,
+            };
         }
         catch {
+            return {};
+        }
+    }
+    async function getCurrentModel(sessionID) {
+        if (!sessionID)
             return undefined;
+        return (await getSessionModelMeta(sessionID)).modelID;
+    }
+    function matchesProviderCurrentSelection(params) {
+        if (params.provider.id === "cursor" && isCursorProviderId(params.currentProviderID)) {
+            return true;
         }
+        if (!params.currentModel)
+            return false;
+        return params.provider.matchesCurrentModel ? params.provider.matchesCurrentModel(params.currentModel) : true;
     }
     function formatDebugInfo(params) {
         const availability = params.availability
@@ -423,6 +518,99 @@ export const QuotaToastPlugin = async ({ client }) => {
             `available=${availability}`,
         ].join("\n");
     }
+    async function resolveQuotaCommandSelection(params = {}) {
+        if (!configLoaded)
+            await refreshConfig();
+        if (!config.enabled)
+            return null;
+        const allProviders = getProviders();
+        const isAutoMode = config.enabledProviders === "auto";
+        const providers = isAutoMode
+            ? allProviders
+            : allProviders.filter((p) => config.enabledProviders.includes(p.id));
+        if (!isAutoMode && providers.length === 0)
+            return null;
+        let currentModel;
+        let currentProviderID;
+        if (config.onlyCurrentModel && params.sessionID) {
+            const currentSession = params.sessionMeta ?? (await getSessionModelMeta(params.sessionID));
+            currentModel = currentSession.modelID;
+            currentProviderID = currentSession.providerID;
+        }
+        const ctx = {
+            client: typedClient,
+            config: {
+                googleModels: config.googleModels,
+                alibabaCodingPlanTier: config.alibabaCodingPlanTier,
+                cursorPlan: config.cursorPlan,
+                cursorIncludedApiUsd: config.cursorIncludedApiUsd,
+                cursorBillingCycleStartDay: config.cursorBillingCycleStartDay,
+                // Always format /quota in grouped mode for a more dashboard-like look.
+                toastStyle: "grouped",
+                onlyCurrentModel: config.onlyCurrentModel,
+                currentModel,
+                currentProviderID,
+            },
+        };
+        const filteringByCurrentSelection = config.onlyCurrentModel && Boolean(currentModel || isCursorProviderId(currentProviderID));
+        const filtered = filteringByCurrentSelection
+            ? providers.filter((p) => matchesProviderCurrentSelection({ provider: p, currentModel, currentProviderID }))
+            : providers;
+        return {
+            isAutoMode,
+            providers,
+            filtered,
+            ctx,
+            currentModel,
+            currentProviderID,
+            filteringByCurrentSelection,
+        };
+    }
+    function describeQuotaCommandCurrentSelection(params) {
+        if (isCursorProviderId(params.currentProviderID)) {
+            return `current provider: ${params.currentProviderID}`;
+        }
+        if (params.currentModel) {
+            return `current model: ${params.currentModel}`;
+        }
+        return "current session";
+    }
+    async function buildQuotaCommandUnavailableMessage(params = {}) {
+        const selection = await resolveQuotaCommandSelection(params);
+        if (!selection) {
+            return "Quota unavailable\n\nNo enabled quota providers are configured.\n\nRun /quota_status for diagnostics.";
+        }
+        if (selection.filteringByCurrentSelection && selection.filtered.length === 0) {
+            const detail = describeQuotaCommandCurrentSelection({
+                currentModel: selection.currentModel,
+                currentProviderID: selection.currentProviderID,
+            });
+            return `Quota unavailable\n\nNo enabled quota providers matched the ${detail}.\n\nRun /quota_status for diagnostics.`;
+        }
+        const avail = await Promise.all(selection.filtered.map(async (p) => {
+            try {
+                return { id: p.id, ok: await p.isAvailable(selection.ctx) };
+            }
+            catch {
+                return { id: p.id, ok: false };
+            }
+        }));
+        const availableIds = avail.filter((x) => x.ok).map((x) => x.id);
+        if (availableIds.length === 0) {
+            const scopedDetail = selection.filteringByCurrentSelection
+                ? ` for the ${describeQuotaCommandCurrentSelection({
+                    currentModel: selection.currentModel,
+                    currentProviderID: selection.currentProviderID,
+                })}`
+                : "";
+            return (`Quota unavailable\n\nNo quota providers detected${scopedDetail}. ` +
+                "Make sure you are logged in to a supported provider (Copilot, OpenAI, etc.).\n\n" +
+                "Run /quota_status for diagnostics.");
+        }
+        return (`Quota unavailable\n\nProviders detected (${availableIds.join(", ")}) but returned no data. ` +
+            "This may be a temporary API error.\n\n" +
+            "Run /quota_status for diagnostics.");
+    }
     async function fetchQuotaMessage(trigger, sessionID) {
         // Ensure we have loaded config at least once. If load fails, we keep trying
         // on subsequent triggers.
@@ -449,21 +637,28 @@ export const QuotaToastPlugin = async ({ client }) => {
                 : null;
         }
         let currentModel;
+        let currentProviderID;
         if (config.onlyCurrentModel) {
-            currentModel = await getCurrentModel(sessionID);
+            const currentSession = await getSessionModelMeta(sessionID);
+            currentModel = currentSession.modelID;
+            currentProviderID = currentSession.providerID;
         }
         const ctx = {
             client: typedClient,
             config: {
                 googleModels: config.googleModels,
                 alibabaCodingPlanTier: config.alibabaCodingPlanTier,
+                cursorPlan: config.cursorPlan,
+                cursorIncludedApiUsd: config.cursorIncludedApiUsd,
+                cursorBillingCycleStartDay: config.cursorBillingCycleStartDay,
                 toastStyle: config.toastStyle,
                 onlyCurrentModel: config.onlyCurrentModel,
                 currentModel,
+                currentProviderID,
             },
         };
-        const filtered = config.onlyCurrentModel && currentModel
-            ? providers.filter((p) => p.matchesCurrentModel ? p.matchesCurrentModel(currentModel) : true)
+        const filtered = config.onlyCurrentModel && (currentModel || isCursorProviderId(currentProviderID))
+            ? providers.filter((p) => matchesProviderCurrentSelection({ provider: p, currentModel, currentProviderID }))
             : providers;
         // availability checks are cheap, do them in parallel
         const avail = await Promise.all(filtered.map(async (p) => ({ p, ok: await p.isAvailable(ctx) })));
@@ -479,11 +674,11 @@ export const QuotaToastPlugin = async ({ client }) => {
                 })
                 : null;
         }
-        const results = await Promise.all(active.map((p) => fetchProviderWithCache({
-            provider: p,
+        const results = await fetchProviderResults({
+            providers: active,
             ctx,
             ttlMs: config.minIntervalMs,
-        })));
+        });
         const entries = results.flatMap((r) => r.entries);
         const errors = results.flatMap((r) => r.errors);
         const attemptedAny = results.some((r) => r.attempted);
@@ -498,7 +693,7 @@ export const QuotaToastPlugin = async ({ client }) => {
                 if (!result.attempted && result.entries.length === 0 && result.errors.length === 0) {
                     errors.push({
                         label: getQuotaProviderDisplayLabel(provider.id),
-                        message: "Not configured",
+                        message: getExplicitNoDataMessage(provider),
                     });
                     hasExplicitProviderIssues = true;
                 }
@@ -609,7 +804,7 @@ export const QuotaToastPlugin = async ({ client }) => {
         }
         const bypassMessageCache = config.debug
             ? true
-            : await shouldBypassToastCacheForLocalRequestPlan(trigger, sessionID);
+            : await shouldBypassToastCacheForLiveLocalUsage({ trigger, sessionID });
         const message = bypassMessageCache
             ? await fetchQuotaMessage(trigger, sessionID)
             : await getOrFetchWithCacheControl(async () => {
@@ -642,50 +837,40 @@ export const QuotaToastPlugin = async ({ client }) => {
             });
         }
     }
-    async function fetchQuotaCommandBody(trigger, sessionID) {
-        if (!configLoaded)
-            await refreshConfig();
-        if (!config.enabled)
-            return null;
-        const allProviders = getProviders();
-        const isAutoMode = config.enabledProviders === "auto";
-        const providers = isAutoMode
-            ? allProviders
-            : allProviders.filter((p) => config.enabledProviders.includes(p.id));
-        if (!isAutoMode && providers.length === 0)
+    async function fetchQuotaCommandBody(trigger, params = {}) {
+        const selection = await resolveQuotaCommandSelection(params);
+        if (!selection)
             return null;
-        let currentModel;
-        if (config.onlyCurrentModel && sessionID) {
-            currentModel = await getCurrentModel(sessionID);
-        }
-        const ctx = {
-            client: typedClient,
-            config: {
-                googleModels: config.googleModels,
-                alibabaCodingPlanTier: config.alibabaCodingPlanTier,
-                // Always format /quota in grouped mode for a more dashboard-like look.
-                toastStyle: "grouped",
-                onlyCurrentModel: config.onlyCurrentModel,
-                currentModel,
-            },
-        };
-        const avail = await Promise.all(providers.map(async (p) => ({ p, ok: await p.isAvailable(ctx) })));
+        const { isAutoMode, ctx } = selection;
+        const avail = await Promise.all(selection.filtered.map(async (p) => ({ p, ok: await p.isAvailable(ctx) })));
         const active = avail.filter((x) => x.ok).map((x) => x.p);
         if (active.length === 0)
             return null;
-        const results = await Promise.all(active.map((p) => fetchProviderWithCache({
-            provider: p,
+        const results = await fetchProviderResults({
+            providers: active,
             ctx,
             ttlMs: config.minIntervalMs,
-        })));
+        });
         const entries = results.flatMap((r) => r.entries);
         const errors = results.flatMap((r) => r.errors);
+        if (!isAutoMode) {
+            for (let i = 0; i < active.length; i++) {
+                const provider = active[i];
+                const result = results[i];
+                if (!result.attempted && result.entries.length === 0 && result.errors.length === 0) {
+                    errors.push({
+                        label: getQuotaProviderDisplayLabel(provider.id),
+                        message: getExplicitNoDataMessage(provider),
+                    });
+                }
+            }
+        }
         // Fetch session tokens if enabled and sessionID is available
         let sessionTokens;
-        if (config.showSessionTokens && sessionID) {
+        if (config.showSessionTokens && params.sessionID) {
             const stResult = await fetchSessionTokensForDisplay({
                 enabled: config.showSessionTokens,
-                sessionID,
+                sessionID: params.sessionID,
             });
             sessionTokens = stResult.sessionTokens;
             // Update diagnostics state: clear on success (no error returned), set on failure
@@ -719,7 +904,9 @@ export const QuotaToastPlugin = async ({ client }) => {
         if (!config.enabled)
             return null;
         await kickPricingRefresh({ reason: "status", maxWaitMs: 750 });
-        const currentModel = await getCurrentModel(params.sessionID);
+        const currentSession = await getSessionModelMeta(params.sessionID);
+        const currentModel = currentSession.modelID;
+        const currentProviderID = currentSession.providerID;
         const sessionModelLookup = !params.sessionID
             ? "no_session"
             : currentModel
@@ -735,6 +922,11 @@ export const QuotaToastPlugin = async ({ client }) => {
                     config: {
                         googleModels: config.googleModels,
                         alibabaCodingPlanTier: config.alibabaCodingPlanTier,
+                        cursorPlan: config.cursorPlan,
+                        cursorIncludedApiUsd: config.cursorIncludedApiUsd,
+                        cursorBillingCycleStartDay: config.cursorBillingCycleStartDay,
+                        currentModel,
+                        currentProviderID,
                     },
                 });
             }
@@ -746,8 +938,8 @@ export const QuotaToastPlugin = async ({ client }) => {
                 // In auto mode, a provider is effectively "enabled" if it's available.
                 enabled: isAutoMode ? ok : config.enabledProviders.includes(p.id),
                 available: ok,
-                matchesCurrentModel: typeof p.matchesCurrentModel === "function" && currentModel
-                    ? p.matchesCurrentModel(currentModel)
+                matchesCurrentModel: currentModel || isCursorProviderId(currentProviderID)
+                    ? matchesProviderCurrentSelection({ provider: p, currentModel, currentProviderID })
                     : undefined,
             };
         }));
@@ -759,6 +951,10 @@ export const QuotaToastPlugin = async ({ client }) => {
             configPaths: configMeta.paths,
             enabledProviders: config.enabledProviders,
             alibabaCodingPlanTier: config.alibabaCodingPlanTier,
+            cursorPlan: config.cursorPlan,
+            cursorIncludedApiUsd: config.cursorIncludedApiUsd,
+            cursorBillingCycleStartDay: config.cursorBillingCycleStartDay,
+            pricingSnapshotSource: config.pricingSnapshot.source,
             onlyCurrentModel: config.onlyCurrentModel,
             currentModel,
             sessionModelLookup,
@@ -775,6 +971,42 @@ export const QuotaToastPlugin = async ({ client }) => {
             generatedAtMs: params.generatedAtMs,
         });
     }
+    function formatIsoTimestamp(timestampMs) {
+        return typeof timestampMs === "number" && Number.isFinite(timestampMs) && timestampMs > 0
+            ? new Date(timestampMs).toISOString()
+            : "(none)";
+    }
+    function buildPricingRefreshCommandOutput(params) {
+        const meta = getPricingSnapshotMeta();
+        const activeSource = getPricingSnapshotSource();
+        const configuredSelection = config.pricingSnapshot.source;
+        const resultLabel = params.result.reason ??
+            params.result.state.lastResult ??
+            (params.result.updated ? "success" : "unknown");
+        const lines = [
+            renderCommandHeading({
+                title: "Pricing Refresh (/pricing_refresh)",
+                generatedAtMs: params.generatedAtMs,
+            }),
+            "",
+            "refresh:",
+            `- attempted: ${params.result.attempted ? "true" : "false"}`,
+            `- result: ${resultLabel}`,
+            `- runtime_snapshot_persisted: ${params.result.updated ? "true" : "false"}`,
+        ];
+        if (params.result.error) {
+            lines.push(`- error: ${params.result.error}`);
+        }
+        lines.push("");
+        lines.push("pricing_snapshot:");
+        lines.push(`- selection: configured=${configuredSelection} active=${activeSource}`);
+        lines.push(`- active_snapshot: source=${meta.source} generated_at=${formatIsoTimestamp(meta.generatedAt)} units=${meta.units}`);
+        lines.push(`- runtime_paths: snapshot=${getRuntimePricingSnapshotPath()} refresh_state=${getRuntimePricingRefreshStatePath()}`);
+        if (configuredSelection === "bundled" && params.result.updated) {
+            lines.push("- selection_note: runtime snapshot refreshed locally, but active reports remain pinned to bundled pricing");
+        }
+        return lines.join("\n");
+    }
     // Return hook implementations
     return {
         // Register built-in slash commands (in addition to /tool quota_*)
@@ -790,6 +1022,10 @@ export const QuotaToastPlugin = async ({ client }) => {
                 template: "/quota_status",
                 description: "Diagnostics for toast + pricing + local storage (includes unknown pricing report).",
             };
+            cfg.command["pricing_refresh"] = {
+                template: "/pricing_refresh",
+                description: "Refresh the local runtime pricing snapshot from models.dev.",
+            };
             // Register token report commands (/tokens_*)
             for (const spec of TOKEN_REPORT_COMMANDS) {
                 cfg.command[spec.id] = {
@@ -802,7 +1038,10 @@ export const QuotaToastPlugin = async ({ client }) => {
             try {
                 const cmd = input.command;
                 const sessionID = input.sessionID;
-                const isQuotaCommand = cmd === "quota" || cmd === "quota_status" || isTokenReportCommand(cmd);
+                const isQuotaCommand = cmd === "quota" ||
+                    cmd === "quota_status" ||
+                    cmd === "pricing_refresh" ||
+                    isTokenReportCommand(cmd);
                 if (isQuotaCommand && !configLoaded) {
                     await refreshConfig();
                 }
@@ -811,30 +1050,45 @@ export const QuotaToastPlugin = async ({ client }) => {
                 }
                 if (cmd === "quota") {
                     const generatedAtMs = Date.now();
-                    // Separate cache for /quota so it doesn't pollute the toast cache.
-                    const quotaCache = getQuotaCommandCache();
                     const now = generatedAtMs;
-                    const bypassCommandCache = await shouldBypassQuotaCommandCache(sessionID);
-                    const cached = !bypassCommandCache &&
-                        quotaCache.timestamp &&
-                        now - quotaCache.timestamp < config.minIntervalMs
-                        ? quotaCache.body
-                        : null;
-                    const body = cached
-                        ? cached
-                        : await (quotaCache.inFlight ??
-                            (quotaCache.inFlight = (async () => {
-                                try {
-                                    return await fetchQuotaCommandBody("command:/quota", sessionID);
-                                }
-                                finally {
-                                    quotaCache.inFlight = undefined;
-                                }
-                            })()));
-                    if (body) {
-                        quotaCache.body = body;
-                        quotaCache.timestamp = Date.now();
-                    }
+                    const quotaRequestContext = {
+                        sessionID,
+                        sessionMeta: sessionID ? await getSessionModelMeta(sessionID) : undefined,
+                    };
+                    const bypassCommandCache = await shouldBypassQuotaCommandCache(sessionID, quotaRequestContext.sessionMeta);
+                    const body = bypassCommandCache
+                        ? await fetchQuotaCommandBody("command:/quota", quotaRequestContext)
+                        : await (async () => {
+                            const quotaCache = getQuotaCommandCache();
+                            pruneQuotaCommandCache(config.minIntervalMs, now);
+                            const cacheKey = buildQuotaCommandCacheKey(quotaRequestContext);
+                            const cachedEntry = quotaCache.get(cacheKey);
+                            if (cachedEntry?.timestamp &&
+                                now - cachedEntry.timestamp < config.minIntervalMs) {
+                                return cachedEntry.body;
+                            }
+                            const cacheEntry = cachedEntry ?? { body: "", timestamp: 0 };
+                            if (!cachedEntry) {
+                                quotaCache.set(cacheKey, cacheEntry);
+                            }
+                            return await (cacheEntry.inFlight ??
+                                (cacheEntry.inFlight = (async () => {
+                                    try {
+                                        const freshBody = await fetchQuotaCommandBody("command:/quota", quotaRequestContext);
+                                        if (freshBody) {
+                                            cacheEntry.body = freshBody;
+                                            cacheEntry.timestamp = Date.now();
+                                        }
+                                        return freshBody;
+                                    }
+                                    finally {
+                                        cacheEntry.inFlight = undefined;
+                                        if (!cacheEntry.body && cacheEntry.timestamp <= 0) {
+                                            quotaCache.delete(cacheKey);
+                                        }
+                                    }
+                                })()));
+                        })();
                     if (!body) {
                         // Provide an actionable message instead of a generic "unavailable".
                         if (!configLoaded) {
@@ -844,30 +1098,7 @@ export const QuotaToastPlugin = async ({ client }) => {
                             await injectRawOutput(sessionID, "Quota disabled in config (enabled: false)");
                         }
                         else {
-                            // Check what providers are available for a more specific hint.
-                            const allProvs = getProviders();
-                            const ctx = {
-                                client: typedClient,
-                                config: {
-                                    googleModels: config.googleModels,
-                                    alibabaCodingPlanTier: config.alibabaCodingPlanTier,
-                                },
-                            };
-                            const avail = await Promise.all(allProvs.map(async (p) => {
-                                try {
-                                    return { id: p.id, ok: await p.isAvailable(ctx) };
-                                }
-                                catch {
-                                    return { id: p.id, ok: false };
-                                }
-                            }));
-                            const availableIds = avail.filter((x) => x.ok).map((x) => x.id);
-                            if (availableIds.length === 0) {
-                                await injectRawOutput(sessionID, "Quota unavailable\n\nNo quota providers detected. Make sure you are logged in to a supported provider (Copilot, OpenAI, etc.).\n\nRun /quota_status for diagnostics.");
-                            }
-                            else {
-                                await injectRawOutput(sessionID, `Quota unavailable\n\nProviders detected (${availableIds.join(", ")}) but returned no data. This may be a temporary API error.\n\nRun /quota_status for diagnostics.`);
-                            }
+                            await injectRawOutput(sessionID, await buildQuotaCommandUnavailableMessage(quotaRequestContext));
                         }
                         handled();
                     }
@@ -878,6 +1109,24 @@ export const QuotaToastPlugin = async ({ client }) => {
                     await injectRawOutput(sessionID, `${heading}\n\n${body}`);
                     handled();
                 }
+                if (cmd === "pricing_refresh") {
+                    const generatedAtMs = Date.now();
+                    if ((input.arguments ?? "").trim()) {
+                        await injectRawOutput(sessionID, "Invalid arguments for /pricing_refresh\n\nThis command does not accept arguments.\n\nUsage:\n/pricing_refresh");
+                        handled();
+                    }
+                    const result = await maybeRefreshPricingSnapshot({
+                        reason: "manual",
+                        force: true,
+                        snapshotSelection: config.pricingSnapshot.source,
+                        allowRefreshWhenSelectionBundled: true,
+                    });
+                    await injectRawOutput(sessionID, buildPricingRefreshCommandOutput({
+                        result,
+                        generatedAtMs,
+                    }));
+                    handled();
+                }
                 const untilMs = Date.now();
                 // Handle token report commands (/tokens_*)
                 if (isTokenReportCommand(cmd)) {
@@ -1029,7 +1278,8 @@ export const QuotaToastPlugin = async ({ client }) => {
             if (!config.enabled)
                 return;
             if (isSuccessfulQuestionExecution(output)) {
-                const model = await getCurrentModel(input.sessionID);
+                const sessionMeta = await getSessionModelMeta(input.sessionID);
+                const model = sessionMeta.modelID;
                 try {
                     if (isQwenCodeModelId(model)) {
                         const plan = await resolveQwenLocalPlanCached();
@@ -1048,11 +1298,15 @@ export const QuotaToastPlugin = async ({ client }) => {
                             clearQuotaCommandCache();
                         }
                     }
+                    else if (isCursorProviderId(sessionMeta.providerID) || isCursorModelId(model)) {
+                        clearQuotaCommandCache();
+                    }
                 }
                 catch (err) {
                     await log("Failed to record local request-plan quota completion", {
                         error: err instanceof Error ? err.message : String(err),
                         model,
+                        providerID: sessionMeta.providerID,
                     });
                 }
             }