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

package/dist/lib/quota-status.js

@@ -1,21 +1,130 @@
-import { stat } from "fs/promises";
-import { homedir } from "os";
-import { getProviders } from "../providers/registry.js";
-import { interpretAccountingRow } from "./accounting-format.js";
-import { QUOTA_TOAST_SETTING_SOURCE_KEYS, } from "./config.js";
-import { sanitizeQuotaProviderResult, sanitizeSingleLineDisplayText } from "./display-sanitize.js";
-import { replaceHomeDirWithTilde, replaceHomeDirWithTildeInDocument } from "./home-dir-display.js";
-import { getPricingRefreshPolicy, getPricingSnapshotHealth, getPricingSnapshotMeta, getPricingSnapshotSource, getProviderModelCount, getRuntimePricingRefreshStatePath, getRuntimePricingSnapshotPath, listProviders, readPricingRefreshState, hasProvider as snapshotHasProvider, } from "./modelsdev-pricing.js";
-import { getCredentialSourceDiagnostics } from "./opencode-auth.js";
+/**
+ * The Quota Status report (`/quota_status`, the `quota_status` tool, `opencode-quota status`):
+ * the OpenCode version and computer, where the settings come from and which differ from the
+ * defaults, what each known provider returned, logins, local files and prices. Every provider
+ * section is built the same way from the store's snapshot (state, rows, error, debug details).
+ *
+ * Users paste this report into public issues, so it is built from a closed vocabulary. Every
+ * value it prints is a member of a set this plugin defines (provider ids, row keys, windows,
+ * error codes, states, setting keys, the provider's own env variables, folder and file names)
+ * or a number, count or time this file formats in its range. Everything else is counted or
+ * stands in as a placeholder: "custom 1", "account 2", "(part 1)", "(custom path)", "(out of
+ * range)", "3 other details not shown". A debug detail shows only when its key is in its
+ * provider's allow list and its value passes that key's rule.
+ */
+import { stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { classifyError, describeError, errorKind, httpStatus, isQuotaErrorCode, LOCAL_TOOLS, } from "../core/errors.js";
+import { isQuotaWindow } from "../core/windows.js";
+import { isV5SettingKey } from "../settings/convert.js";
+import { defaultSettings, diffSettings, isSettingsGroup, PROVIDER_IDS as SETTINGS_PROVIDER_IDS, SETTINGS_SCHEMA, THEME_COLOR_NAMES, } from "../settings/schema.js";
+import { formatShare, formatTokens } from "../view/format.js";
+import { COUNT_LABELS } from "./accounting-format.js";
+import { ERROR_MESSAGES as ALIBABA_TOKEN_PLAN_ERRORS } from "./alibaba-token-plan.js";
+import { API_KEY_LOGIN_VENDORS, API_KEY_VENDORS } from "./api-key-resolver.js";
+import { COPILOT_AUTH_KEYS } from "./copilot.js";
+import { CURSOR_CANONICAL_PLUGIN_PACKAGE } from "./cursor-detection.js";
+import { sanitizeSingleLineDisplayText } from "./display-sanitize.js";
+import { AGY_AUTH_KEYS } from "./google-agy.js";
+import { GEMINI_CLI_AUTH_KEYS } from "./google-gemini-cli.js";
+import { replaceHomeDirWithTildeInDocument } from "./home-dir-display.js";
+import { getPricingRefreshPolicy, getPricingSnapshotHealth, getPricingSnapshotMeta, getPricingSnapshotSource, getRuntimePricingRefreshStatePath, getRuntimePricingSnapshotPath, isBundledPricingModelId, isBundledPricingProviderId, listProviders, readPricingRefreshState, } from "./modelsdev-pricing.js";
+import { OPENAI_AUTH_SOURCE_KEYS } from "./openai.js";
 import { getOpenCodeDbPath } from "./opencode-db-path.js";
 import { getOpencodeRuntimeDirs } from "./opencode-runtime-paths.js";
 import { getOpenCodeDbStats } from "./opencode-storage.js";
-import { getQuotaProviderDisplayLabel } from "./provider-metadata.js";
-import { isMaintainedQuotaProviderTuning } from "./quota-providers.js";
-import { aggregateUsage } from "./quota-stats.js";
-import { commandHeading, renderPlainTextReport, } from "./report-document.js";
-import { totalTokenBuckets } from "./token-buckets.js";
+import { MEMBER_BUDGET_NOTE } from "./opencode-zen.js";
+import { getQuotaProviderDisplayLabel, PROVIDER_ROW_KEYS, QUOTA_PROVIDER_CATALOG, QUOTA_PROVIDER_RUNTIME_IDS, } from "./provider-metadata.js";
+import { isMaintainedQuotaProviderTuning, } from "./quota-providers.js";
+import { renderPlainTextReport, } from "./report-document.js";
 import { getPackageVersion } from "./version.js";
+/** Rows listed per provider section; the rest are counted. */
+const ROW_LIST_LIMIT = 8;
+/** Models without a price listed in the pricing section; the rest are counted. */
+const UNPRICED_LIST_LIMIT = 5;
+/** Shown for a path outside the known folders, or with a part this plugin did not name. */
+const CUSTOM_PATH = "(custom path)";
+/** The quota providers' ids. */
+const PROVIDER_IDS = new Set(Object.keys(QUOTA_PROVIDER_CATALOG));
+/** The provider ids OpenCode uses for them ("github-copilot", "codex", …), and theirs. */
+const OPENCODE_PROVIDER_IDS = new Set([
+    ...PROVIDER_IDS,
+    ...Object.values(QUOTA_PROVIDER_RUNTIME_IDS).flat(),
+]);
+const CURRENCIES = new Set(Intl.supportedValuesOf("currency"));
+const CREDENTIAL_SOURCE_KINDS = {
+    "opencode-integration-api": true,
+    sqlite: true,
+};
+const CREDENTIAL_FAILURE_CATEGORIES = new Set(["refresh_failed", "resolve_empty", "active_failed"]);
+/** Folder and file names this plugin and OpenCode use; a shown path is made only of these. */
+export const KNOWN_PATH_PARTS = new Set([
+    ".config",
+    ".local",
+    "share",
+    "state",
+    ".cache",
+    "opencode",
+    "opencode-quota",
+    "quota-providers",
+    ".claude",
+    "local",
+    "bin",
+    ".cursor",
+    "cursor",
+    "Library",
+    "Application Support",
+    "AppData",
+    "Roaming",
+    "Local",
+]);
+/** File names this plugin and OpenCode read or write. */
+export const KNOWN_FILE_NAMES = new Set([
+    "settings.jsonc",
+    "opencode.db",
+    "opencode.json",
+    "opencode.jsonc",
+    "auth.json",
+    "cli-config.json",
+    ".credentials.json",
+    "copilot-quota-token.json",
+    "mimo.json",
+    "alibaba-coding-plan-local-quota.json",
+    "modelsdev-pricing.runtime.min.json",
+    "modelsdev-pricing.refresh-state.json",
+    "snapshot-v6.json",
+    "quota-export.json",
+    "google-access-tokens.json",
+    "maintainer-announcements-home.json",
+    "quota-toast.json",
+    "quota-toast.jsonc",
+    "claude",
+]);
+/** Paths outside the home dir this plugin looks at. */
+export const KNOWN_ABSOLUTE_PATHS = new Set([
+    "/opt/homebrew/bin/claude",
+    "/usr/local/bin/claude",
+]);
+/** Where an API key came from, besides an env variable or a path. */
+const KEY_FILE_SOURCES = new Set([
+    "opencode.json",
+    "opencode.jsonc",
+    "opencode.db",
+]);
+/** The providers that read a key or a cookie, by id, and the env variables they read it from. */
+const KEY_VENDORS = {
+    ...API_KEY_VENDORS,
+    ...API_KEY_LOGIN_VENDORS,
+    openrouter: { envVars: ["OPENROUTER_API_KEY"] },
+    cursor: { envVars: ["CURSOR_API_KEY"] },
+    xiaomi: { envVars: ["MIMO_USAGE_COOKIE"] },
+};
+const ORIGINS = {
+    slash_command: "/quota_status",
+    tool: "quota_status tool",
+    tui: "TUI Plugin tab",
+    cli: "opencode-quota status (CLI)",
+};
 async function pathExists(path) {
     try {
         await stat(path);
@@ -26,839 +135,1070 @@ async function pathExists(path) {
     }
 }
 function fmtInt(n) {
-    return Math.trunc(n).toLocaleString("en-US");
-}
-const STATUS_SAMPLE_LIMIT = 5;
-const STATUS_LIVE_ENTRY_LIMIT = 2;
-const STATUS_LIVE_ERROR_LIMIT = 2;
-const STATUS_LIVE_ROW_MAX_LENGTH = 120;
-const OPENCODE_GO_STATUS_DETAIL_KEYS = new Set([
-    "auth_state",
-    "auth_source",
-    "auth_checked_paths",
-    "credential_database_paths",
-    "auth_error",
-    "selected_windows",
-    "rolling_usage",
-    "weekly_usage",
-    "monthly_usage",
-    "live_fetch_error",
-    "opencode_go_state",
-    "go_source",
-    "console_error",
-    "console_auth_state",
-    "console_server",
-]);
-function joinOrNone(values) {
-    return values.length > 0 ? values.join(" | ") : "(none)";
+    return Number.isFinite(n) ? Math.trunc(n).toLocaleString("en-US") : "(none)";
 }
-function formatSettingSources(sources) {
-    if (!sources)
+/** The times this report prints: from 2000 to 2100. */
+const FIRST_DATE_MS = Date.UTC(2000, 0, 1);
+const LAST_DATE_MS = Date.UTC(2100, 0, 1);
+/** An ISO time from 2000 to 2100, "(none)" for no time, and "(invalid date)" for any other. */
+function isoText(ms) {
+    if (typeof ms !== "number" || ms === 0)
         return "(none)";
-    const parts = QUOTA_TOAST_SETTING_SOURCE_KEYS.filter((key) => typeof sources[key] === "string" && sources[key].length > 0).map((key) => `${key}<=${sources[key]}`);
-    return parts.length > 0 ? parts.join(" | ") : "(none)";
-}
-function getConfigPrecedenceLabel(configSource) {
-    switch (configSource) {
-        case "files":
-            return "global defaults -> workspace overrides";
-        case "sdk":
-            return "sdk fallback (no file-backed config)";
-        case "defaults":
-            return "built-in defaults only";
-        default:
-            return configSource;
-    }
-}
-function createKvSection(id, title, rows) {
-    return {
-        id,
-        title,
-        blocks: [{ kind: "kv", rows }],
-    };
+    return ms >= FIRST_DATE_MS && ms < LAST_DATE_MS ? new Date(ms).toISOString() : "(invalid date)";
 }
-function createLinesSection(id, title, lines) {
-    return {
-        id,
-        title,
-        blocks: [{ kind: "lines", lines }],
-    };
+/** An ISO date text ("2026-10-11T00:00:00Z") as `isoText` shows it; other text is no date. */
+function dateText(text) {
+    return /^\d{4}-\d{2}-\d{2}/u.test(text) ? isoText(Date.parse(text)) : "(invalid date)";
 }
-function normalizeLiveProbeText(value) {
-    return sanitizeSingleLineDisplayText(value).replace(/:+$/u, "").toLowerCase();
+/** A whole number from `min` to `max`, else "(out of range)": a long number is no count. */
+function inRange(value, min, max) {
+    return Number.isInteger(value) && value >= min && value <= max ? String(value) : "(out of range)";
 }
-function isRedundantLiveProbeDescriptor(providerId, value) {
-    if (!value)
-        return true;
-    const normalized = normalizeLiveProbeText(value);
-    if (!normalized)
-        return true;
-    return (normalized === normalizeLiveProbeText(providerId) ||
-        normalized === normalizeLiveProbeText(getQuotaProviderDisplayLabel(providerId)));
+const DAY_MS = 24 * 60 * 60 * 1000;
+/** The most days `providers.pricing.autoRefreshDays` shows: a longer wait is no setting. */
+const MAX_REFRESH_DAYS = 9999;
+/** A time span in ms up to `MAX_REFRESH_DAYS` days, else "(out of range)". */
+function msText(ms) {
+    return Number.isFinite(ms) && ms >= 0 && ms <= MAX_REFRESH_DAYS * DAY_MS
+        ? fmtInt(ms)
+        : "(out of range)";
 }
-function findProviderLiveProbe(providerId, probes) {
-    return probes?.find((probe) => probe.providerId === providerId);
+/** "2.1.3": the first three numbers of a version, each up to 999; undefined for no version. */
+function versionText(value) {
+    const match = /^(\d+)\.(\d+)\.(\d+)/u.exec(value);
+    if (!match)
+        return undefined;
+    const parts = match.slice(1, 4).map(Number);
+    return parts.every((part) => part <= 999) ? parts.join(".") : "(out of range)";
 }
-function getProviderStatusDetails(providerId, probes) {
-    const probe = findProviderLiveProbe(providerId, probes);
-    return probe ? sanitizeQuotaProviderResult(probe.result).statusDetails : undefined;
+function joinOrNone(values) {
+    return values.length > 0 ? values.join(" | ") : "(none)";
 }
-function appendProviderStatusDetailRows(rows, providerId, probes, keys) {
-    for (const detail of getProviderStatusDetails(providerId, probes) ?? []) {
-        if (!keys || keys.has(detail.key)) {
-            rows.push({ key: detail.key, value: detail.value });
-        }
-    }
+function kvSection(id, rows) {
+    return { id, title: `${id}:`, blocks: [{ kind: "kv", rows }] };
 }
-function findProviderStatusDetail(providerId, key, probes) {
-    return getProviderStatusDetails(providerId, probes)?.find((detail) => detail.key === key)?.value;
+/** "1 other detail not shown", "3 other details not shown". */
+function countText(count, one, many) {
+    return `${count} ${count === 1 ? one : many}`;
 }
-function getLiveProbeState(probe) {
-    if (!probe)
-        return "unavailable";
-    if (probe.result.entries.length > 0 && probe.result.errors.length > 0)
-        return "partial";
-    if (probe.result.entries.length > 0)
-        return "success";
-    if (probe.result.errors.length > 0)
-        return "error";
-    return "no_data";
-}
-function appendProviderCompactLiveProbeRows(rows, providerId, probes, availability, homeDir) {
-    const provider = availability.find((item) => item.id === providerId);
-    if (!provider?.enabled || !provider.available)
-        return;
-    appendCompactLiveProbeRows(rows, providerId, findProviderLiveProbe(providerId, probes), homeDir);
-}
-function createCompactLiveProbeOnlySection(params) {
-    const provider = params.availability.find((item) => item.id === params.providerId);
-    if (!provider?.enabled || !provider.available)
-        return null;
-    const probe = findProviderLiveProbe(params.providerId, params.probes);
-    if (!probe) {
-        return null;
-    }
-    const rows = [];
-    appendCompactLiveProbeRows(rows, params.providerId, probe, params.homeDir);
-    return createKvSection(params.id, params.title, rows);
+/** Hands out 1, 2, 3, … per distinct value, in the order values are first seen. */
+function numbering() {
+    const seen = [];
+    return (value) => {
+        if (!seen.includes(value))
+            seen.push(value);
+        return seen.indexOf(value) + 1;
+    };
 }
-function createProviderStatusSection(params) {
-    const rows = [];
-    if (params.includeDetails !== false) {
-        appendProviderStatusDetailRows(rows, params.providerId, params.probes, params.detailKeys);
-    }
-    appendProviderCompactLiveProbeRows(rows, params.providerId, params.probes, params.availability, params.homeDir);
-    return createKvSection(params.id, params.title, rows);
+/** The 1-based place of each custom definition id, as the settings section lists them. */
+function customNumbers(params) {
+    return new Map((params.quotaProviders ?? []).map((definition, index) => [definition.id, index + 1]));
 }
-function getCompactLiveProbeDescriptor(providerId, entry, semanticLabel) {
-    if (entry.semantic) {
-        return sanitizeSingleLineDisplayText(semanticLabel);
-    }
-    const candidates = [entry.label, entry.name, entry.group];
-    for (const candidate of candidates) {
-        if (typeof candidate !== "string")
-            continue;
-        const cleaned = sanitizeSingleLineDisplayText(candidate);
-        if (!cleaned || isRedundantLiveProbeDescriptor(providerId, cleaned)) {
+/** The path's parts after the home dir ("~" or `homeDir`), or undefined outside it. */
+function partsUnderHome(path, homeDir) {
+    for (const home of ["~", homeDir]) {
+        if (!home)
             continue;
+        if (path === home)
+            return [];
+        const separator = path.charAt(home.length);
+        if (path.startsWith(home) && (separator === "/" || separator === "\\")) {
+            return path.slice(home.length + 1).split(/[/\\]/u);
         }
-        return cleaned;
     }
     return undefined;
 }
 /**
- * One live probe row, cut to its length limit. The home dir becomes "~" before the cut, so a
- * cut inside a home path cannot leave part of the user name (e.g. "/Users/ali").
+ * A path made only of known parts: under the home dir, every folder and file name one this
+ * plugin or OpenCode uses ("~/.config/opencode/opencode-quota/settings.jsonc"), or a known
+ * absolute path. Any other path, such as one from an env variable or the settings, shows as
+ * "(custom path)", with its file name when that is a known one.
  */
-function shortenLiveRowText(text, homeDir) {
-    return replaceHomeDirWithTilde(sanitizeSingleLineDisplayText(text), homeDir).slice(0, STATUS_LIVE_ROW_MAX_LENGTH);
+function pathText(raw, homeDir) {
+    const path = sanitizeSingleLineDisplayText(raw);
+    if (KNOWN_ABSOLUTE_PATHS.has(path))
+        return path;
+    const parts = partsUnderHome(path, sanitizeSingleLineDisplayText(homeDir));
+    const known = (part) => KNOWN_PATH_PARTS.has(part) || KNOWN_FILE_NAMES.has(part);
+    if (parts?.every(known))
+        return ["~", ...parts].join("/");
+    const fileName = path.split(/[/\\]/u).at(-1) ?? "";
+    return KNOWN_FILE_NAMES.has(fileName) ? `${CUSTOM_PATH}/${fileName}` : CUSTOM_PATH;
 }
-function formatCompactLiveProbeEntry(providerId, entry, homeDir) {
-    const interpretation = interpretAccountingRow(entry, { booleanWording: "semantic" });
-    const parts = [];
-    const descriptor = getCompactLiveProbeDescriptor(providerId, entry, interpretation.label);
-    if (descriptor) {
-        parts.push(descriptor);
-    }
-    if (interpretation.display.kind === "value") {
-        const value = interpretation.display.entryKind === "value"
-            ? sanitizeSingleLineDisplayText(interpretation.display.text)
-            : interpretation.display.text;
-        parts.push(`value=${value}`);
-    }
-    else {
-        if (entry.right) {
-            parts.push(sanitizeSingleLineDisplayText(entry.right));
-        }
-        const percentRemaining = Number.isFinite(interpretation.display.percentRemaining)
-            ? Math.max(0, Math.min(100, Math.round(interpretation.display.percentRemaining)))
-            : 0;
-        parts.push(`percent_remaining=${percentRemaining}`);
+/** A path with the "(experimental.quotaToast)" note v5 conversion adds to a source. */
+function sourceFileText(source, homeDir) {
+    const note = " (experimental.quotaToast)";
+    return source.endsWith(note)
+        ? `${pathText(source.slice(0, -note.length), homeDir)}${note}`
+        : pathText(source, homeDir);
+}
+/**
+ * The session's model as "openai/gpt-5": ids OpenCode or the shipped price list knows, else a
+ * placeholder. A downloaded price list is a file on this machine, so its ids are not trusted.
+ */
+function currentModelText(params) {
+    const { currentModel, currentProviderID } = params;
+    if (currentModel) {
+        const provider = currentProviderID === undefined
+            ? "(unknown provider)"
+            : OPENCODE_PROVIDER_IDS.has(currentProviderID) ||
+                isBundledPricingProviderId(currentProviderID)
+                ? currentProviderID
+                : "(other provider)";
+        const model = isBundledPricingModelId(currentModel)
+            ? currentModel
+            : "(model not in the shipped price list)";
+        return `${provider}/${model}`;
     }
-    if (entry.resetTimeIso) {
-        parts.push(`reset_at=${sanitizeSingleLineDisplayText(entry.resetTimeIso)}`);
+    if (params.sessionModelLookup === "not_found")
+        return "(the session has no model yet)";
+    if (params.sessionModelLookup === "no_session")
+        return "(no session)";
+    return "(unknown)";
+}
+/** Known provider ids joined, and how many others there were. */
+function providerIdsText(ids) {
+    const known = ids.filter((id) => SETTINGS_PROVIDER_IDS.includes(id));
+    const others = ids.length - known.length;
+    const text = joinOrNone(known);
+    return others > 0 ? `${text} (+${countText(others, "unknown id", "unknown ids")})` : text;
+}
+/**
+ * A custom provider definition as its number, mode and model count: "custom 1 (remote-api,
+ * 3 models)". Its id, provider id, URL, key, env variable and model ids are never shown. A
+ * definition that tunes a maintained provider names that provider. A switched-off definition
+ * says so and where to switch it on.
+ */
+function customProviderText(definition, number) {
+    if (definition.enabled === false) {
+        return `custom ${number} off (switch on in /quota_settings → Providers)`;
     }
-    return shortenLiveRowText(parts.join(" "), homeDir);
-}
-function formatCompactLiveProbeError(providerId, error, homeDir) {
-    const label = isRedundantLiveProbeDescriptor(providerId, error.label)
-        ? ""
-        : sanitizeSingleLineDisplayText(error.label);
-    const message = sanitizeSingleLineDisplayText(error.message);
-    return shortenLiveRowText(label ? `${label}: ${message}` : message, homeDir);
-}
-function getQuotaProviderCredentialCategory(source) {
-    switch (source) {
-        case "explicit_env":
-            return "environment";
-        case "global_opencode_json":
-        case "global_opencode_jsonc":
-            return "trusted_global_config";
-        case "opencode_db":
-            return "opencode_db";
-        default:
-            return "none";
+    const mode = definition.mode === "remote-api" ? "remote-api" : "local-estimate";
+    const models = definition.modelIds
+        ? countText(definition.modelIds.length, "model", "models")
+        : "all models";
+    const tunes = isMaintainedQuotaProviderTuning(definition) && PROVIDER_IDS.has(definition.id)
+        ? `, tunes ${definition.id}`
+        : "";
+    return `custom ${number} (${mode}, ${models}${tunes})`;
+}
+function settingsFileText(params, homeDir) {
+    const { exists } = params.settings;
+    const path = pathText(params.settings.path, homeDir);
+    if (exists)
+        return `${path} (exists)`;
+    if (params.conversion)
+        return `${path} (missing; the v5 settings are converted in memory)`;
+    return `${path} (missing; using the defaults)`;
+}
+/** Our words for a settings issue, chosen by its message; never the value it names. */
+const ISSUE_CODES = [
+    [/^expected one JSON object/u, "not one JSON object; using the defaults"],
+    [/^expected /u, "invalid value"],
+    [/^unknown provider id/u, "unknown provider id"],
+    [/^duplicate key/u, "duplicate key"],
+    [/^cannot read it/u, "cannot read the file; using the defaults"],
+    [/^file-only/u, "file-only setting"],
+];
+function issueCodeText(message) {
+    const line = /^syntax error on line (\d+)/u.exec(message)?.[1];
+    if (line !== undefined)
+        return `syntax error on line ${inRange(Number(line), 1, 9999)}`;
+    return codeOf(ISSUE_CODES, message) ?? "invalid";
+}
+/** The code of the first pattern the text matches. */
+function codeOf(codes, text) {
+    return codes.find(([pattern]) => pattern.test(text))?.[1];
+}
+/** Our code for each v5 conversion note, chosen by its words; never the paths it names. */
+const CONVERSION_NOTE_CODES = [
+    [/ does not parse as a JSON object, so it was not converted$/u, "file_not_a_json_object"],
+    [/ was not converted: v5 used .+ when both exist$/su, "jsonc_used_over_json"],
+    [/^experimental\.quotaToast in .+ v5 ignored it while /su, "quota_toast_block_ignored"],
+    [/ does not parse, so its experimental\.quotaToast was not converted$/u, "config_not_parsed"],
+    [/^the old settings in .+ were not converted: .+ has some too$/su, "older_folder_not_converted"],
+];
+/** A settings key from the schema, a group, a file-level key, or the custom providers. */
+function issueKeyText(key) {
+    if (Object.hasOwn(SETTINGS_SCHEMA, key) || isSettingsGroup(key))
+        return key;
+    if (key === "$file" || key === "$patch" || key === "$conversion")
+        return key;
+    if (key.startsWith("providers.custom[") || key.startsWith("providers.custom.")) {
+        return "providers.custom";
     }
+    return undefined;
 }
-function createQuotaProvidersSection(params) {
-    if (params.definitions.length === 0)
-        return null;
-    const diagnostics = findProviderLiveProbe("quota-providers", params.probes)?.result.diagnostics ?? [];
-    const diagnosticsBySource = new Map(diagnostics.map((diagnostic) => [diagnostic.sourceId, diagnostic]));
+/** Each issue as our key and words; unknown keys are counted. */
+function settingsIssueRows(issues) {
     const rows = [];
-    for (const definition of params.definitions) {
-        const diagnostic = diagnosticsBySource.get(definition.id);
-        const coverage = definition.modelIds ? definition.modelIds.join(",") : "all_models";
-        if (definition.mode === "local-estimate" && isMaintainedQuotaProviderTuning(definition)) {
-            const probe = findProviderLiveProbe(definition.id, params.probes);
-            const statePath = findProviderStatusDetail(definition.id, "local_state_path", params.probes);
-            const stateExists = findProviderStatusDetail(definition.id, "local_state_exists", params.probes);
-            const stateHealth = findProviderStatusDetail(definition.id, "local_state_health", params.probes);
-            const stateVersion = findProviderStatusDetail(definition.id, "local_state_version", params.probes);
-            const stateLastUpdate = findProviderStatusDetail(definition.id, "local_state_last_update", params.probes);
-            rows.push({
-                key: `provider_${definition.id}`,
-                value: [
-                    `provider_id=${definition.providerId}`,
-                    "mode=local-estimate",
-                    `coverage=${coverage}`,
-                    `outcome=${getLiveProbeState(probe)}`,
-                    `limits=${definition.windows.map((window) => `${window.id}:${window.requestLimit}`).join(",")}`,
-                    `state_path=${statePath ?? "(none)"}`,
-                    `state_exists=${stateExists ?? "false"}`,
-                    `state_health=${stateHealth ?? "missing"}`,
-                    `state_version=${stateVersion ?? "(none)"}`,
-                    `state_last_update=${stateLastUpdate ?? "(none)"}`,
-                ]
-                    .map((part) => sanitizeSingleLineDisplayText(part))
-                    .join(" "),
-            });
-            continue;
-        }
-        if (definition.mode === "local-estimate") {
-            const stateHealth = diagnostic?.stateHealth ?? "missing";
-            rows.push({
-                key: `provider_${definition.id}`,
-                value: [
-                    `provider_id=${definition.providerId}`,
-                    "mode=local-estimate",
-                    `coverage=${coverage}`,
-                    `outcome=${diagnostic?.outcome ?? "unavailable"}`,
-                    `state_path=${diagnostic?.statePath ?? "(none)"}`,
-                    `state_exists=${diagnostic?.statePath && stateHealth !== "missing" ? "true" : "false"}`,
-                    `state_health=${stateHealth}`,
-                    `state_version=${diagnostic?.stateVersion ?? "(none)"}`,
-                    `state_last_update=${diagnostic?.stateLastUpdatedAt == null ? "(none)" : new Date(diagnostic.stateLastUpdatedAt).toISOString()}`,
-                ]
-                    .map((part) => sanitizeSingleLineDisplayText(part))
-                    .join(" "),
-            });
+    let unknownKeys = 0;
+    for (const issue of issues) {
+        const key = issueKeyText(issue.key);
+        if (key === undefined || issue.message.startsWith("unknown setting")) {
+            unknownKeys += 1;
             continue;
         }
-        const checkedPaths = diagnostic
-            ? [...new Set([...diagnostic.checkedPaths, ...diagnostic.credentialDatabasePaths])]
-            : [];
-        rows.push({
-            key: `provider_${definition.id}`,
-            value: [
-                `provider_id=${definition.providerId}`,
-                "mode=remote-api",
-                `format=${definition.format}`,
-                `coverage=${coverage}`,
-                `outcome=${diagnostic?.outcome ?? "unavailable"}`,
-                `credential_category=${getQuotaProviderCredentialCategory(diagnostic?.credentialSource ?? null)}`,
-                `env_name=${definition.apiKeyEnv ?? "(none)"}`,
-                `checked_paths=${checkedPaths.length > 0 ? checkedPaths.join(" | ") : "(none)"}`,
-            ]
-                .map((part) => sanitizeSingleLineDisplayText(part))
-                .join(" "),
-        });
-    }
-    return createKvSection("quota_providers", "quota_providers:", rows);
-}
-function appendCompactLiveProbeRows(rows, providerId, probe, homeDir) {
-    if (!probe)
-        return;
-    const result = sanitizeQuotaProviderResult(probe.result);
-    const entryCount = Math.min(result.entries.length, STATUS_LIVE_ENTRY_LIMIT);
-    const errorCount = Math.min(result.errors.length, STATUS_LIVE_ERROR_LIMIT);
-    const state = result.entries.length > 0 && result.errors.length > 0
-        ? "partial"
-        : result.entries.length > 0
-            ? "success"
-            : result.errors.length > 0
-                ? "error"
-                : "no_data";
-    rows.push({ key: "live_probe", value: state });
-    for (let index = 0; index < entryCount; index += 1) {
-        rows.push({
-            key: `live_entry_${index + 1}`,
-            value: formatCompactLiveProbeEntry(providerId, result.entries[index], homeDir),
-        });
+        rows.push({ key: "settings_issue", value: `${key}: ${issueCodeText(issue.message)}` });
     }
-    for (let index = 0; index < errorCount; index += 1) {
+    if (unknownKeys > 0) {
         rows.push({
-            key: `live_error_${index + 1}`,
-            value: formatCompactLiveProbeError(providerId, result.errors[index], homeDir),
-        });
-    }
-    const suppressedCount = Math.max(0, result.entries.length - entryCount) +
-        Math.max(0, result.errors.length - errorCount);
-    if (suppressedCount > 0) {
-        rows.push({
-            key: "live_more",
-            value: `+${suppressedCount} additional rows suppressed`,
+            key: "settings_issue",
+            value: countText(unknownKeys, "unknown key", "unknown keys"),
         });
     }
+    return rows;
 }
-function computePricingCoverageFromAgg(agg) {
-    const byProvider = new Map();
-    let pricedKeysSeen = 0;
-    let mappedMissingKeysSeen = 0;
-    let unpricedKeysSeen = 0;
-    // Priced keys seen in history
-    for (const row of agg.byModel) {
-        const p = row.key.provider;
-        const existing = byProvider.get(p) ?? {
-            pricedKeysSeen: 0,
-            mappedMissingKeysSeen: 0,
-            unpricedKeysSeen: 0,
-        };
-        existing.pricedKeysSeen += 1;
-        byProvider.set(p, existing);
-        pricedKeysSeen += 1;
-    }
-    // Keys that mapped to an official provider/model but were missing pricing
-    for (const row of agg.unknown) {
-        const p = row.key.mappedProvider;
-        if (!p || !row.key.mappedModel)
-            continue;
-        const existing = byProvider.get(p) ?? {
-            pricedKeysSeen: 0,
-            mappedMissingKeysSeen: 0,
-            unpricedKeysSeen: 0,
-        };
-        existing.mappedMissingKeysSeen += 1;
-        byProvider.set(p, existing);
-        mappedMissingKeysSeen += 1;
-    }
-    // Mapped keys that we explicitly consider unpriced
-    for (const row of agg.unpriced) {
-        const p = row.key.mappedProvider;
-        const existing = byProvider.get(p) ?? {
-            pricedKeysSeen: 0,
-            mappedMissingKeysSeen: 0,
-            unpricedKeysSeen: 0,
-        };
-        existing.unpricedKeysSeen += 1;
-        byProvider.set(p, existing);
-        unpricedKeysSeen += 1;
-    }
-    return { byProvider, totals: { pricedKeysSeen, mappedMissingKeysSeen, unpricedKeysSeen } };
-}
-function supportedProviderPricingRow(params) {
-    const id = params.id;
-    if (id === "synthetic") {
-        return {
-            id,
-            pricing: "no",
-            notes: "subscription request quota (not token-priced)",
-        };
-    }
-    if (id === "alibaba-coding-plan") {
-        return {
-            id,
-            pricing: "no",
-            notes: "local request-count estimate (tiered rolling windows, no token pricing API)",
-        };
-    }
-    if (id === "alibaba-token-plan") {
-        return {
-            id,
-            pricing: "no",
-            notes: "official Alibaba Cloud CLI Personal Token Plan quota (not token-priced)",
-        };
-    }
-    if (id === "cursor") {
-        return {
-            id,
-            pricing: "partial",
-            notes: "API-pool models map to official pricing; Auto/Composer use bundled static Cursor rates",
-        };
-    }
-    if (id === "nanogpt") {
-        return {
-            id,
-            pricing: "no",
-            notes: "subscription request quota + account balance (not token-priced)",
-        };
-    }
-    if (id === "deepseek") {
-        return {
-            id,
-            pricing: "no",
-            notes: "account balance only (not token-priced)",
-        };
-    }
-    if (id === "opencode-go") {
-        return {
-            id,
-            pricing: "no",
-            notes: "subscription percentage quota from the OpenCode Go usage API (not token-priced)",
-        };
-    }
-    if (id === "xiaomi") {
-        return {
-            id,
-            pricing: "no",
-            notes: "dashboard monthly token quota and balances; per-key costs unsupported",
-        };
-    }
-    if (id === "kimi-code-plan-global" ||
-        id === "kimi-code-plan-cn" ||
-        id === "kimi-for-coding" ||
-        id === "kimi-code" ||
-        id === "kimi") {
-        return {
-            id,
-            pricing: "no",
-            notes: "request quota via Kimi Code API (not token-priced)",
-        };
-    }
-    // Providers that correspond directly to models.dev providers.
-    if (params.snapshotProviders.includes(id)) {
-        return { id, pricing: "yes", notes: "models.dev snapshot provider" };
-    }
-    // Connector to snapshot provider; treat as priced if snapshot has OpenAI pricing.
-    // Copilot is an OpenCode provider but token costs still map into official model pricing.
-    if (id === "copilot") {
-        return snapshotHasProvider("openai")
-            ? { id, pricing: "yes", notes: "connector (priced via models.dev openai)" }
-            : { id, pricing: "partial", notes: "connector (pricing snapshot missing openai)" };
-    }
-    if (id === "google-gemini-cli") {
-        return snapshotHasProvider("google")
-            ? { id, pricing: "yes", notes: "connector (priced via models.dev google)" }
-            : { id, pricing: "partial", notes: "connector (pricing snapshot missing google)" };
+/** v5 keys joined, and how many unknown keys there were: "showOnIdle, debug (+1 unknown key)". */
+function v5KeysText(keys) {
+    // "quotaProviders[0].url" is a problem inside the v5 key "quotaProviders".
+    const bases = keys.map((key) => key.replace(/\[.*$/su, ""));
+    const known = [...new Set(bases.filter(isV5SettingKey))];
+    const others = bases.filter((key) => !isV5SettingKey(key)).length;
+    const text = known.join(", ");
+    if (others === 0)
+        return text;
+    const count = countText(others, "unknown key", "unknown keys");
+    return text ? `${text} (+${count})` : count;
+}
+/** Where the v5 settings went: written to settings.jsonc, or not. Only v5 keys are named. */
+function conversionRows(conversion, homeDir) {
+    const { converted, dropped, invalid } = conversion;
+    const sources = conversion.sources.map((source) => sourceFileText(source, homeDir));
+    const counts = `${converted.length} converted, ${dropped.length} dropped, ${invalid.length} invalid`;
+    const outcome = conversion.written
+        ? "written to settings.jsonc"
+        : conversion.notWrittenReason !== undefined
+            ? "not written"
+            : "converted in memory";
+    const rows = [
+        { key: "conversion", value: `from ${joinOrNone(sources)} (${counts}); ${outcome}` },
+    ];
+    const lists = [
+        ["conversion_converted", converted],
+        ["conversion_dropped", dropped],
+        ["conversion_invalid", invalid],
+    ];
+    for (const [key, items] of lists) {
+        if (items.length > 0)
+            rows.push({ key, value: v5KeysText(items.map((item) => item.key)) });
     }
-    // Connector providers: pricing exists when model IDs can be mapped into snapshot pricing keys.
-    // Use local history as the source of truth.
-    const hasAnyUsage = params.agg.bySourceProvider.some((p) => p.providerID === id);
-    const hasAnyUnknown = params.agg.unknown.some((u) => u.key.sourceProviderID === id);
-    // Note: agg.byModel is already mapped to official pricing keys, not source provider IDs.
-    // So for connector providers we infer pricing availability based on whether we saw usage at all
-    // and whether it was mappable.
-    if (!hasAnyUsage && !hasAnyUnknown) {
-        return { id, pricing: "no", notes: "no local usage observed" };
+    if (conversion.notes.length > 0) {
+        const codes = conversion.notes.map((note) => codeOf(CONVERSION_NOTE_CODES, note) ?? "(other)");
+        rows.push({ key: "conversion_notes", value: codes.join(", ") });
     }
-    if (hasAnyUnknown) {
-        return {
-            id,
-            pricing: "partial",
-            notes: "some models not in snapshot (see unpriced_models / unknown_pricing)",
-        };
+    return rows;
+}
+/** Settings with rows of their own (the off list, custom definitions) or no setting (version). */
+const OWN_ROW_KEYS = new Set(["version", "providers.off", "providers.custom"]);
+/** The separators the Settings tab steps through. */
+const SEPARATORS = new Set([" · ", " | ", " / ", "  "]);
+/**
+ * A changed setting's value in this report's words: a switch, choice, number or color as it is,
+ * a list or map as its count, a path as a known path; never a name or text the user typed.
+ */
+function settingValueText(rule, value, homeDir) {
+    if (value === null)
+        return "null";
+    switch (rule.kind) {
+        case "boolean":
+            return value === true ? "true" : "false";
+        case "choice":
+            return rule.values.includes(String(value)) ? String(value) : "(other)";
+        case "number": {
+            if (rule.word !== undefined && value === rule.word)
+                return rule.word;
+            const rounded = typeof value === "number" ? Number(value.toFixed(2)) : Number.NaN;
+            return Number.isFinite(rounded) && Math.abs(rounded) < 1e6
+                ? String(rounded)
+                : "(out of range)";
+        }
+        case "path":
+            return typeof value === "string" ? pathText(value, homeDir) : CUSTOM_PATH;
+        case "color":
+            if (typeof value === "string" && THEME_COLOR_NAMES.includes(value))
+                return value;
+            return typeof value === "string" && /^#[0-9a-f]{6}$/iu.test(value)
+                ? "(custom color)"
+                : "(color)";
+        case "separator":
+            return typeof value === "string" && SEPARATORS.has(value)
+                ? JSON.stringify(value)
+                : "(custom separator)";
+        default: {
+            const count = Array.isArray(value)
+                ? value.length
+                : typeof value === "object"
+                    ? Object.keys(value ?? {}).length
+                    : 1;
+            return countText(count, "entry", "entries");
+        }
     }
-    return {
-        id,
-        pricing: "yes",
-        notes: "model IDs map into snapshot pricing",
-    };
 }
-export async function buildQuotaStatusReport(params) {
-    return renderPlainTextReport(await buildQuotaStatusReportDocument(params));
+/** Every setting that differs from its default, by its settings.jsonc key, under a count. */
+function changedSettingRows(settings, homeDir) {
+    const changes = diffSettings(defaultSettings(), settings).filter((change) => !OWN_ROW_KEYS.has(change.key));
+    const rules = SETTINGS_SCHEMA;
+    return [
+        {
+            key: "changed_from_defaults",
+            value: changes.length > 0 ? countText(changes.length, "setting", "settings") : "(none)",
+        },
+        ...changes.flatMap((change) => {
+            const rule = rules[change.key];
+            if (!rule)
+                return [];
+            return [{ key: change.key, value: settingValueText(rule, change.after, homeDir), indent: 1 }];
+        }),
+    ];
 }
-export async function buildQuotaStatusReportDocument(params) {
-    const homeDir = params.homeDir ?? homedir();
-    const version = await getPackageVersion();
-    const v = version ?? "unknown";
-    const modelDisplay = params.currentModel
-        ? params.currentModel
-        : params.sessionModelLookup === "not_found"
-            ? "(error: session.get returned no modelID)"
-            : params.sessionModelLookup === "no_session"
-                ? "(no session available)"
-                : "(unknown)";
-    const sections = [];
-    // === toast diagnostics ===
-    const toastLines = [
-        `- configSource: ${params.configSource}`,
-        `- configPaths: ${joinOrNone(params.configPaths)}`,
-        `- precedence: ${getConfigPrecedenceLabel(params.configSource)}`,
-        `- global_config_paths: ${joinOrNone(params.globalConfigPaths ?? [])}`,
-        `- workspace_config_paths: ${joinOrNone(params.workspaceConfigPaths ?? [])}`,
-        `- setting_sources: ${formatSettingSources(params.settingSources)}`,
-        `- enabledProviders: ${params.enabledProviders === "auto" ? "(auto)" : params.enabledProviders.length ? params.enabledProviders.join(",") : "(none)"}`,
-        `- onlyCurrentModel: ${params.onlyCurrentModel ? "true" : "false"}`,
-        `- currentModel: ${modelDisplay}`,
+/** OpenCode release channels this report names; a build's own channel name is not shown. */
+const OPENCODE_CHANNELS = new Set([
+    "latest",
+    "beta",
+    "next",
+    "nightly",
+    "preview",
+    "canary",
+    "dev",
+    "local",
+    "snapshot",
+]);
+/**
+ * When and where the report was made, and what it ran on: OpenCode's version and release
+ * channel, the system and CPU, and the JavaScript runtime.
+ */
+function environmentSection(params, nowMs) {
+    const opencode = params.opencode
+        ? `${versionText(params.opencode.version) ?? "(unknown version)"} (${OPENCODE_CHANNELS.has(params.opencode.channel) ? params.opencode.channel : "other channel"})`
+        : "(unknown)";
+    const bun = process.versions.bun;
+    const runtime = bun
+        ? `bun ${versionText(bun) ?? "(unknown version)"}`
+        : `node ${versionText(process.versions.node) ?? "(unknown version)"}`;
+    return kvSection("environment", [
+        { key: "generated_at", value: isoText(nowMs) },
+        { key: "origin", value: ORIGINS[params.origin] },
+        { key: "opencode", value: opencode },
+        { key: "os", value: `${process.platform} ${process.arch}` },
+        { key: "runtime", value: runtime },
+    ]);
+}
+/** The settings file, what is wrong in it, the v5 conversion, and what quota is set to do. */
+function settingsSection(params, homeDir) {
+    const rows = [
+        { key: "settings_file", value: settingsFileText(params, homeDir) },
+        ...settingsIssueRows(params.settings.issues),
     ];
-    if (params.configIssues?.length) {
-        toastLines.push("- config_errors:");
-        for (const issue of params.configIssues) {
-            toastLines.push(`  - ${sanitizeSingleLineDisplayText(issue.path)} ${sanitizeSingleLineDisplayText(issue.key)}: ${sanitizeSingleLineDisplayText(issue.message)}`);
-        }
-    }
-    if (params.runtimeRoots) {
-        toastLines.push(`- workspace_root: ${params.runtimeRoots.workspaceRoot}`);
-        toastLines.push(`- config_root: ${params.runtimeRoots.configRoot}`);
+    if (params.conversion)
+        rows.push(...conversionRows(params.conversion, homeDir));
+    if (params.settings.notRead.length > 0) {
+        const paths = params.settings.notRead.map((path) => sourceFileText(path, homeDir));
+        rows.push({ key: "not_read", value: joinOrNone(paths) });
     }
-    toastLines.push("- providers:");
-    for (const p of params.providerAvailability) {
-        const bits = [];
-        bits.push(p.enabled ? "enabled" : "disabled");
-        bits.push(p.available ? "available" : "unavailable");
-        if (p.matchesCurrentModel !== undefined) {
-            bits.push(`matchesCurrentModel=${p.matchesCurrentModel ? "yes" : "no"}`);
+    rows.push({ key: "providers.off", value: providerIdsText(params.offProviders) }, ...changedSettingRows(params.settings.settings, homeDir), { key: "current_model", value: currentModelText(params) }, { key: "workspace_root", value: pathText(params.workspaceRoot, homeDir) });
+    (params.quotaProviders ?? []).forEach((definition, index) => {
+        rows.push({ key: "providers.custom", value: customProviderText(definition, index + 1) });
+    });
+    return kvSection("settings", rows);
+}
+function providerIdText(id) {
+    return PROVIDER_IDS.has(id) ? id : "(other provider)";
+}
+function providerListSection(availability) {
+    return kvSection("providers", availability.map((provider) => {
+        const bits = [
+            provider.enabled ? "enabled" : "disabled",
+            provider.available ? "available" : "unavailable",
+        ];
+        if (provider.matchesCurrentModel !== undefined) {
+            bits.push(`matchesCurrentModel=${provider.matchesCurrentModel ? "yes" : "no"}`);
         }
-        toastLines.push(`  - ${p.id}: ${bits.join(" ")}`);
+        return { key: providerIdText(provider.id), value: bits.join(" ") };
+    }));
+}
+function noticesSection(announcements) {
+    const { summary } = announcements;
+    return kvSection("notices", [
+        { key: "source", value: summary.source === "bundled_only" ? "bundled_only" : "(other)" },
+        { key: "network", value: summary.network ? "true" : "false" },
+        { key: "active", value: fmtInt(summary.activeCount) },
+        { key: "future", value: fmtInt(summary.futureCount) },
+        { key: "expired", value: fmtInt(summary.expiredCount) },
+    ]);
+}
+async function pathsSection(homeDir) {
+    const dirs = getOpencodeRuntimeDirs();
+    const dbPath = getOpenCodeDbPath();
+    const shownDb = pathText(dbPath, homeDir);
+    let db = `path=${shownDb} present=false`;
+    if (await pathExists(dbPath)) {
+        const stats = await getOpenCodeDbStats();
+        db = `path=${shownDb} present=true sessions=${fmtInt(stats.sessionCount)} messages=${fmtInt(stats.messageCount)} assistant_messages=${fmtInt(stats.assistantMessageCount)}`;
     }
-    sections.push(createLinesSection("toast", "toast:", toastLines));
-    const quotaProvidersSection = createQuotaProvidersSection({
-        definitions: params.quotaProviders ?? [],
-        probes: params.providerLiveProbes,
+    const dir = (path) => pathText(path, homeDir);
+    return kvSection("paths", [
+        {
+            key: "opencode_dirs",
+            value: `data=${dir(dirs.dataDir)} config=${dir(dirs.configDir)} cache=${dir(dirs.cacheDir)} state=${dir(dirs.stateDir)}`,
+        },
+        { key: "opencode.db", value: `${db} (session and token history)` },
+    ]);
+}
+/**
+ * The login source and its failures: each failed login's integration id (when OpenCode or this
+ * plugin knows it), failure kind and time, never its label or the error's own words.
+ */
+function credentialSourceSection(diagnostics) {
+    const failures = diagnostics.failures.map((failure) => {
+        const integration = OPENCODE_PROVIDER_IDS.has(failure.integrationId)
+            ? failure.integrationId
+            : "(other integration)";
+        const category = CREDENTIAL_FAILURE_CATEGORIES.has(failure.category)
+            ? failure.category
+            : "(other failure)";
+        return `${integration}: ${category} at ${isoText(failure.at)}`;
     });
-    if (quotaProvidersSection) {
-        sections.push(quotaProvidersSection);
+    const listError = diagnostics.lastListError;
+    const listErrorText = listError
+        ? `${errorKind(classifyError(listError.detail))} at ${isoText(listError.at)}`
+        : "(none)";
+    const source = diagnostics.state === "bound"
+        ? Object.hasOwn(CREDENTIAL_SOURCE_KINDS, diagnostics.kind)
+            ? diagnostics.kind
+            : "(other source)"
+        : "unbound";
+    return kvSection("credential_source", [
+        { key: "source", value: source },
+        { key: "list_error", value: listErrorText },
+        { key: "failures", value: joinOrNone(failures) },
+    ]);
+}
+const COMPACT = new Intl.NumberFormat("en-US", {
+    notation: "compact",
+    maximumSignificantDigits: 3,
+});
+/** A decimal in three significant digits ("4.5", "1.23K", "123T"): no long number shows. */
+function numberText(decimal) {
+    const value = Number(decimal);
+    if (!Number.isFinite(value))
+        return "(not a number)";
+    return Math.abs(value) < 1e15 ? COMPACT.format(value) : "(out of range)";
+}
+/** "4.5 USD", "12 request"; a unit this plugin does not name shows as a placeholder. */
+function amountText(amount) {
+    const { unit } = amount;
+    let unitText = "(custom unit)";
+    if (unit.kind === "currency")
+        unitText = CURRENCIES.has(unit.code) ? unit.code : "(currency)";
+    else if (unit.kind === "count") {
+        unitText = Object.hasOwn(COUNT_LABELS, unit.unit) ? unit.unit : "(unit)";
     }
-    if (params.maintainerAnnouncements) {
-        const announcements = params.maintainerAnnouncements;
-        const summary = announcements.summary;
-        sections.push(createLinesSection("maintainer_announcements", "maintainer_announcements:", [
-            `- enabled: ${announcements.config.enabled ? "true" : "false"}`,
-            `- home: ${announcements.config.home ? "true" : "false"}`,
-            `- home_frequency: ${announcements.config.homeFrequency}`,
-            `- source: ${summary.source}`,
-            `- network: ${summary.network ? "true" : "false"}`,
-            `- active: ${summary.activeCount}`,
-            `- future: ${summary.futureCount}`,
-            `- expired: ${summary.expiredCount}`,
-        ]));
+    return `${numberText(amount.decimal)} ${unitText}`;
+}
+/**
+ * A row's facts in one line, for example "window=five_hour, 43% left, 57/100 request,
+ * resets 2026-…". Its label and text are the provider's words: a text value is only noted.
+ */
+function rowFacts(row) {
+    const parts = [];
+    if (row.window !== undefined) {
+        parts.push(isQuotaWindow(row.window) ? `window=${row.window}` : "window=(other)");
+    }
+    if (typeof row.percentRemaining === "number") {
+        const percent = inRange(Math.round(row.percentRemaining), 0, 100);
+        parts.push(percent === "(out of range)" ? "percent (out of range)" : `${percent}% left`);
     }
-    // === paths ===
-    const pathsRows = [];
-    const runtime = getOpencodeRuntimeDirs();
-    pathsRows.push({
-        key: "opencode_dirs",
-        value: `data=${runtime.dataDir} config=${runtime.configDir} cache=${runtime.cacheDir} state=${runtime.stateDir}`,
+    if (row.used && row.limit)
+        parts.push(`${numberText(row.used.decimal)}/${amountText(row.limit)}`);
+    if (row.amount)
+        parts.push(amountText(row.amount));
+    if (row.flag !== undefined)
+        parts.push(row.flag ? "yes" : "no");
+    if (row.text !== undefined)
+        parts.push("text not shown");
+    if (row.resetsAt !== undefined)
+        parts.push(`resets ${dateText(row.resetsAt)}`);
+    return parts.join(", ");
+}
+/**
+ * A row id from the ledger: the provider id and its row key, each `*` part as "(part 1)" and a
+ * custom definition's id as "(custom 1)", numbered like the settings section.
+ */
+function rowIdText(row, parts, customs) {
+    const [providerId = "", ...keyParts] = row.id.split(".");
+    if (!PROVIDER_IDS.has(providerId))
+        return "(other row)";
+    const patterns = PROVIDER_ROW_KEYS[providerId].map((key) => key.split("."));
+    const pattern = patterns.find((candidate) => candidate.length === keyParts.length &&
+        candidate.every((part, index) => part === "*" || part === keyParts[index]));
+    if (!pattern)
+        return `${providerId}.(other row)`;
+    const shown = pattern.map((part, index) => {
+        if (part !== "*")
+            return part;
+        const value = keyParts[index] ?? "";
+        const custom = providerId === "quota-providers" && index === 1 ? customs.get(value) : undefined;
+        return custom !== undefined ? `(custom ${custom})` : `(part ${parts(value)})`;
     });
-    const dbPath = getOpenCodeDbPath();
-    pathsRows.push({
-        key: "opencode.db",
-        value: `path=${dbPath} present=${(await pathExists(dbPath)) ? "true" : "false"} (session and token history)`,
+    return [providerId, ...shown].join(".");
+}
+/**
+ * The error in our own words, with its code and HTTP status: "Provider error 503
+ * (provider_error, http 503)". A local tool is named only when it is one this plugin knows.
+ */
+function errorText(error, providerId, nowMs) {
+    if (!isQuotaErrorCode(error.code))
+        return "(unknown error code)";
+    const tool = error.tool !== undefined && LOCAL_TOOLS.includes(error.tool) ? error.tool : undefined;
+    // A wait shows in minutes or hours: up to a week.
+    const retryAtMs = typeof error.retryAtMs === "number" && error.retryAtMs <= nowMs + 7 * 24 * 60 * 60 * 1000
+        ? error.retryAtMs
+        : undefined;
+    const known = {
+        code: error.code,
+        status: httpStatus(error.status),
+        retryAtMs,
+        tool,
+        missing: error.missing === true,
+    };
+    const label = PROVIDER_IDS.has(providerId)
+        ? getQuotaProviderDisplayLabel(providerId)
+        : "the provider";
+    return `${describeError(known, label, nowMs)} (${errorKind(known)})`;
+}
+/** "ok", or the error in our words; "partial" when rows came with the error. */
+function providerState(provider, nowMs) {
+    if (provider.checkedAtMs === undefined)
+        return provider.refreshing ? "checking" : "not checked";
+    const error = provider.error;
+    if (!error)
+        return "ok";
+    const words = errorText(error, provider.providerId, nowMs);
+    return provider.rows.length > 0 ? `partial: ${words}` : `error: ${words}`;
+}
+/** Shown as they are for any allowed key. */
+const NO_VALUES = new Set(["(none)", "(unknown)", "unknown"]);
+function oneOf(...values) {
+    const allowed = new Set(values);
+    return (value) => (allowed.has(value) ? value : undefined);
+}
+/** "a,b" when every item is one of `values`. */
+function listOf(values) {
+    const allowed = new Set(values);
+    return (value) => (value.split(",").every((item) => allowed.has(item)) ? value : undefined);
+}
+/** The same rule for each named key. */
+function each(rule, ...keys) {
+    return Object.fromEntries(keys.map((key) => [key, rule]));
+}
+const bool = oneOf("true", "false");
+/** An error or message key: that it is set, never its words. */
+const present = () => "(text not shown)";
+/** An error's text as our code and HTTP status ("provider_error, http 503"), never its words. */
+const errorKindOf = (value) => errorKind(classifyError(value));
+/** A failed login's kind as rows.ts wrote it ("provider_error, http 503"), checked again. */
+const writtenErrorKind = (value) => {
+    const match = /^([a-z_]+)(?:, http [1-5]\d{2})?$/u.exec(value);
+    return match && isQuotaErrorCode(match[1]) ? value : undefined;
+};
+/** Why a row was dropped (`validateRows`, `addRow`), never the row's own id. */
+const DROPPED_ROW_REASONS = new Set([
+    "not an object",
+    "wrong provider",
+    "no value",
+    "repeated row",
+    ...[
+        "id",
+        "label",
+        "type",
+        "method",
+        "authority",
+        "prominence",
+        "account",
+        "window",
+        "percentRemaining",
+        "used",
+        "limit",
+        "remaining",
+        "amount",
+        "flag",
+        "text",
+        "resetsAt",
+        "windowStartedAt",
+    ].map((field) => `invalid ${field}`),
+]);
+const droppedRow = (value) => {
+    const reason = value.slice(value.lastIndexOf(": ") + 2);
+    return DROPPED_ROW_REASONS.has(reason) ? reason : undefined;
+};
+/** A name the user chose (an organization, an enterprise): that it is set, never the name. */
+const setOrNot = (value) => (value.trim() ? "set" : "not set");
+/** A whole number from `min` to `max`, written with or without commas. */
+function whole(min, max) {
+    return (value) => {
+        const plain = value.replaceAll(",", "");
+        return /^\d+$/u.test(plain) ? inRange(Number(plain), min, max) : undefined;
+    };
+}
+/** Accounts, models and state versions: a few at most. */
+const count = whole(0, 999);
+const time = dateText;
+/** A month ("2026-10") from 2000 to 2099. */
+const month = (value) => {
+    if (!/^\d{4}-\d{2}$/u.test(value))
+        return undefined;
+    return dateText(`${value}-01`) === "(invalid date)" ? "(invalid date)" : value;
+};
+const version = versionText;
+const status = (value) => {
+    const shown = httpStatus(Number(value));
+    return shown === undefined ? undefined : String(shown);
+};
+/** A file path, or `env:NAME` for a variable its provider reads (`env:(other)` for any other). */
+function pathOrEnv(value, { homeDir, envNames }) {
+    if (!value.startsWith("env:"))
+        return pathText(value, homeDir);
+    return envNames.includes(value.slice(4)) ? value : "env:(other)";
+}
+/** Paths joined by " | ". */
+const pathList = (value, context) => value
+    .split(" | ")
+    .map((path) => pathOrEnv(path, context))
+    .join(" | ");
+/** Where an API key came from: `env:NAME`, a config file name, or a path. */
+const keySource = (value, context) => KEY_FILE_SOURCES.has(value) ? value : pathOrEnv(value, context);
+/** The Claude CLI's arguments this plugin passes. */
+const CLAUDE_ARGS = new Set(["--version", "auth", "status", "--json"]);
+/** Claude CLI command lines joined by " | ": the program as a path, then known arguments. */
+const claudeCommands = (value, { homeDir }) => value
+    .split(" | ")
+    .map((command) => {
+    const words = command.match(/"(?:[^"\\]|\\.)*"|[^\s"]+/gu) ?? [];
+    const [program = "", ...args] = words.map((word) => {
+        if (!word.startsWith('"'))
+            return word;
+        try {
+            return String(JSON.parse(word));
+        }
+        catch {
+            return "";
+        }
     });
-    appendProviderStatusDetailRows(pathsRows, "alibaba-coding-plan", params.providerLiveProbes, new Set([
-        "alibaba auth configured",
-        "alibaba_api_key_source",
-        "alibaba_api_key_checked_paths",
-        "alibaba_api_key_credential_database_paths",
-        "alibaba_coding_plan",
-        "alibaba_auth_error",
-    ]));
-    sections.push(createKvSection("paths", "paths:", pathsRows));
-    // === credential_source ===
-    const credentialSource = getCredentialSourceDiagnostics();
-    sections.push(createKvSection("credential_source", "credential_source:", [
-        {
-            key: "source",
-            value: credentialSource.state === "bound" ? credentialSource.kind : "unbound",
-        },
-        { key: "list_error", value: credentialSource.lastListError?.detail ?? "(none)" },
-        {
-            key: "failures",
-            value: joinOrNone(credentialSource.failures.map((failure) => [failure.integrationId, failure.label, failure.category, failure.detail]
-                .map((part) => sanitizeSingleLineDisplayText(part))
-                .join(":"))),
-        },
-    ]));
-    for (const [id, providerId] of [
-        ["openai", "openai"],
-        ["anthropic", "anthropic"],
-    ]) {
-        sections.push(createProviderStatusSection({
-            id,
-            title: `${id}:`,
-            providerId,
-            probes: params.providerLiveProbes,
-            availability: params.providerAvailability,
-            homeDir,
-        }));
+    const programText = program === "claude" ? "claude" : pathText(program, homeDir);
+    return [programText, ...args.map((arg) => (CLAUDE_ARGS.has(arg) ? arg : "(arg)"))].join(" ");
+})
+    .join(" | ");
+/**
+ * A value of `name=value` fields after an optional head word ("yes found=openai,codex"). Every
+ * part must pass its rule; a field rule may read the rest of a value (a path list).
+ */
+function fields(rules, head) {
+    const pattern = new RegExp(`(?:^| )(${Object.keys(rules).join("|")})=`, "gu");
+    return (value, context) => {
+        const matches = [...value.matchAll(pattern)];
+        const headText = value.slice(0, matches[0]?.index ?? value.length);
+        const shown = [];
+        if (headText) {
+            const text = head?.(headText, context);
+            if (text === undefined)
+                return undefined;
+            shown.push(text);
+        }
+        for (const [index, match] of matches.entries()) {
+            const name = match[1] ?? "";
+            const start = match.index + match[0].length;
+            const end = matches[index + 1]?.index ?? value.length;
+            const text = ruleValue(rules[name], value.slice(start, end), context);
+            if (text === undefined)
+                return undefined;
+            shown.push(`${name}=${text}`);
+        }
+        return shown.length > 0 ? shown.join(" ") : undefined;
+    };
+}
+function ruleValue(rule, value, context) {
+    if (!rule)
+        return undefined;
+    return NO_VALUES.has(value) ? value : rule(value, context);
+}
+/**
+ * How a provider that reads an API key (one with env variables) looked for it, as the key
+ * resolver writes it, with or without a stored login's state.
+ */
+const API_KEY_DETAILS = {
+    api_key_configured: oneOf("true", "false", "unreadable"),
+    api_key_source: keySource,
+    ...each(pathList, "api_key_checked_paths", "api_key_credential_database_paths"),
+    auth_state: oneOf("none", "configured", "invalid"),
+    auth_error: present,
+};
+/** Synthetic and Chutes write their key lookup as one value. */
+const KEY_SUMMARY = fields({ configured: bool, source: keySource, checked: pathList });
+const GOOGLE_DETAILS = {
+    auth_state: oneOf("missing", "present", "invalid"),
+    auth_source: oneOf(...AGY_AUTH_KEYS, ...GEMINI_CLI_AUTH_KEYS),
+    ...each(count, "account_count", "valid_account_count"),
+    companion_package_state: oneOf("present", "missing", "invalid"),
+    companion_package_path: pathList,
+    auth_error: present,
+};
+const STATE_HEALTH = ["missing", "healthy", "malformed", "version_mismatch"];
+const CONSOLE_AUTH_STATES = ["none", "configured", "expired", "invalid"];
+/**
+ * The debug details each provider's section may show besides its setup and API-key details,
+ * by key; every other one is counted.
+ */
+const DEBUG_DETAILS = {
+    anthropic: {
+        ...each(bool, "cli_installed", "quota_supported"),
+        cli_version: version,
+        binary_path: (value, { homeDir }) => value === "claude (PATH)" ? value : pathText(value, homeDir),
+        auth_status: oneOf("authenticated", "unauthenticated", "unknown"),
+        quota_source: oneOf("claude-auth-status-json", "claude-credentials-oauth-api", "opencode-auth-oauth-api"),
+        oauth_credential_source: oneOf("opencode-auth", "claude-credentials"),
+        checked_commands: claudeCommands,
+    },
+    copilot: {
+        pat_state: oneOf("absent", "invalid", "valid"),
+        ...each(pathList, "pat_path", "pat_checked_paths"),
+        pat_token_kind: oneOf("github_pat", "ghp", "ghu", "ghs", "other"),
+        pat_tier: oneOf("free", "student", "pro", "pro+", "max", "business", "enterprise"),
+        ...each(setOrNot, "pat_organization", "pat_enterprise"),
+        billing_model: oneOf("ai_credits", "legacy_premium_requests"),
+        deployment: oneOf("github.com", "ghe.com", "invalid", "none"),
+        api_host: (value) => (value === "api.github.com" ? value : "github enterprise (custom host)"),
+        ...each(oneOf("pat", "oauth", "none"), "enterprise_host_source", "effective_source"),
+        billing_mode: oneOf("user_quota", "organization_usage", "enterprise_usage", "none"),
+        billing_scope: oneOf("user", "organization", "enterprise", "none"),
+        quota_api: oneOf("github_ai_credit_api", "github_legacy_premium_request_api", "copilot_internal_user", "none"),
+        budget_api: oneOf("organization_budgets", "enterprise_budgets", "not_available"),
+        billing_api_access_likely: bool,
+        remaining_totals_state: oneOf("available", "value_only_without_denominator", "not_available_from_org_usage", "not_available_from_enterprise_usage", "reported_by_copilot_internal_user", "unavailable"),
+        billing_period: month,
+        oauth_configured: fields({ key: oneOf(...COPILOT_AUTH_KEYS), refresh: bool, access: bool, enterprise_host: bool }, bool),
+        oauth_accounting_state: oneOf("available_via_copilot_internal_user", "invalid_enterprise_host", "not_configured"),
+        override: oneOf("pat_overrides_oauth", "none"),
+    },
+    openai: {
+        auth_configured: bool,
+        auth_source: oneOf(...OPENAI_AUTH_SOURCE_KEYS, ...OPENCODE_PROVIDER_IDS),
+        auth_method: oneOf("chatgpt-token-sharing"),
+        token_status: oneOf("api key", "failed", "expired", "valid"),
+        token_expires_at: time,
+    },
+    kilo: { accounting_mode: oneOf("kilo_pass", "gateway_balance"), reset_at: time },
+    cursor: {
+        plan: oneOf("Pro", "Pro Plus", "Ultra", "none"),
+        billing_cycle_start_day: (value, context) => value === "(calendar month)" ? value : whole(1, 31)(value, context),
+        auth_state: oneOf("missing", "present", "invalid"),
+        auth_error: present,
+        auth_selected_path: keySource,
+        ...each(pathList, "auth_present_paths", "auth_candidate_paths"),
+        ...each(pathList, "config_matches", "config_checked_paths"),
+        ...each(bool, "plugin_enabled", "provider_configured"),
+        canonical_plugin_package: oneOf(CURSOR_CANONICAL_PLUGIN_PACKAGE),
+        cycle_source: oneOf("configured_day", "calendar_month"),
+        cycle_reset_at: time,
+        unknown_cursor_models: count,
+    },
+    "alibaba-coding-plan": {
+        ...each(bool, "alibaba auth configured", "local_state_exists"),
+        alibaba_api_key_source: keySource,
+        ...each(pathList, "alibaba_api_key_checked_paths", "local_state_path"),
+        alibaba_api_key_credential_database_paths: pathList,
+        alibaba_coding_plan: oneOf("lite", "pro", "invalid"),
+        local_state_health: oneOf(...STATE_HEALTH),
+        local_state_version: count,
+        local_state_last_update: time,
+    },
+    "alibaba-token-plan": {
+        cli_available: bool,
+        // The provider writes the platform this report runs on.
+        platform: oneOf(process.platform),
+        windows: listOf(["5h", "weekly"]),
+        failure_kind: oneOf(...Object.keys(ALIBABA_TOKEN_PLAN_ERRORS)),
+    },
+    synthetic: { api_key_diagnostics: KEY_SUMMARY },
+    chutes: { api_key_diagnostics: KEY_SUMMARY },
+    "google-gemini-cli": GOOGLE_DETAILS,
+    "google-agy": GOOGLE_DETAILS,
+    nanogpt: {
+        ...each(bool, "subscription_active", "enforce_daily_limit"),
+        subscription_state: oneOf("active", "grace", "inactive"),
+        ...each(time, "billing_period_end", "grace_until"),
+        ...each(errorKindOf, "live_error_usage", "live_error_balance"),
+    },
+    "minimax-coding-plan": { api_endpoint: oneOf("international", "china") },
+    "minimax-china-coding-plan": { api_endpoint: oneOf("international", "china") },
+    "kimi-code-plan-global": { api_endpoint: oneOf("global", "cn") },
+    "kimi-code-plan-cn": { api_endpoint: oneOf("global", "cn") },
+    xiaomi: {
+        config_state: oneOf("none", "configured", "invalid"),
+        config_source: keySource,
+        config_checked_paths: pathList,
+    },
+    "opencode-go": {
+        auth_source: keySource,
+        ...each(pathList, "auth_checked_paths", "credential_database_paths"),
+        console_auth_state: oneOf(...CONSOLE_AUTH_STATES),
+        console_error: present,
+        go_source: oneOf("console", "legacy_key"),
+        opencode_go_state: oneOf("not_subscribed"),
+        selected_windows: listOf(["rolling", "weekly", "monthly"]),
+    },
+    "ollama-cloud": {
+        ...each(time, "included_period_from", "included_period_until", "session_resets_at", "weekly_resets_at"),
+    },
+    opencode: {
+        console_auth_state: oneOf(...CONSOLE_AUTH_STATES),
+        budget_source: oneOf("member_budget", "credit_limit"),
+        member_budget_note: oneOf(MEMBER_BUDGET_NOTE),
+        auto_reload: bool,
+    },
+};
+/**
+ * Every section may show whether OpenCode lists the provider ("yes found=openai"), the kind of
+ * an error a check noted, and why a row was dropped.
+ */
+const SETUP_DETAILS = {
+    opencode_provider: fields({ found: listOf(OPENCODE_PROVIDER_IDS), looked_for: listOf(OPENCODE_PROVIDER_IDS) }, oneOf("yes", "no", "unreadable")),
+    error_kind: writtenErrorKind,
+    live_fetch_error: errorKindOf,
+    dropped_row: droppedRow,
+};
+/** A numbered live error ("live_error_1"), shown as its kind like `live_fetch_error`. */
+const LIVE_ERROR_KEY = /^live_error_\d{1,2}$/u;
+/** A custom definition's check: outcome, login source, files read, local counter state. */
+const CUSTOM_CHECK = fields({
+    outcome: oneOf("missing_credential", "success", "http_error", "redirect_error", "timeout", "body_too_large", "invalid_content_type", "invalid_json", "invalid_response", "network_error", "local_state_error"),
+    http_status: status,
+    credential_source: oneOf("explicit_env", "global_opencode_json", "global_opencode_jsonc", "opencode_db"),
+    checked_paths: pathList,
+    state_health: oneOf(...STATE_HEALTH),
+    state_version: count,
+    state_last_update: time,
+});
+/** "custom 2 check" for the debug key of the second custom definition's check. */
+function customCheckKey(key, customs) {
+    const id = /^custom_(.+)_check$/su.exec(key)?.[1];
+    const number = id === undefined ? undefined : customs.get(id);
+    return number === undefined ? undefined : `custom ${number} check`;
+}
+/** The debug details the provider's allow list has, and a count of the others. */
+function debugRows(provider, customs, homeDir) {
+    const id = provider.providerId;
+    const envNames = Object.hasOwn(KEY_VENDORS, id) ? (KEY_VENDORS[id]?.envVars ?? []) : [];
+    const rules = {
+        ...SETUP_DETAILS,
+        ...(envNames.length > 0 ? API_KEY_DETAILS : {}),
+        ...(PROVIDER_IDS.has(id) ? DEBUG_DETAILS[id] : {}),
+    };
+    const context = { homeDir, envNames };
+    const rows = [];
+    let hidden = 0;
+    for (const item of provider.debug) {
+        // A failed login's own words: its `error_kind` detail, made with it, shows its kind.
+        if (item.key === "error")
+            continue;
+        const customKey = customCheckKey(item.key, customs);
+        const rule = customKey
+            ? CUSTOM_CHECK
+            : Object.hasOwn(rules, item.key)
+                ? rules[item.key]
+                : LIVE_ERROR_KEY.test(item.key)
+                    ? errorKindOf
+                    : undefined;
+        const value = ruleValue(rule, item.value, context);
+        if (value === undefined)
+            hidden += 1;
+        else
+            rows.push({ key: customKey ?? item.key, value });
     }
-    // === cursor ===
-    const cursorRows = [];
-    appendProviderStatusDetailRows(cursorRows, "cursor", params.providerLiveProbes);
-    appendProviderStatusDetailRows(cursorRows, "alibaba-coding-plan", params.providerLiveProbes, new Set(["alibaba coding plan local quota", "alibaba coding plan error"]));
-    appendProviderCompactLiveProbeRows(cursorRows, "cursor", params.providerLiveProbes, params.providerAvailability, homeDir);
-    sections.push(createKvSection("cursor", "cursor:", cursorRows));
-    const alibabaCodingPlanLiveProbeSection = createCompactLiveProbeOnlySection({
-        id: "alibaba_coding_plan",
-        title: "alibaba_coding_plan:",
-        providerId: "alibaba-coding-plan",
-        probes: params.providerLiveProbes,
-        availability: params.providerAvailability,
-        homeDir,
-    });
-    if (alibabaCodingPlanLiveProbeSection) {
-        sections.push(alibabaCodingPlanLiveProbeSection);
+    if (hidden > 0) {
+        rows.push({ key: countText(hidden, "other detail not shown", "other details not shown") });
     }
-    const alibabaTokenPlanLiveProbeSection = createCompactLiveProbeOnlySection({
-        id: "alibaba_token_plan",
-        title: "alibaba_token_plan:",
-        providerId: "alibaba-token-plan",
-        probes: params.providerLiveProbes,
-        availability: params.providerAvailability,
-        homeDir,
-    });
-    if (alibabaTokenPlanLiveProbeSection) {
-        sections.push(alibabaTokenPlanLiveProbeSection);
+    return rows;
+}
+/**
+ * "disabled" (turned off in the settings, never fetched) and "unavailable" (only local setup
+ * details) win over the state of a check. With "auto" no provider is turned off; with a list,
+ * `availability.enabled` says whether the provider is in it.
+ */
+function sectionState(availability, provider, enabledProviders, nowMs) {
+    if (enabledProviders !== "auto" && !availability.enabled)
+        return "disabled";
+    if (!availability.available)
+        return "unavailable";
+    return provider ? providerState(provider, nowMs) : "not checked";
+}
+/**
+ * One provider's section, the same for every provider: state, rows, debug details. Rows show
+ * their ledger id, an account number and their facts; debug details show when their provider
+ * allows them, and the rest are counted.
+ */
+function providerSection(availability, provider, params, homeDir) {
+    const nowMs = params.generatedAtMs ?? Date.now();
+    const state = sectionState(availability, provider, params.enabledProviders, nowMs);
+    const title = providerIdText(availability.id);
+    const rows = [{ key: "state", value: state }];
+    if (!provider)
+        return kvSection(title, rows);
+    if (provider.checkedAtMs !== undefined) {
+        const lastRows = provider.okAtMs !== undefined && provider.okAtMs !== provider.checkedAtMs
+            ? ` (rows from ${isoText(provider.okAtMs)})`
+            : "";
+        rows.push({ key: "checked_at", value: `${isoText(provider.checkedAtMs)}${lastRows}` });
     }
-    for (const section of [
-        { id: "minimax", title: "minimax:", providerId: "minimax-coding-plan" },
-        {
-            id: "minimax_china",
-            title: "minimax_china:",
-            providerId: "minimax-china-coding-plan",
-        },
-        { id: "kimi", title: "kimi:", providerId: "kimi-code-plan-global" },
-        { id: "kimi_cn", title: "kimi_cn:", providerId: "kimi-code-plan-cn" },
-        {
-            id: "opencode_go",
-            title: "opencode_go:",
-            providerId: "opencode-go",
-            detailKeys: OPENCODE_GO_STATUS_DETAIL_KEYS,
-        },
-        { id: "opencode_zen", title: "opencode_zen:", providerId: "opencode" },
-        { id: "xiaomi", title: "xiaomi:", providerId: "xiaomi" },
-        { id: "zai", title: "zai:", providerId: "zai" },
-        { id: "zhipu", title: "zhipu:", providerId: "zhipu" },
-        { id: "synthetic", title: "synthetic:", providerId: "synthetic" },
-        { id: "chutes", title: "chutes:", providerId: "chutes" },
-        { id: "deepseek", title: "deepseek:", providerId: "deepseek" },
-        { id: "xai", title: "xai:", providerId: "xai", includeDetails: false },
-        { id: "nanogpt", title: "nanogpt:", providerId: "nanogpt" },
-        { id: "openrouter", title: "openrouter:", providerId: "openrouter" },
-        {
-            id: "copilot_quota_auth",
-            title: "copilot_quota_auth:",
-            providerId: "copilot",
-        },
-    ]) {
-        sections.push(createProviderStatusSection({
-            ...section,
-            probes: params.providerLiveProbes,
-            availability: params.providerAvailability,
-            homeDir,
-        }));
+    rows.push({ key: "rows", value: String(provider.rows.length) });
+    // An account is a login's label (often an email address): it shows as its number.
+    const account = numbering();
+    const part = numbering();
+    const customs = customNumbers(params);
+    for (const row of provider.rows.slice(0, ROW_LIST_LIMIT)) {
+        const accountText = row.account ? ` (account ${account(row.account)})` : "";
+        const id = rowIdText(row, part, customs);
+        rows.push({ key: `${id}${accountText}`, value: rowFacts(row), indent: 1 });
     }
-    if (findProviderLiveProbe("kilo", params.providerLiveProbes)) {
-        sections.push(createProviderStatusSection({
-            id: "kilo",
-            title: "kilo:",
-            providerId: "kilo",
-            probes: params.providerLiveProbes,
-            availability: params.providerAvailability,
-            homeDir,
-        }));
+    if (provider.rows.length > ROW_LIST_LIMIT) {
+        rows.push({ key: `… (${provider.rows.length - ROW_LIST_LIMIT} more)`, indent: 1 });
     }
-    for (const [id, providerId] of [
-        ["google_gemini_cli", "google-gemini-cli"],
-        ["google_agy", "google-agy"],
-    ]) {
-        sections.push(createProviderStatusSection({
-            id,
-            title: `${id}:`,
-            providerId,
-            probes: params.providerLiveProbes,
-            availability: params.providerAvailability,
-            homeDir,
-        }));
+    rows.push(...debugRows(provider, customs, homeDir));
+    return kvSection(title, rows);
+}
+/** "openai/gpt-5" when OpenCode or the shipped price list knows both ids, else undefined. */
+function knownModelText(providerId, modelId) {
+    const knownProvider = OPENCODE_PROVIDER_IDS.has(providerId) || isBundledPricingProviderId(providerId);
+    return knownProvider && isBundledPricingModelId(modelId) ? `${providerId}/${modelId}` : undefined;
+}
+/**
+ * The models of the last 30 days without a price: their tokens add no cost. A model shows when
+ * the shipped price list has its id; the others are counted.
+ */
+function unpricedRows(usage) {
+    if (!usage)
+        return [{ key: "unpriced_30d", value: "(the usage history could not be read)" }];
+    const { totals } = usage;
+    if (totals.tokens.processed === 0)
+        return [{ key: "unpriced_30d", value: "(no usage)" }];
+    const summary = `${formatShare(totals.unpricedShare)} of ${formatTokens(totals.tokens.processed)} tokens`;
+    const unpriced = usage.models.filter((model) => !model.priced);
+    const rows = [{ key: "unpriced_30d", value: summary }];
+    const listed = unpriced
+        .map((model) => ({ model, name: knownModelText(model.providerID, model.modelID) }))
+        .filter((item) => item.name !== undefined)
+        .slice(0, UNPRICED_LIST_LIMIT);
+    for (const { model, name } of listed) {
+        rows.push({
+            key: name ?? "",
+            value: `${formatTokens(model.unpricedTokens)} tokens`,
+            indent: 1,
+        });
     }
-    // === session token errors ===
-    if (params.sessionTokenError) {
-        const sessionTokenErrorRows = [
-            { key: "session_id", value: params.sessionTokenError.sessionID },
-            { key: "error", value: params.sessionTokenError.error },
-        ];
-        if (params.sessionTokenError.checkedPath) {
-            sessionTokenErrorRows.push({
-                key: "checked_path",
-                value: params.sessionTokenError.checkedPath,
-            });
-        }
-        sections.push(createKvSection("session_tokens_error", "session_tokens_error:", sessionTokenErrorRows));
+    const others = unpriced.length - listed.length;
+    if (others > 0) {
+        const text = countText(others, "more unpriced model", "more unpriced models");
+        rows.push({ key: `… (${text})`, indent: 1 });
     }
-    // === storage scan ===
-    const dbStats = await getOpenCodeDbStats();
-    sections.push(createKvSection("storage", "storage:", [
-        { key: "sessions_in_db", value: fmtInt(dbStats.sessionCount) },
-        { key: "messages_in_db", value: fmtInt(dbStats.messageCount) },
-        { key: "assistant_messages_in_db", value: fmtInt(dbStats.assistantMessageCount) },
-    ]));
-    // === pricing snapshot ===
-    const agg = await aggregateUsage({});
+    return rows;
+}
+const PRICING_UNITS = "USD per 1M tokens";
+const PRICING_SOURCE_NAMES = {
+    bundled: "bundled",
+    runtime: "downloaded",
+};
+const PRICING_SELECTIONS = new Set(["auto", "bundled", "runtime"]);
+/** The active price list as fixed words: where it came from, its date and its units. */
+export function publicPricingMeta() {
     const meta = getPricingSnapshotMeta();
-    const providers = listProviders();
-    const coverage = computePricingCoverageFromAgg(agg);
-    const refreshPolicy = getPricingRefreshPolicy();
-    const autoRefreshDays = Math.round(refreshPolicy.maxAgeMs / (24 * 60 * 60 * 1000));
-    const health = getPricingSnapshotHealth({
-        maxAgeMs: refreshPolicy.maxAgeMs,
-    });
-    const snapshotSource = getPricingSnapshotSource();
-    const runtimeSnapshotPath = getRuntimePricingSnapshotPath();
-    const refreshStatePath = getRuntimePricingRefreshStatePath();
-    const pricingRefreshState = await readPricingRefreshState();
-    const pricingRows = [
+    return {
+        source: PRICING_SOURCE_NAMES[getPricingSnapshotSource()] ?? "unknown",
+        generatedAt: isoText(meta.generatedAt),
+        units: meta.units === PRICING_UNITS ? PRICING_UNITS : "(other units)",
+    };
+}
+async function pricingSection(params, homeDir) {
+    const meta = publicPricingMeta();
+    const activeSource = getPricingSnapshotSource();
+    const { maxAgeMs } = getPricingRefreshPolicy();
+    const health = getPricingSnapshotHealth({ maxAgeMs });
+    const refreshState = await readPricingRefreshState();
+    const configured = PRICING_SELECTIONS.has(params.pricingSnapshotSource)
+        ? params.pricingSnapshotSource
+        : "(other)";
+    const rows = [
         {
             key: "pricing",
-            value: `source=${meta.source} active_source=${snapshotSource} generated_at=${new Date(meta.generatedAt).toISOString()} units=${meta.units}`,
-        },
-        {
-            key: "selection",
-            value: `configured=${params.pricingSnapshotSource} active=${snapshotSource}`,
+            value: `source=${meta.source} generated_at=${meta.generatedAt} units=${meta.units}`,
         },
+        { key: "providers.pricing.source", value: `configured=${configured} active=${meta.source}` },
     ];
-    if (params.pricingSnapshotSource === "bundled") {
-        pricingRows.push({
+    if (configured === "bundled") {
+        rows.push({
             key: "selection_note",
-            value: "bundled config pins the packaged snapshot and ignores runtime refresh for active pricing",
+            value: "bundled: the built-in price list is used and downloaded prices are ignored",
         });
     }
-    else if (params.pricingSnapshotSource === "runtime" && snapshotSource !== "runtime") {
-        pricingRows.push({
+    else if (configured === "runtime" && activeSource !== "runtime") {
+        rows.push({
             key: "selection_note",
-            value: "runtime config requested the local runtime snapshot, but bundled fallback is active because no valid runtime snapshot is available",
+            value: "runtime: no valid downloaded price list, so the built-in one is used",
         });
     }
-    pricingRows.push({
+    rows.push({
         key: "runtime_paths",
-        value: `snapshot=${runtimeSnapshotPath} refresh_state=${refreshStatePath}`,
-    });
-    pricingRows.push({
+        value: `snapshot=${pathText(getRuntimePricingSnapshotPath(), homeDir)} refresh_state=${pathText(getRuntimePricingRefreshStatePath(), homeDir)}`,
+    }, {
         key: "staleness",
-        value: `age_ms=${fmtInt(health.ageMs)} max_age_ms=${fmtInt(health.maxAgeMs)} stale=${health.stale ? "true" : "false"}`,
-    });
-    pricingRows.push({
-        key: "refresh_policy",
-        value: `auto_refresh_days=${fmtInt(autoRefreshDays)}`,
+        value: `age_ms=${msText(health.ageMs)} max_age_ms=${msText(health.maxAgeMs)} stale=${health.stale === true}`,
+    }, {
+        key: "providers.pricing.autoRefreshDays",
+        value: inRange(Math.round(maxAgeMs / DAY_MS), 1, MAX_REFRESH_DAYS),
     });
-    if (pricingRefreshState) {
-        pricingRows.push({
+    if (refreshState) {
+        // The reader keeps only the results it knows.
+        const result = refreshState.lastResult ?? "(none)";
+        rows.push({
             key: "refresh",
-            value: `last_attempt_at=${pricingRefreshState.lastAttemptAt ? new Date(pricingRefreshState.lastAttemptAt).toISOString() : "(none)"} last_success_at=${pricingRefreshState.lastSuccessAt ? new Date(pricingRefreshState.lastSuccessAt).toISOString() : "(none)"} last_failure_at=${pricingRefreshState.lastFailureAt ? new Date(pricingRefreshState.lastFailureAt).toISOString() : "(none)"} last_result=${pricingRefreshState.lastResult ?? "(none)"}`,
+            value: `last_attempt_at=${isoText(refreshState.lastAttemptAt)} last_success_at=${isoText(refreshState.lastSuccessAt)} last_failure_at=${isoText(refreshState.lastFailureAt)} last_result=${result}`,
         });
-        if (pricingRefreshState.lastError) {
-            pricingRows.push({ key: "refresh_error", value: pricingRefreshState.lastError });
+        if (refreshState.lastError) {
+            rows.push({ key: "refresh_error", value: errorKind(classifyError(refreshState.lastError)) });
         }
     }
     else {
-        pricingRows.push({ key: "refresh", value: "(no runtime refresh state yet)" });
+        rows.push({ key: "refresh", value: "(no runtime refresh state yet)" });
     }
-    pricingRows.push({ key: "providers", value: providers.join(",") });
-    pricingRows.push({
-        key: "coverage_seen",
-        value: `priced_keys=${fmtInt(coverage.totals.pricedKeysSeen)} mapped_but_missing=${fmtInt(coverage.totals.mappedMissingKeysSeen)} unpriced_keys=${fmtInt(coverage.totals.unpricedKeysSeen)}`,
-    });
-    for (const p of providers) {
-        const c = coverage.byProvider.get(p) ?? {
-            pricedKeysSeen: 0,
-            mappedMissingKeysSeen: 0,
-            unpricedKeysSeen: 0,
-        };
-        pricingRows.push({
-            key: p,
-            value: `models=${fmtInt(getProviderModelCount(p))} priced_models_seen=${fmtInt(c.pricedKeysSeen)} mapped_but_missing_models_seen=${fmtInt(c.mappedMissingKeysSeen)} unpriced_models_seen=${fmtInt(c.unpricedKeysSeen)}`,
-            indent: 1,
-        });
-    }
-    sections.push(createKvSection("pricing_snapshot", "pricing_snapshot:", pricingRows));
-    // === supported providers pricing ===
-    const supported = getProviders().map((p) => p.id);
-    const supportedRows = supported.map((id) => {
-        const row = supportedProviderPricingRow({ id, agg, snapshotProviders: providers });
-        return {
-            key: row.id,
-            value: `pricing=${row.pricing} (${row.notes})`,
-        };
-    });
-    sections.push(createKvSection("supported_providers_pricing", "supported_providers_pricing:", supportedRows));
-    // === unpriced models ===
-    const unpricedRows = [];
-    if (agg.unpriced.length === 0) {
-        unpricedRows.push({ key: "none" });
-    }
-    else {
-        unpricedRows.push({
-            key: "keys",
-            value: `${fmtInt(agg.unpriced.length)} tokens_total=${fmtInt(totalTokenBuckets(agg.totals.unpriced))}`,
-        });
-        for (const row of agg.unpriced.slice(0, STATUS_SAMPLE_LIMIT)) {
-            const src = `${row.key.sourceProviderID}/${row.key.sourceModelID}`;
-            const mapped = `${row.key.mappedProvider}/${row.key.mappedModel}`;
-            unpricedRows.push({
-                key: src,
-                value: `mapped=${mapped} tokens=${fmtInt(totalTokenBuckets(row.tokens))} msgs=${fmtInt(row.messageCount)} reason=${row.key.reason}`,
-            });
-        }
-        if (agg.unpriced.length > STATUS_SAMPLE_LIMIT) {
-            unpricedRows.push({ key: `… (${fmtInt(agg.unpriced.length - STATUS_SAMPLE_LIMIT)} more)` });
-        }
-    }
-    sections.push(createKvSection("unpriced_models", "unpriced_models:", unpricedRows));
-    // === unknown pricing ===
-    const unknownRows = [];
-    if (agg.unknown.length === 0) {
-        unknownRows.push({ key: "none" });
-    }
-    else {
-        unknownRows.push({
-            key: "keys",
-            value: `${fmtInt(agg.unknown.length)} tokens_total=${fmtInt(totalTokenBuckets(agg.totals.unknown))}`,
-        });
-        for (const row of agg.unknown.slice(0, STATUS_SAMPLE_LIMIT)) {
-            const src = `${row.key.sourceProviderID}/${row.key.sourceModelID}`;
-            const mappedBase = row.key.mappedProvider && row.key.mappedModel
-                ? `${row.key.mappedProvider}/${row.key.mappedModel}`
-                : "(none)";
-            const candidates = row.key.providerCandidates && row.key.providerCandidates.length > 0
-                ? ` candidates=${row.key.providerCandidates.join(",")}`
-                : "";
-            unknownRows.push({
-                key: src,
-                value: `mapped=${mappedBase}${candidates} tokens=${fmtInt(totalTokenBuckets(row.tokens))} msgs=${fmtInt(row.messageCount)}`,
-            });
-        }
-        if (agg.unknown.length > STATUS_SAMPLE_LIMIT) {
-            unknownRows.push({ key: `… (${fmtInt(agg.unknown.length - STATUS_SAMPLE_LIMIT)} more)` });
-        }
-    }
-    sections.push(createKvSection("unknown_pricing", "unknown_pricing:", unknownRows));
-    // Users paste this report into public issues: show the home dir as "~" in every path
-    // so it does not reveal their computer's user name.
+    rows.push({ key: "price_list_providers", value: fmtInt(listProviders().length) }, ...unpricedRows(params.usage));
+    return kvSection("pricing_snapshot", rows);
+}
+/** A path as the report shows it, for the status payload. */
+export function statusPathText(path, homeDir = homedir()) {
+    return pathText(path, homeDir);
+}
+/** The provider ids this plugin knows, for the status payload. */
+export function knownProviderIds(ids) {
+    return ids === "auto" ? ids : ids.filter((id) => PROVIDER_IDS.has(id));
+}
+export async function buildQuotaStatusReport(params) {
+    return renderPlainTextReport(await buildQuotaStatusReportDocument(params));
+}
+export async function buildQuotaStatusReportDocument(params) {
+    const homeDir = params.homeDir ?? homedir();
+    const pluginVersion = (await getPackageVersion()) ?? "unknown";
+    const snapshots = new Map(params.providers.map((provider) => [provider.providerId, provider]));
+    const sections = [
+        environmentSection(params, params.generatedAtMs ?? Date.now()),
+        settingsSection(params, homeDir),
+        providerListSection(params.providerAvailability),
+        ...(params.maintainerAnnouncements ? [noticesSection(params.maintainerAnnouncements)] : []),
+        await pathsSection(homeDir),
+        credentialSourceSection(params.credentialSource),
+        ...params.providerAvailability.map((availability) => providerSection(availability, snapshots.get(availability.id), params, homeDir)),
+        await pricingSection(params, homeDir),
+    ];
     return replaceHomeDirWithTildeInDocument({
-        heading: commandHeading({
-            title: `Quota Status (opencode-quota v${v}) (/quota_status)`,
-            detail: `opencode-quota v${v}`,
-            generatedAtMs: params.generatedAtMs,
-        }),
+        heading: `# Quota Status (opencode-quota v${pluginVersion})`,
         sections,
     }, homeDir);
 }