@slkiser/opencode-quota 5.0.3 → 6.0.0-beta.1

package/dist/lib/quota-dialog-commands.js

@@ -1,223 +1,241 @@
-import { formatYmd, parseQuotaBetweenArgs, startOfLocalDayMs, startOfNextLocalDayMs, } from "./command-parsing.js";
+/**
+ * The /quota_status report of the slash command, the `quota_status` tool and
+ * `opencode-quota status`, and the quota lines of `opencode-quota show`. Each reads the server
+ * settings the host holds now.
+ */
+import { loadProviderSource, providerContext, } from "../core/provider-source.js";
+import { matchesQuotaProviderCurrentSelection } from "../core/selection.js";
+import { createQuotaStore } from "../core/store.js";
+import { usageReport } from "../core/usage.js";
+import { getProviders } from "../providers/registry.js";
+import { apiKeyStatusDetails, simpleApiKeyStatusDetails } from "../providers/result-helpers.js";
+import { PROVIDER_IDS } from "../settings/schema.js";
+import { DEFAULT_WORDS } from "../view/format.js";
+import { visibleGroups } from "../view/select.js";
+import { plainLines } from "../view/text.js";
+import { API_KEY_LOGIN_VENDORS, API_KEY_VENDORS, getApiKeyDiagnostics, getApiKeyLoginDiagnostics, } from "./api-key-resolver.js";
+import { inspectCursorAuthPresence } from "./cursor-detection.js";
 import { isCursorProviderId } from "./cursor-pricing.js";
-import { BUNDLED_MAINTAINER_ANNOUNCEMENTS, getMaintainerAnnouncementsSummary, } from "./maintainer-announcements.js";
-import { getPricingSnapshotMeta, getPricingSnapshotSource, getRuntimePricingRefreshStatePath, getRuntimePricingSnapshotPath, maybeRefreshPricingSnapshot, setPricingSnapshotAutoRefresh, setPricingSnapshotSelection, } from "./modelsdev-pricing.js";
-import { buildQuotaCommandDocument } from "./quota-command-format.js";
-import { QUOTA_DIALOG_COMMANDS_BY_ID, TOKEN_REPORT_COMMANDS, } from "./quota-dialog-command-specs.js";
-import { ALL_WINDOWS_FORMAT_STYLE } from "./quota-format-style.js";
-import { collectConcreteEnabledProviderIds, collectQuotaRenderData, collectQuotaStatusLiveProbes, matchesQuotaProviderCurrentSelection, } from "./quota-render-data.js";
-import { createQuotaProviderRuntimeContext, createQuotaRuntimeRequestContext, resolveQuotaRuntimeContext, } from "./quota-runtime-context.js";
-import { aggregateUsage, resolveSessionTree, SessionNotFoundError, } from "./quota-stats.js";
-import { buildQuotaStatsReportDocument } from "./quota-stats-format.js";
-import { buildQuotaStatusReportDocument } from "./quota-status.js";
-import { commandHeading, messageDocument, renderMarkdownReport, renderPlainTextReport, } from "./report-document.js";
-import { getPackageVersion } from "./version.js";
-// Token report model names are capped at the length of this reference model.
-const TUI_TOKEN_REPORT_MODEL_NAME_WIDTH_REFERENCE = "gemini-3-pro-preview";
-const TUI_TOKEN_REPORT_MODEL_MAX_WIDTH = TUI_TOKEN_REPORT_MODEL_NAME_WIDTH_REFERENCE.length;
-const TOKEN_REPORT_COMMANDS_BY_ID = (() => {
-    const map = new Map();
-    for (const spec of TOKEN_REPORT_COMMANDS) {
-        map.set(spec.id, spec);
+import { sanitizeDisplayText } from "./display-sanitize.js";
+import { getMaintainerAnnouncementsSummary } from "./maintainer-announcements.js";
+import { getPricingSnapshotSource, getRuntimePricingRefreshStatePath, getRuntimePricingSnapshotPath, maybeRefreshPricingSnapshot, setPricingSnapshotAutoRefresh, setPricingSnapshotSelection, } from "./modelsdev-pricing.js";
+import { getCredentialSourceDiagnostics } from "./opencode-auth.js";
+import { resolveOpenRouterApiKey } from "./openrouter.js";
+import { getQuotaProviderDisplayLabel, getQuotaProviderRuntimeIds } from "./provider-metadata.js";
+import { buildQuotaStatusReportDocument, knownProviderIds, publicPricingMeta, statusPathText, } from "./quota-status.js";
+import { renderPlainTextReport } from "./report-document.js";
+/** `opencode-quota show` lists every row of every provider. */
+const EVERY_ROW = { enabled: true, hidden: [], providerOrder: [], rowOrder: {} };
+const EVERY_ROW_SETTINGS = {
+    labels: {},
+    window: {},
+    surfaces: { sidebar: EVERY_ROW, collapsed: EVERY_ROW, statusLine: EVERY_ROW, toast: EVERY_ROW },
+};
+/**
+ * The quota lines `opencode-quota show` prints, in the snapshot's words: a line per row (with
+ * "runs out in …" when the quota runs out before its reset), a line per provider problem, then the session's
+ * tokens when the snapshot has them.
+ */
+export function quotaReportLines(snapshot, nowMs) {
+    const words = snapshot.words ?? DEFAULT_WORDS;
+    const groups = visibleGroups(snapshot, EVERY_ROW_SETTINGS, "toast", words);
+    const sessionTokens = snapshot.sessionTokens ? { sessionTokens: snapshot.sessionTokens } : {};
+    return plainLines({ groups, words, nowMs, runsOut: true, ...sessionTokens }).map(sanitizeDisplayText);
+}
+/**
+ * Uses the pricing settings from now on: the price list (`source`) and how many days old it
+ * may get before a refresh. Applied before any provider check, as local estimates use prices.
+ */
+export function applyPricingSettings(pricing) {
+    setPricingSnapshotAutoRefresh(pricing.autoRefreshDays);
+    setPricingSnapshotSelection(pricing.source);
+}
+/** Starts a models.dev price refresh when due and waits for it at most 0.75 s. */
+export async function kickPricingRefresh(params) {
+    try {
+        const refresh = maybeRefreshPricingSnapshot(params).catch(() => undefined);
+        await Promise.race([refresh, new Promise((resolve) => setTimeout(resolve, 750))]);
+    }
+    catch {
+        // A refresh that fails to start keeps the current price list.
     }
-    return map;
-})();
-function isTokenReportCommand(cmd) {
-    return TOKEN_REPORT_COMMANDS_BY_ID.has(cmd);
 }
-function plainTextReport(document) {
-    return { document, output: renderPlainTextReport(document) };
+/**
+ * A fresh check of every enabled and available provider (or only `providerId`), through a
+ * store of its own that keeps nothing: the same providers, rows, errors and debug details the
+ * plugin's store would hold.
+ */
+export async function checkProviders(host, providerId) {
+    const store = createQuotaStore({ source: () => loadProviderSource(host), file: null });
+    try {
+        const providerIds = providerId ? [providerId] : undefined;
+        const snapshot = await store.refresh({ reason: "manual", providerIds });
+        const providers = snapshot.providers.filter((provider) => !providerId || provider.providerId === providerId);
+        return { ...snapshot, providers };
+    }
+    finally {
+        await store.dispose();
+    }
 }
-function describeQuotaCommandCurrentSelection(params) {
-    if (isCursorProviderId(params.currentProviderID)) {
-        return `current provider: ${params.currentProviderID}`;
+async function isAvailable(provider, ctx) {
+    try {
+        return await provider.isAvailable(ctx);
     }
-    if (params.currentModel) {
-        return `current model: ${params.currentModel}`;
+    catch {
+        return false;
     }
-    return "current session";
 }
-function buildQuotaCommandUnavailableMessage(result) {
-    const selection = result.selection;
-    if (!selection) {
-        return "Quota unavailable\n\nNo enabled quota providers are configured.\n\nRun /quota_status for diagnostics.";
+/**
+ * Where an API-key provider (and Cursor) looked for its key, from local reads only, with the
+ * same details its own check writes: whether a key is set, its source, and the files checked.
+ * Nothing for a provider without an API key.
+ */
+async function apiKeySetupDetails(providerId) {
+    if (Object.hasOwn(API_KEY_VENDORS, providerId)) {
+        const vendor = API_KEY_VENDORS[providerId];
+        return simpleApiKeyStatusDetails(await getApiKeyDiagnostics(vendor));
+    }
+    if (Object.hasOwn(API_KEY_LOGIN_VENDORS, providerId)) {
+        const vendor = API_KEY_LOGIN_VENDORS[providerId];
+        return apiKeyStatusDetails(await getApiKeyLoginDiagnostics(vendor));
     }
-    if (selection.filteringByCurrentSelection && selection.filtered.length === 0) {
-        const detail = describeQuotaCommandCurrentSelection({
-            currentModel: selection.currentModel,
-            currentProviderID: selection.currentProviderID,
+    if (providerId === "openrouter") {
+        const resolved = await resolveOpenRouterApiKey();
+        return simpleApiKeyStatusDetails({
+            configured: Boolean(resolved.key),
+            source: resolved.source,
+            checkedPaths: resolved.checkedPaths,
+            credentialDatabasePaths: resolved.credentialDatabasePaths,
         });
-        return `Quota unavailable\n\nNo enabled quota providers matched the ${detail}.\n\nRun /quota_status for diagnostics.`;
     }
-    const availableIds = result.availability
-        .filter((item) => item.ok)
-        .map((item) => item.provider.id);
-    if (availableIds.length === 0) {
-        const scopedDetail = selection.filteringByCurrentSelection
-            ? ` for the ${describeQuotaCommandCurrentSelection({
-                currentModel: selection.currentModel,
-                currentProviderID: selection.currentProviderID,
-            })}`
-            : "";
-        return (`Quota unavailable\n\nNo provider data available${scopedDetail}. ` +
-            "Make sure you are logged in to a supported provider (Copilot, OpenAI, etc.).\n\n" +
-            "Run /quota_status for diagnostics.");
+    if (providerId === "cursor") {
+        const auth = await inspectCursorAuthPresence();
+        return [
+            { key: "auth_state", value: auth.state },
+            { key: "auth_selected_path", value: auth.selectedPath ?? "(none)" },
+            { key: "auth_present_paths", value: auth.presentPaths.join(" | ") || "(none)" },
+            { key: "auth_candidate_paths", value: auth.candidatePaths.join(" | ") || "(none)" },
+        ];
     }
-    return (`Quota unavailable\n\nNo provider data available for detected providers (${availableIds.join(", ")}). ` +
-        "This may be a temporary API error.\n\n" +
-        "Run /quota_status for diagnostics.");
+    return [];
 }
-async function fetchQuotaCommandData(params) {
-    const { runtime } = params;
-    const request = createQuotaRuntimeRequestContext(runtime);
-    const quotaResult = await collectQuotaRenderData({
-        client: runtime.client,
-        resolveRuntimeProviderIds: runtime.resolveRuntimeProviderIds,
-        config: runtime.config,
-        configMeta: runtime.configMeta,
-        request,
-        workspaceRoot: runtime.roots.workspaceRoot,
-        surfaceExplicitProviderIssues: false,
-        formatStyle: ALL_WINDOWS_FORMAT_STYLE,
-        providers: runtime.providers,
-    });
-    if (runtime.config.showSessionTokens && request.sessionID) {
-        params.setLastSessionTokenError?.(quotaResult.sessionTokenError);
+/**
+ * What an unavailable provider's setup looks like, from local checks only: whether OpenCode
+ * lists the provider and, for an API-key provider, where its key was looked for. No quota
+ * request is made.
+ */
+async function localSetupDetails(providerId, ctx) {
+    const details = [];
+    const runtimeIds = getQuotaProviderRuntimeIds(providerId);
+    if (runtimeIds.length > 0) {
+        let listed;
+        try {
+            const openCodeIds = await ctx.resolveRuntimeProviderIds();
+            const found = runtimeIds.filter((id) => openCodeIds.has(id));
+            listed =
+                found.length > 0 ? `yes found=${found.join(",")}` : `no looked_for=${runtimeIds.join(",")}`;
+        }
+        catch {
+            listed = "unreadable";
+        }
+        details.push({ key: "opencode_provider", value: listed });
     }
-    return quotaResult;
-}
-async function kickPricingRefresh(params) {
     try {
-        const refreshPromise = maybeRefreshPricingSnapshot({
-            reason: params.reason,
-            snapshotSelection: params.snapshotSelection,
-        });
-        const guardedRefreshPromise = refreshPromise.catch(() => undefined);
-        if (!params.maxWaitMs || params.maxWaitMs <= 0) {
-            void guardedRefreshPromise;
-            return;
-        }
-        await Promise.race([
-            guardedRefreshPromise,
-            new Promise((resolve) => {
-                setTimeout(resolve, params.maxWaitMs);
-            }),
-        ]);
+        details.push(...(await apiKeySetupDetails(providerId)));
     }
-    catch (error) {
-        await params.log?.("Pricing refresh failed", {
-            reason: params.reason,
-            error: error instanceof Error ? error.message : String(error),
-        });
+    catch {
+        details.push({ key: "api_key_configured", value: "unreadable" });
     }
+    return details;
 }
-async function buildQuotaReport(params) {
-    const result = await aggregateUsage({
-        sinceMs: params.sinceMs,
-        untilMs: params.untilMs,
-        sessionID: params.filterSessionID,
-        sessionIDs: params.filterSessionIDs,
-    });
-    const document = buildQuotaStatsReportDocument({
-        title: params.title,
-        titleDetail: params.titleDetail,
-        result,
-        topModels: params.topModels,
-        topSessions: params.topSessions,
-        focusSessionID: params.sessionID,
-        sessionOnly: params.sessionOnly,
-        reportKind: params.reportKind,
-        sessionTree: params.sessionTree,
-        generatedAtMs: params.generatedAtMs,
-        tableOptions: {
-            compactHeaders: true,
-            modelNameMaxWidth: TUI_TOKEN_REPORT_MODEL_MAX_WIDTH,
-        },
-    });
-    return { document, output: renderMarkdownReport(document) };
-}
-export function summarizeQuotaStatusLiveProbes(probes) {
-    return probes.map((probe) => ({
-        id: probe.providerId,
-        ok: probe.result.attempted && probe.result.errors.length === 0,
+/**
+ * A fresh check of every known provider (or only `providerId`) for /quota_status. The plugin's
+ * source decides which providers are enabled and available; those are checked through a store
+ * of its own that keeps nothing, as the plugin's store would check them. An unavailable
+ * provider shows its local setup details instead, and one turned off in the settings is never
+ * fetched.
+ */
+async function checkKnownProviders(host, providerId) {
+    const source = await loadProviderSource(host);
+    const sourceIds = new Set(source.providers.map((provider) => provider.id));
+    const ctx = providerContext(host);
+    const { enabledProviders } = ctx.config;
+    const turnedOn = (id) => enabledProviders === "auto" || enabledProviders.includes(id);
+    const known = getProviders().filter((provider) => !providerId || provider.id === providerId);
+    const checks = await Promise.all(known.map(async (provider) => {
+        if (sourceIds.has(provider.id))
+            return { provider, enabled: true, available: true };
+        if (turnedOn(provider.id))
+            return { provider, enabled: true, available: false };
+        return { provider, enabled: false, available: await isAvailable(provider, ctx) };
     }));
+    const setupSnapshots = checks
+        .filter((check) => !check.available && turnedOn(check.provider.id))
+        .map(async ({ provider }) => ({
+        providerId: provider.id,
+        label: getQuotaProviderDisplayLabel(provider.id),
+        rows: [],
+        refreshing: false,
+        debug: await localSetupDetails(provider.id, ctx),
+    }));
+    const store = createQuotaStore({ source: async () => source, file: null });
+    try {
+        const knownIds = new Set(known.map((provider) => provider.id));
+        const snapshot = await store.refresh({ reason: "manual", providerIds: [...knownIds] });
+        const checked = snapshot.providers.filter((provider) => knownIds.has(provider.providerId));
+        return { checks, snapshots: [...checked, ...(await Promise.all(setupSnapshots))] };
+    }
+    finally {
+        await store.dispose();
+    }
 }
-export async function buildStatusReportData(params) {
-    const runtimeConfig = params.runtime.config;
-    if (!runtimeConfig.enabled) {
-        return { document: null, output: null, payload: null, hasComparableProviderData: false };
+/** The last 30 days of usage, for the models without a price; null when it can't be read. */
+async function readRecentUsage(nowMs) {
+    try {
+        return await usageReport({ range: "30d" }, nowMs);
     }
+    catch {
+        return null;
+    }
+}
+export async function buildStatusReportData(params) {
+    const { host } = params;
+    const loaded = host.settings();
+    const { settings } = loaded;
     await kickPricingRefresh({
         reason: "status",
-        maxWaitMs: 750,
-        snapshotSelection: runtimeConfig.pricingSnapshot.source,
-        log: params.log,
+        snapshotSelection: settings.providers.pricing.source,
     });
-    const currentSession = params.runtime.session.sessionMeta ?? {};
-    const currentModel = currentSession.modelID;
-    const currentProviderID = currentSession.providerID;
+    const currentModel = params.sessionModel?.id;
+    const currentProviderID = params.sessionModel?.providerID;
     const sessionModelLookup = !params.sessionID
         ? "no_session"
         : currentModel
             ? "ok"
             : "not_found";
-    const isAutoMode = runtimeConfig.enabledProviders === "auto";
-    const providers = params.providerFilterId
-        ? params.runtime.providers.filter((provider) => provider.id === params.providerFilterId)
-        : params.runtime.providers;
-    const providerContext = createQuotaProviderRuntimeContext({
-        ...params.runtime,
-        workspaceRoot: params.runtime.roots.workspaceRoot,
-    });
-    const availability = await Promise.all(providers.map(async (p) => {
-        let ok = false;
-        try {
-            ok = await p.isAvailable(providerContext);
-        }
-        catch {
-            ok = false;
-        }
-        return {
-            id: p.id,
-            enabled: isAutoMode ? ok : runtimeConfig.enabledProviders.includes(p.id),
-            available: ok,
-            matchesCurrentModel: currentModel || isCursorProviderId(currentProviderID)
-                ? matchesQuotaProviderCurrentSelection({
-                    provider: p,
-                    currentModel,
-                    currentProviderID,
-                    enabledProviders: runtimeConfig.enabledProviders,
-                    quotaProviders: runtimeConfig.quotaProviders,
-                })
-                : undefined,
-        };
+    const { enabledProviders, automaticDiscovery, quotaProviders } = providerContext(host, loaded).config;
+    const [{ checks, snapshots }, usage] = await Promise.all([
+        checkKnownProviders(host, params.providerFilterId),
+        readRecentUsage(params.generatedAtMs),
+    ]);
+    const availability = checks.map(({ provider, enabled, available }) => ({
+        id: provider.id,
+        enabled,
+        available,
+        matchesCurrentModel: currentModel || isCursorProviderId(currentProviderID)
+            ? matchesQuotaProviderCurrentSelection({
+                provider,
+                currentModel,
+                currentProviderID,
+                enabledProviders,
+                automaticDiscovery,
+                quotaProviders,
+            })
+            : undefined,
     }));
-    if (isAutoMode) {
-        await params.onDetectedProviderIds?.(availability.filter((item) => item.available).map((item) => item.id));
-    }
-    // Status diagnostics belong to provider results, including missing or disabled
-    // providers. Provider fetch implementations must keep unconfigured cases local.
-    const liveProbeProviders = providers;
-    let providerLiveProbes = [];
-    if (liveProbeProviders.length > 0) {
-        try {
-            providerLiveProbes = await collectQuotaStatusLiveProbes({
-                client: params.runtime.client,
-                resolveRuntimeProviderIds: params.runtime.resolveRuntimeProviderIds,
-                config: runtimeConfig,
-                configMeta: params.runtime.configMeta,
-                request: createQuotaRuntimeRequestContext(params.runtime),
-                workspaceRoot: params.runtime.roots.workspaceRoot,
-                providers: liveProbeProviders,
-            });
-        }
-        catch (error) {
-            await params.log?.("Failed to collect /quota_status live probes", {
-                providers: liveProbeProviders.map((provider) => provider.id),
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
+    await params.onDetectedProviderIds?.(availability.filter((item) => item.enabled && item.available).map((item) => item.id));
+    const checkedIds = new Set(availability.filter((item) => item.enabled && item.available).map((item) => item.id));
+    const checked = snapshots.filter((provider) => checkedIds.has(provider.providerId));
     const announcementProviderIds = availability
         .filter((item) => item.enabled && item.available)
         .map((item) => item.id);
@@ -225,362 +243,84 @@ export async function buildStatusReportData(params) {
         enabledProviders: announcementProviderIds,
     });
     const document = await buildQuotaStatusReportDocument({
-        runtimeRoots: params.runtime.roots,
-        configSource: params.runtime.configMeta.source,
-        configPaths: params.runtime.configMeta.paths,
-        globalConfigPaths: params.runtime.configMeta.globalConfigPaths,
-        workspaceConfigPaths: params.runtime.configMeta.workspaceConfigPaths,
-        settingSources: params.runtime.configMeta.settingSources,
-        configIssues: params.runtime.configMeta.configIssues,
-        enabledProviders: runtimeConfig.enabledProviders,
-        anthropicBinaryPath: runtimeConfig.anthropicBinaryPath,
-        cursorPlan: runtimeConfig.cursorPlan,
-        cursorIncludedApiUsd: runtimeConfig.cursorIncludedApiUsd,
-        cursorBillingCycleStartDay: runtimeConfig.cursorBillingCycleStartDay,
-        opencodeGoWindows: runtimeConfig.opencodeGoWindows,
-        pricingSnapshotSource: runtimeConfig.pricingSnapshot.source,
-        onlyCurrentModel: runtimeConfig.onlyCurrentModel,
+        origin: params.origin,
+        opencode: params.opencode,
+        settings: loaded,
+        conversion: loaded.conversion ?? params.conversion,
+        workspaceRoot: host.workspaceRoot,
+        enabledProviders: settings.providers.off.length === 0
+            ? "auto"
+            : PROVIDER_IDS.filter((id) => !settings.providers.off.includes(id)),
+        offProviders: settings.providers.off,
+        quotaProviders: settings.providers.custom,
+        pricingSnapshotSource: settings.providers.pricing.source,
         currentModel,
+        currentProviderID,
         sessionModelLookup,
         providerAvailability: availability,
-        providerLiveProbes,
-        quotaProviders: runtimeConfig.quotaProviders,
-        sessionTokenError: params.lastSessionTokenError,
+        providers: snapshots,
+        credentialSource: getCredentialSourceDiagnostics(),
         maintainerAnnouncements: {
-            config: runtimeConfig.maintainerAnnouncements,
             summary: maintainerAnnouncementsSummary,
         },
+        usage,
         generatedAtMs: params.generatedAtMs,
     });
-    const version = (await getPackageVersion()) ?? "unknown";
-    const pricingMeta = getPricingSnapshotMeta();
-    const activePricingSource = getPricingSnapshotSource();
+    // The payload follows the report's closed vocabulary: known ids, fixed words, known paths.
+    const pricingMeta = publicPricingMeta();
     const payload = {
-        version,
+        version: "6",
         generatedAt: new Date(params.generatedAtMs).toISOString(),
         config: {
-            configSource: params.runtime.configMeta.source,
-            configPaths: params.runtime.configMeta.paths,
-            globalConfigPaths: params.runtime.configMeta.globalConfigPaths,
-            workspaceConfigPaths: params.runtime.configMeta.workspaceConfigPaths,
-            enabledProviders: runtimeConfig.enabledProviders,
-            onlyCurrentModel: runtimeConfig.onlyCurrentModel,
-            pricingSnapshotSource: runtimeConfig.pricingSnapshot.source,
+            settingsPath: statusPathText(loaded.path),
+            settingsFileExists: loaded.exists,
+            enabledProviders: knownProviderIds(settings.providers.off.length === 0
+                ? "auto"
+                : PROVIDER_IDS.filter((id) => !settings.providers.off.includes(id))),
+            onlyCurrentModel: settings.words.onlyCurrentModel,
+            pricingSnapshotSource: settings.providers.pricing.source,
         },
         providers: availability,
         pricing: {
-            selection: runtimeConfig.pricingSnapshot.source,
-            activeSource: activePricingSource,
+            selection: settings.providers.pricing.source,
+            activeSource: getPricingSnapshotSource(),
             snapshot: {
                 source: pricingMeta.source,
-                generatedAt: pricingMeta.generatedAt > 0 ? new Date(pricingMeta.generatedAt).toISOString() : null,
+                // "(none)" and "(invalid date)" are no time.
+                generatedAt: /^\d/u.test(pricingMeta.generatedAt) ? pricingMeta.generatedAt : null,
                 units: pricingMeta.units,
             },
-            snapshotPath: getRuntimePricingSnapshotPath(),
-            refreshStatePath: getRuntimePricingRefreshStatePath(),
+            snapshotPath: statusPathText(getRuntimePricingSnapshotPath()),
+            refreshStatePath: statusPathText(getRuntimePricingRefreshStatePath()),
         },
-        liveProbes: summarizeQuotaStatusLiveProbes(providerLiveProbes),
+        liveProbes: checked.map((provider) => ({
+            id: provider.providerId,
+            ok: provider.error === undefined,
+        })),
     };
     return {
-        document,
         output: renderPlainTextReport(document),
         payload,
-        hasComparableProviderData: providerLiveProbes.some((probe) => probe.result.entries.length > 0),
+        hasComparableProviderData: checked.some((provider) => provider.rows.length > 0),
     };
 }
-function formatIsoTimestamp(timestampMs) {
-    return typeof timestampMs === "number" && Number.isFinite(timestampMs) && timestampMs > 0
-        ? new Date(timestampMs).toISOString()
-        : "(none)";
-}
-function buildPricingRefreshCommandReport(params) {
-    const meta = getPricingSnapshotMeta();
-    const activeSource = getPricingSnapshotSource();
-    const resultLabel = params.result.reason ??
-        params.result.state.lastResult ??
-        (params.result.updated ? "success" : "unknown");
-    const refreshRows = [
-        { key: "attempted", value: params.result.attempted ? "true" : "false" },
-        { key: "result", value: resultLabel },
-        { key: "runtime_snapshot_persisted", value: params.result.updated ? "true" : "false" },
-    ];
-    if (params.result.error) {
-        refreshRows.push({ key: "error", value: params.result.error });
-    }
-    const snapshotRows = [
-        { key: "selection", value: `configured=${params.configuredSelection} active=${activeSource}` },
-        {
-            key: "active_snapshot",
-            value: `source=${meta.source} generated_at=${formatIsoTimestamp(meta.generatedAt)} units=${meta.units}`,
-        },
-        {
-            key: "runtime_paths",
-            value: `snapshot=${getRuntimePricingSnapshotPath()} refresh_state=${getRuntimePricingRefreshStatePath()}`,
-        },
-    ];
-    if (params.configuredSelection === "bundled" && params.result.updated) {
-        snapshotRows.push({
-            key: "selection_note",
-            value: "runtime snapshot refreshed locally, but active reports remain pinned to bundled pricing",
-        });
-    }
-    return plainTextReport({
-        heading: commandHeading({
-            title: "Pricing Refresh (/pricing_refresh)",
-            generatedAtMs: params.generatedAtMs,
-        }),
-        sections: [
-            { id: "refresh", title: "refresh:", blocks: [{ kind: "kv", rows: refreshRows }] },
-            {
-                id: "pricing_snapshot",
-                title: "pricing_snapshot:",
-                blocks: [{ kind: "kv", rows: snapshotRows }],
-            },
-        ],
-    });
-}
-function buildTokenReportUnavailableReport(params) {
-    return plainTextReport({
-        heading: commandHeading({
-            title: `Token report unavailable (${params.command})`,
-            detail: "Token report unavailable",
-            generatedAtMs: params.generatedAtMs,
-        }),
-        sections: [
-            {
-                id: "session_lookup_error",
-                title: "session_lookup_error:",
-                blocks: [
-                    {
-                        kind: "kv",
-                        rows: [
-                            { key: "session_id", value: params.error.sessionID },
-                            { key: "error", value: params.error.message },
-                            { key: "checked_path", value: params.error.checkedPath },
-                        ],
-                    },
-                ],
-            },
-        ],
-    });
-}
-async function buildQuotaAnnouncementsCommandReport(runtime) {
-    let activeAnnouncements = [];
-    if (runtime.config.enabled && runtime.config.maintainerAnnouncements.enabled) {
-        const providerIds = await collectConcreteEnabledProviderIds({
-            providers: runtime.providers,
-            ctx: createQuotaProviderRuntimeContext({
-                ...runtime,
-                workspaceRoot: runtime.roots.workspaceRoot,
-            }),
-            enabledProviders: runtime.config.enabledProviders,
-        });
-        const summary = getMaintainerAnnouncementsSummary({
-            announcements: BUNDLED_MAINTAINER_ANNOUNCEMENTS,
-            enabledProviders: providerIds,
-        });
-        activeAnnouncements = summary.activeAnnouncements;
-    }
-    const lines = [];
-    if (activeAnnouncements.length === 0) {
-        lines.push("No current announcements.");
-    }
-    for (const evaluation of activeAnnouncements) {
-        lines.push(`- ${evaluation.announcement.message}`);
-        if (evaluation.announcement.url) {
-            lines.push(`  ${evaluation.announcement.url}`);
-        }
-    }
-    return plainTextReport({
-        heading: { line: "Maintainer announcements" },
-        sections: [{ id: "announcements", blocks: [{ kind: "lines", lines }] }],
-    });
-}
-function outputResult(command, report) {
-    const spec = QUOTA_DIALOG_COMMANDS_BY_ID.get(command);
-    return {
-        state: "output",
-        command,
-        title: spec.title,
-        output: report.output,
-        document: report.document,
-        dialogSize: spec.dialogSize,
-    };
-}
-async function buildTokenReportCommandReport(params) {
-    const spec = TOKEN_REPORT_COMMANDS_BY_ID.get(params.command);
-    const sessionID = params.sessionID;
-    const untilMs = params.generatedAtMs;
-    await kickPricingRefresh({
-        reason: "tokens",
-        maxWaitMs: 750,
-        snapshotSelection: params.runtime.config.pricingSnapshot.source,
-        log: params.log,
-    });
-    if (!sessionID && (spec.kind === "session" || spec.kind === "session_tree")) {
-        return buildTokenReportUnavailableReport({
-            command: spec.template,
-            generatedAtMs: params.generatedAtMs,
-            error: new SessionNotFoundError("(none)", "(none)"),
-        });
-    }
-    try {
-        if (spec.kind === "between") {
-            const parsed = parseQuotaBetweenArgs(params.arguments);
-            if (!parsed.ok) {
-                return plainTextReport(messageDocument(`Invalid arguments for /${spec.id}\n\n${parsed.error}\n\nExpected: /${spec.id} YYYY-MM-DD YYYY-MM-DD\nExample: /${spec.id} 2026-01-01 2026-01-15`));
-            }
-            const sinceMs = startOfLocalDayMs(parsed.startYmd);
-            const rangeUntilMs = startOfNextLocalDayMs(parsed.endYmd);
-            return await buildQuotaReport({
-                title: spec.titleForRange(parsed.startYmd, parsed.endYmd),
-                titleDetail: `${formatYmd(parsed.startYmd)} .. ${formatYmd(parsed.endYmd)}`,
-                sinceMs,
-                untilMs: rangeUntilMs,
-                sessionID: sessionID ?? "",
-                generatedAtMs: params.generatedAtMs,
-            });
-        }
-        let sinceMs;
-        let filterSessionID;
-        let filterSessionIDs;
-        let sessionOnly;
-        let topModels;
-        let topSessions;
-        let reportKind;
-        let sessionTree;
-        switch (spec.kind) {
-            case "rolling":
-                sinceMs = untilMs - spec.windowMs;
-                break;
-            case "today": {
-                const now = new Date(untilMs);
-                const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate());
-                sinceMs = startOfDay.getTime();
-                break;
-            }
-            case "session":
-                filterSessionID = sessionID;
-                sessionOnly = true;
-                reportKind = "session";
-                break;
-            case "session_tree": {
-                const nodes = await resolveSessionTree(sessionID);
-                filterSessionIDs = nodes.map((node) => node.sessionID);
-                reportKind = "session_tree";
-                sessionTree = { rootSessionID: sessionID, nodes };
-                break;
-            }
-            case "all":
-                topModels = spec.topModels;
-                topSessions = spec.topSessions;
-                break;
-        }
-        return await buildQuotaReport({
-            title: spec.title,
-            sinceMs,
-            untilMs: spec.kind === "rolling" || spec.kind === "today" ? untilMs : undefined,
-            sessionID: sessionID ?? "",
-            filterSessionID,
-            filterSessionIDs,
-            sessionOnly,
-            reportKind,
-            sessionTree,
-            topModels,
-            topSessions,
-            generatedAtMs: params.generatedAtMs,
-        });
-    }
-    catch (err) {
-        if (err instanceof SessionNotFoundError) {
-            return buildTokenReportUnavailableReport({
-                command: spec.template,
-                generatedAtMs: params.generatedAtMs,
-                error: err,
-            });
-        }
-        throw err;
-    }
-}
+/** The /quota_status report as text. */
 export async function buildQuotaDialogCommandOutput(params) {
     const generatedAtMs = params.generatedAtMs ?? Date.now();
-    const runtime = await resolveQuotaRuntimeContext({
-        client: params.client,
-        roots: params.roots,
+    applyPricingSettings(params.host.settings().settings.providers.pricing);
+    const sessionModel = params.sessionID && params.resolveSessionModel
+        ? await params.resolveSessionModel(params.sessionID)
+        : undefined;
+    const data = await buildStatusReportData({
+        host: params.host,
+        origin: params.origin,
+        opencode: params.opencode,
         sessionID: params.sessionID,
-        sessionMeta: params.sessionMeta,
-        resolveSessionMeta: params.resolveSessionMeta,
-        includeSessionMeta: (config) => config.onlyCurrentModel || params.command === "quota_status",
+        sessionModel,
+        conversion: params.conversion,
+        generatedAtMs,
+        onDetectedProviderIds: params.onDetectedProviderIds,
     });
-    setPricingSnapshotAutoRefresh(runtime.config.pricingSnapshot.autoRefresh);
-    setPricingSnapshotSelection(runtime.config.pricingSnapshot.source);
-    if (!runtime.config.enabled && params.command !== "quota_announcements") {
-        return { state: "noop", command: params.command, reason: "disabled" };
-    }
-    if (params.command === "quota") {
-        const reportData = await fetchQuotaCommandData({
-            runtime,
-            setLastSessionTokenError: params.setLastSessionTokenError,
-        });
-        if (!reportData.data ||
-            (reportData.selection?.filteringByCurrentSelection &&
-                reportData.selection.filtered.length === 0)) {
-            return outputResult(params.command, plainTextReport(messageDocument(buildQuotaCommandUnavailableMessage(reportData))));
-        }
-        return outputResult(params.command, plainTextReport(buildQuotaCommandDocument({
-            ...reportData.data,
-            generatedAtMs,
-            percentDisplayMode: runtime.config.percentDisplayMode,
-            percentLabelStyle: runtime.config.percentLabelStyle,
-            accountingDetail: runtime.config.accountingDetail,
-            resetTimeSpaced: runtime.config.resetTimeSpaced,
-        })));
-    }
-    if (params.command === "quota_status") {
-        const data = await buildStatusReportData({
-            runtime,
-            sessionID: params.sessionID,
-            generatedAtMs,
-            lastSessionTokenError: params.lastSessionTokenError,
-            log: params.log,
-            onDetectedProviderIds: params.onDetectedProviderIds,
-        });
-        return data.document && data.output
-            ? outputResult(params.command, { document: data.document, output: data.output })
-            : { state: "noop", command: params.command, reason: "disabled" };
-    }
-    if (params.command === "quota_announcements") {
-        if ((params.arguments ?? "").trim()) {
-            return outputResult(params.command, plainTextReport(messageDocument("Invalid arguments for /quota_announcements\n\nThis command does not accept arguments.\n\nUsage: /quota_announcements")));
-        }
-        return outputResult(params.command, await buildQuotaAnnouncementsCommandReport(runtime));
-    }
-    if (params.command === "pricing_refresh") {
-        if ((params.arguments ?? "").trim()) {
-            return outputResult(params.command, plainTextReport(messageDocument("Invalid arguments for /pricing_refresh\n\nThis command does not accept arguments.\n\nUsage:\n/pricing_refresh")));
-        }
-        const result = await maybeRefreshPricingSnapshot({
-            reason: "manual",
-            force: true,
-            snapshotSelection: runtime.config.pricingSnapshot.source,
-            allowRefreshWhenSelectionBundled: true,
-        });
-        return outputResult(params.command, buildPricingRefreshCommandReport({
-            result,
-            configuredSelection: runtime.config.pricingSnapshot.source,
-            generatedAtMs,
-        }));
-    }
-    if (isTokenReportCommand(params.command)) {
-        return outputResult(params.command, await buildTokenReportCommandReport({
-            command: params.command,
-            arguments: params.arguments,
-            sessionID: params.sessionID,
-            generatedAtMs,
-            runtime,
-            log: params.log,
-        }));
-    }
-    return { state: "noop", command: params.command, reason: "disabled" };
+    return { output: data.output };
 }
 //# sourceMappingURL=quota-dialog-commands.js.map