@slkiser/opencode-quota 3.2.0 → 3.3.0

package/dist/lib/config.js

@@ -3,25 +3,62 @@
  *
  * Precedence model:
  * - Global/user config provides defaults.
- * - Project/workspace config may override display-oriented settings for the current project.
- * - Global/user config remains authoritative for automatic/network-affecting settings.
- * - SDK config is used only as a fallback when no config files are found.
+ * - Workspace config at the resolved config root overrides ordinary settings.
+ * - SDK config is used only as a fallback when no file-backed config exists.
  */
 import { DEFAULT_CONFIG } from "./types.js";
 import { isQuotaFormatStyle, resolveQuotaFormatStyle } from "./quota-format-style.js";
 import { parseJsonOrJsonc } from "./jsonc.js";
-import { normalizeQuotaProviderId } from "./provider-metadata.js";
+import { getQuotaProviderShape, normalizeQuotaProviderId } from "./provider-metadata.js";
 import { existsSync } from "fs";
 import { readFile } from "fs/promises";
 import { join } from "path";
 import { getOpencodeRuntimeDirCandidates } from "./opencode-runtime-paths.js";
+export const QUOTA_TOAST_SETTING_SOURCE_KEYS = [
+    "enabled",
+    "enableToast",
+    "formatStyle",
+    "percentDisplayMode",
+    "minIntervalMs",
+    "debug",
+    "enabledProviders",
+    "anthropicBinaryPath",
+    "googleModels",
+    "alibabaCodingPlanTier",
+    "cursorPlan",
+    "cursorIncludedApiUsd",
+    "cursorBillingCycleStartDay",
+    "pricingSnapshot.source",
+    "pricingSnapshot.autoRefresh",
+    "showOnIdle",
+    "showOnQuestion",
+    "showOnCompact",
+    "showOnBothFail",
+    "toastDurationMs",
+    "onlyCurrentModel",
+    "showSessionTokens",
+    "layout.maxWidth",
+    "layout.narrowAt",
+    "layout.tinyAt",
+];
 export function createLoadConfigMeta() {
-    return { source: "defaults", paths: [], networkSettingSources: {} };
+    return {
+        source: "defaults",
+        paths: [],
+        globalConfigPaths: [],
+        workspaceConfigPaths: [],
+        settingSources: {},
+        networkSettingSources: {},
+        configIssues: [],
+    };
 }
-const NETWORK_AFFECTING_KEYS = [
+const CONFIG_FILENAMES = ["opencode.json", "opencode.jsonc"];
+const NETWORK_SETTING_SOURCE_KEYS = [
     "enabled",
     "enabledProviders",
     "minIntervalMs",
+    "pricingSnapshot.source",
+    "pricingSnapshot.autoRefresh",
     "showOnIdle",
     "showOnQuestion",
     "showOnCompact",
@@ -40,8 +77,7 @@ function isValidGoogleModelId(id) {
     return typeof id === "string" && ["G3PRO", "G3FLASH", "CLAUDE", "G3IMAGE"].includes(id);
 }
 function isValidCursorQuotaPlan(plan) {
-    return (typeof plan === "string" &&
-        ["none", "pro", "pro-plus", "ultra"].includes(plan));
+    return (typeof plan === "string" && ["none", "pro", "pro-plus", "ultra"].includes(plan));
 }
 function isValidPricingSnapshotSource(source) {
     return typeof source === "string" && ["auto", "bundled", "runtime"].includes(source);
@@ -52,6 +88,15 @@ function isValidPricingSnapshotAutoRefresh(value) {
 function isValidPercentDisplayMode(value) {
     return value === "remaining" || value === "used";
 }
+function isValidAlibabaCodingPlanTier(value) {
+    return value === "lite" || value === "pro";
+}
+function isPositiveNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function isValidCursorBillingCycleStartDay(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 28;
+}
 function normalizeOptionalString(value) {
     if (typeof value !== "string") {
         return undefined;
@@ -78,54 +123,332 @@ function getConfiguredFormatStyle(quotaToastConfig) {
 function dedupe(list) {
     return [...new Set(list)];
 }
-const NETWORK_SETTING_SOURCE_KEYS = [
-    "enabled",
-    "enabledProviders",
-    "minIntervalMs",
-    "pricingSnapshot.source",
-    "pricingSnapshot.autoRefresh",
-    "showOnIdle",
-    "showOnQuestion",
-    "showOnCompact",
-    "showOnBothFail",
-];
-function resolveEffectiveNetworkSettingSources(params) {
-    const resolved = {};
-    for (const key of NETWORK_SETTING_SOURCE_KEYS) {
-        if (typeof params.globalSources[key] === "string" && params.globalSources[key].length > 0) {
-            resolved[key] = params.globalSources[key];
+function cloneDefaultConfig() {
+    return {
+        ...DEFAULT_CONFIG,
+        enabledProviders: Array.isArray(DEFAULT_CONFIG.enabledProviders)
+            ? [...DEFAULT_CONFIG.enabledProviders]
+            : DEFAULT_CONFIG.enabledProviders,
+        googleModels: [...DEFAULT_CONFIG.googleModels],
+        pricingSnapshot: { ...DEFAULT_CONFIG.pricingSnapshot },
+        layout: { ...DEFAULT_CONFIG.layout },
+    };
+}
+function describeInvalidProviderValue(value) {
+    return typeof value === "string" ? value : typeof value;
+}
+function normalizeEnabledProviders(value) {
+    if (value === "auto") {
+        return { value: "auto", issues: [] };
+    }
+    if (!Array.isArray(value)) {
+        return {
+            value: [],
+            issues: ["expected \"auto\" or an array of provider ids"],
+            invalidEmpty: true,
+        };
+    }
+    if (value.length === 0) {
+        return { value: [], issues: [] };
+    }
+    const validProviders = [];
+    const invalidProviders = [];
+    for (const provider of value) {
+        if (typeof provider !== "string") {
+            invalidProviders.push(describeInvalidProviderValue(provider));
+            continue;
+        }
+        const normalized = normalizeQuotaProviderId(provider);
+        if (normalized && getQuotaProviderShape(normalized)) {
+            validProviders.push(normalized);
+        }
+        else {
+            invalidProviders.push(provider);
+        }
+    }
+    const issues = invalidProviders.length
+        ? [`unknown provider id(s): ${dedupe(invalidProviders).join(", ")}`]
+        : [];
+    const normalizedProviders = dedupe(validProviders);
+    return {
+        value: normalizedProviders,
+        issues,
+        invalidEmpty: normalizedProviders.length === 0 && invalidProviders.length > 0,
+    };
+}
+function normalizeGoogleModels(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const models = value.filter(isValidGoogleModelId);
+    return models.length > 0 ? models : undefined;
+}
+function extractPricingSnapshotPatch(value) {
+    if (!isPlainObject(value)) {
+        return undefined;
+    }
+    const patch = {};
+    if (hasOwnKey(value, "source") && isValidPricingSnapshotSource(value.source)) {
+        patch.source = value.source;
+    }
+    if (hasOwnKey(value, "autoRefresh") && isValidPricingSnapshotAutoRefresh(value.autoRefresh)) {
+        patch.autoRefresh = value.autoRefresh;
+    }
+    return Object.keys(patch).length > 0 ? patch : undefined;
+}
+function extractLayoutPatch(value) {
+    if (!isPlainObject(value)) {
+        return undefined;
+    }
+    const patch = {};
+    if (hasOwnKey(value, "maxWidth") && isPositiveNumber(value.maxWidth)) {
+        patch.maxWidth = value.maxWidth;
+    }
+    if (hasOwnKey(value, "narrowAt") && isPositiveNumber(value.narrowAt)) {
+        patch.narrowAt = value.narrowAt;
+    }
+    if (hasOwnKey(value, "tinyAt") && isPositiveNumber(value.tinyAt)) {
+        patch.tinyAt = value.tinyAt;
+    }
+    return Object.keys(patch).length > 0 ? patch : undefined;
+}
+function extractValidatedQuotaToastPatch(quotaToastConfig, reportIssue) {
+    const patch = {};
+    if (hasOwnKey(quotaToastConfig, "enabled") && typeof quotaToastConfig.enabled === "boolean") {
+        patch.enabled = quotaToastConfig.enabled;
+    }
+    if (hasOwnKey(quotaToastConfig, "enableToast") &&
+        typeof quotaToastConfig.enableToast === "boolean") {
+        patch.enableToast = quotaToastConfig.enableToast;
+    }
+    const formatStyle = getConfiguredFormatStyle(quotaToastConfig);
+    if (formatStyle) {
+        patch.formatStyle = formatStyle;
+    }
+    if (hasOwnKey(quotaToastConfig, "percentDisplayMode") &&
+        isValidPercentDisplayMode(quotaToastConfig.percentDisplayMode)) {
+        patch.percentDisplayMode = quotaToastConfig.percentDisplayMode;
+    }
+    if (hasOwnKey(quotaToastConfig, "minIntervalMs") && isPositiveNumber(quotaToastConfig.minIntervalMs)) {
+        patch.minIntervalMs = quotaToastConfig.minIntervalMs;
+    }
+    if (hasOwnKey(quotaToastConfig, "debug") && typeof quotaToastConfig.debug === "boolean") {
+        patch.debug = quotaToastConfig.debug;
+    }
+    if (hasOwnKey(quotaToastConfig, "enabledProviders")) {
+        const enabledProviders = normalizeEnabledProviders(quotaToastConfig.enabledProviders);
+        for (const issue of enabledProviders.issues) {
+            reportIssue?.("enabledProviders", issue);
+        }
+        if (enabledProviders.value !== undefined) {
+            patch.enabledProviders = enabledProviders.value;
+            if (enabledProviders.invalidEmpty) {
+                patch.enabledProvidersInvalidEmpty = true;
+            }
+        }
+    }
+    if (hasOwnKey(quotaToastConfig, "anthropicBinaryPath")) {
+        const anthropicBinaryPath = normalizeOptionalString(quotaToastConfig.anthropicBinaryPath);
+        if (anthropicBinaryPath !== undefined) {
+            patch.anthropicBinaryPath = anthropicBinaryPath;
         }
-        else if (typeof params.localSources[key] === "string" && params.localSources[key].length > 0) {
-            resolved[key] = params.localSources[key];
+    }
+    if (hasOwnKey(quotaToastConfig, "googleModels")) {
+        const googleModels = normalizeGoogleModels(quotaToastConfig.googleModels);
+        if (googleModels !== undefined) {
+            patch.googleModels = googleModels;
+        }
+    }
+    if (hasOwnKey(quotaToastConfig, "alibabaCodingPlanTier") &&
+        isValidAlibabaCodingPlanTier(quotaToastConfig.alibabaCodingPlanTier)) {
+        patch.alibabaCodingPlanTier = quotaToastConfig.alibabaCodingPlanTier;
+    }
+    if (hasOwnKey(quotaToastConfig, "cursorPlan") && isValidCursorQuotaPlan(quotaToastConfig.cursorPlan)) {
+        patch.cursorPlan = quotaToastConfig.cursorPlan;
+    }
+    if (hasOwnKey(quotaToastConfig, "cursorIncludedApiUsd") &&
+        isPositiveNumber(quotaToastConfig.cursorIncludedApiUsd)) {
+        patch.cursorIncludedApiUsd = quotaToastConfig.cursorIncludedApiUsd;
+    }
+    if (hasOwnKey(quotaToastConfig, "cursorBillingCycleStartDay") &&
+        isValidCursorBillingCycleStartDay(quotaToastConfig.cursorBillingCycleStartDay)) {
+        patch.cursorBillingCycleStartDay = quotaToastConfig.cursorBillingCycleStartDay;
+    }
+    if (hasOwnKey(quotaToastConfig, "pricingSnapshot")) {
+        const pricingSnapshot = extractPricingSnapshotPatch(quotaToastConfig.pricingSnapshot);
+        if (pricingSnapshot) {
+            patch.pricingSnapshot = pricingSnapshot;
+        }
+    }
+    if (hasOwnKey(quotaToastConfig, "showOnIdle") && typeof quotaToastConfig.showOnIdle === "boolean") {
+        patch.showOnIdle = quotaToastConfig.showOnIdle;
+    }
+    if (hasOwnKey(quotaToastConfig, "showOnQuestion") &&
+        typeof quotaToastConfig.showOnQuestion === "boolean") {
+        patch.showOnQuestion = quotaToastConfig.showOnQuestion;
+    }
+    if (hasOwnKey(quotaToastConfig, "showOnCompact") &&
+        typeof quotaToastConfig.showOnCompact === "boolean") {
+        patch.showOnCompact = quotaToastConfig.showOnCompact;
+    }
+    if (hasOwnKey(quotaToastConfig, "showOnBothFail") &&
+        typeof quotaToastConfig.showOnBothFail === "boolean") {
+        patch.showOnBothFail = quotaToastConfig.showOnBothFail;
+    }
+    if (hasOwnKey(quotaToastConfig, "toastDurationMs") &&
+        isPositiveNumber(quotaToastConfig.toastDurationMs)) {
+        patch.toastDurationMs = quotaToastConfig.toastDurationMs;
+    }
+    if (hasOwnKey(quotaToastConfig, "onlyCurrentModel") &&
+        typeof quotaToastConfig.onlyCurrentModel === "boolean") {
+        patch.onlyCurrentModel = quotaToastConfig.onlyCurrentModel;
+    }
+    if (hasOwnKey(quotaToastConfig, "showSessionTokens") &&
+        typeof quotaToastConfig.showSessionTokens === "boolean") {
+        patch.showSessionTokens = quotaToastConfig.showSessionTokens;
+    }
+    if (hasOwnKey(quotaToastConfig, "layout")) {
+        const layout = extractLayoutPatch(quotaToastConfig.layout);
+        if (layout) {
+            patch.layout = layout;
         }
     }
-    return resolved;
+    return patch;
 }
-function recordNetworkSettingSource(sources, quotaToast, sourcePath) {
-    for (const key of [
-        "enabled",
-        "enabledProviders",
-        "minIntervalMs",
-        "showOnIdle",
-        "showOnQuestion",
-        "showOnCompact",
-        "showOnBothFail",
-    ]) {
-        if (key in quotaToast) {
-            sources[key] = sourcePath;
+function applySettingSource(settingSources, key, sourcePath) {
+    settingSources[key] = sourcePath;
+}
+function applyValidatedQuotaToastPatch(config, patch, sourcePath, settingSources) {
+    if (hasOwnKey(patch, "enabled")) {
+        config.enabled = patch.enabled;
+        applySettingSource(settingSources, "enabled", sourcePath);
+    }
+    if (hasOwnKey(patch, "enableToast")) {
+        config.enableToast = patch.enableToast;
+        applySettingSource(settingSources, "enableToast", sourcePath);
+    }
+    if (hasOwnKey(patch, "formatStyle")) {
+        config.formatStyle = patch.formatStyle;
+        applySettingSource(settingSources, "formatStyle", sourcePath);
+    }
+    if (hasOwnKey(patch, "percentDisplayMode")) {
+        config.percentDisplayMode = patch.percentDisplayMode;
+        applySettingSource(settingSources, "percentDisplayMode", sourcePath);
+    }
+    if (hasOwnKey(patch, "minIntervalMs")) {
+        config.minIntervalMs = patch.minIntervalMs;
+        applySettingSource(settingSources, "minIntervalMs", sourcePath);
+    }
+    if (hasOwnKey(patch, "debug")) {
+        config.debug = patch.debug;
+        applySettingSource(settingSources, "debug", sourcePath);
+    }
+    if (hasOwnKey(patch, "enabledProviders")) {
+        if (!(patch.enabledProvidersInvalidEmpty && settingSources.enabledProviders)) {
+            config.enabledProviders =
+                patch.enabledProviders === "auto" ? "auto" : [...patch.enabledProviders];
+            applySettingSource(settingSources, "enabledProviders", sourcePath);
+        }
+    }
+    if (hasOwnKey(patch, "anthropicBinaryPath")) {
+        config.anthropicBinaryPath = patch.anthropicBinaryPath;
+        applySettingSource(settingSources, "anthropicBinaryPath", sourcePath);
+    }
+    if (hasOwnKey(patch, "googleModels")) {
+        config.googleModels = [...patch.googleModels];
+        applySettingSource(settingSources, "googleModels", sourcePath);
+    }
+    if (hasOwnKey(patch, "alibabaCodingPlanTier")) {
+        config.alibabaCodingPlanTier = patch.alibabaCodingPlanTier;
+        applySettingSource(settingSources, "alibabaCodingPlanTier", sourcePath);
+    }
+    if (hasOwnKey(patch, "cursorPlan")) {
+        config.cursorPlan = patch.cursorPlan;
+        applySettingSource(settingSources, "cursorPlan", sourcePath);
+    }
+    if (hasOwnKey(patch, "cursorIncludedApiUsd")) {
+        config.cursorIncludedApiUsd = patch.cursorIncludedApiUsd;
+        applySettingSource(settingSources, "cursorIncludedApiUsd", sourcePath);
+    }
+    if (hasOwnKey(patch, "cursorBillingCycleStartDay")) {
+        config.cursorBillingCycleStartDay = patch.cursorBillingCycleStartDay;
+        applySettingSource(settingSources, "cursorBillingCycleStartDay", sourcePath);
+    }
+    if (patch.pricingSnapshot) {
+        if (hasOwnKey(patch.pricingSnapshot, "source")) {
+            config.pricingSnapshot.source = patch.pricingSnapshot.source;
+            applySettingSource(settingSources, "pricingSnapshot.source", sourcePath);
+        }
+        if (hasOwnKey(patch.pricingSnapshot, "autoRefresh")) {
+            config.pricingSnapshot.autoRefresh = patch.pricingSnapshot.autoRefresh;
+            applySettingSource(settingSources, "pricingSnapshot.autoRefresh", sourcePath);
         }
     }
-    const pricingSnapshot = quotaToast.pricingSnapshot;
-    if (pricingSnapshot && typeof pricingSnapshot === "object") {
-        const pricingSnapshotRecord = pricingSnapshot;
-        if ("source" in pricingSnapshotRecord) {
-            sources["pricingSnapshot.source"] = sourcePath;
+    if (hasOwnKey(patch, "showOnIdle")) {
+        config.showOnIdle = patch.showOnIdle;
+        applySettingSource(settingSources, "showOnIdle", sourcePath);
+    }
+    if (hasOwnKey(patch, "showOnQuestion")) {
+        config.showOnQuestion = patch.showOnQuestion;
+        applySettingSource(settingSources, "showOnQuestion", sourcePath);
+    }
+    if (hasOwnKey(patch, "showOnCompact")) {
+        config.showOnCompact = patch.showOnCompact;
+        applySettingSource(settingSources, "showOnCompact", sourcePath);
+    }
+    if (hasOwnKey(patch, "showOnBothFail")) {
+        config.showOnBothFail = patch.showOnBothFail;
+        applySettingSource(settingSources, "showOnBothFail", sourcePath);
+    }
+    if (hasOwnKey(patch, "toastDurationMs")) {
+        config.toastDurationMs = patch.toastDurationMs;
+        applySettingSource(settingSources, "toastDurationMs", sourcePath);
+    }
+    if (hasOwnKey(patch, "onlyCurrentModel")) {
+        config.onlyCurrentModel = patch.onlyCurrentModel;
+        applySettingSource(settingSources, "onlyCurrentModel", sourcePath);
+    }
+    if (hasOwnKey(patch, "showSessionTokens")) {
+        config.showSessionTokens = patch.showSessionTokens;
+        applySettingSource(settingSources, "showSessionTokens", sourcePath);
+    }
+    if (patch.layout) {
+        if (hasOwnKey(patch.layout, "maxWidth")) {
+            config.layout.maxWidth = patch.layout.maxWidth;
+            applySettingSource(settingSources, "layout.maxWidth", sourcePath);
+        }
+        if (hasOwnKey(patch.layout, "narrowAt")) {
+            config.layout.narrowAt = patch.layout.narrowAt;
+            applySettingSource(settingSources, "layout.narrowAt", sourcePath);
         }
-        if ("autoRefresh" in pricingSnapshotRecord) {
-            sources["pricingSnapshot.autoRefresh"] = sourcePath;
+        if (hasOwnKey(patch.layout, "tinyAt")) {
+            config.layout.tinyAt = patch.layout.tinyAt;
+            applySettingSource(settingSources, "layout.tinyAt", sourcePath);
         }
     }
 }
+function projectNetworkSettingSources(settingSources) {
+    const projected = {};
+    for (const key of NETWORK_SETTING_SOURCE_KEYS) {
+        const source = settingSources[key];
+        if (typeof source === "string" && source.length > 0) {
+            projected[key] = source;
+        }
+    }
+    return projected;
+}
+function buildConfigLayerCandidates(configDirs, configRootDir) {
+    const workspaceCandidates = CONFIG_FILENAMES.map((filename) => ({
+        path: join(configRootDir, filename),
+        scope: "workspace",
+    }));
+    const workspacePaths = new Set(workspaceCandidates.map((candidate) => candidate.path));
+    const globalCandidates = configDirs.flatMap((dir) => CONFIG_FILENAMES.map((filename) => ({ path: join(dir, filename), scope: "global" })));
+    return [
+        ...globalCandidates.filter((candidate) => !workspacePaths.has(candidate.path)),
+        ...workspaceCandidates,
+    ];
+}
 /**
  * Load plugin configuration from OpenCode config
  *
@@ -133,106 +456,6 @@ function recordNetworkSettingSource(sources, quotaToast, sourcePath) {
  * @returns Merged configuration with defaults
  */
 export async function loadConfig(client, meta, options) {
-    function normalize(quotaToastConfig) {
-        if (!quotaToastConfig)
-            return DEFAULT_CONFIG;
-        const formatStyle = getConfiguredFormatStyle(quotaToastConfig) ?? DEFAULT_CONFIG.formatStyle;
-        const config = {
-            enabled: typeof quotaToastConfig.enabled === "boolean"
-                ? quotaToastConfig.enabled
-                : DEFAULT_CONFIG.enabled,
-            enableToast: typeof quotaToastConfig.enableToast === "boolean"
-                ? quotaToastConfig.enableToast
-                : DEFAULT_CONFIG.enableToast,
-            formatStyle,
-            percentDisplayMode: isValidPercentDisplayMode(quotaToastConfig.percentDisplayMode)
-                ? quotaToastConfig.percentDisplayMode
-                : DEFAULT_CONFIG.percentDisplayMode,
-            minIntervalMs: typeof quotaToastConfig.minIntervalMs === "number" && quotaToastConfig.minIntervalMs > 0
-                ? quotaToastConfig.minIntervalMs
-                : DEFAULT_CONFIG.minIntervalMs,
-            debug: typeof quotaToastConfig.debug === "boolean" ? quotaToastConfig.debug : DEFAULT_CONFIG.debug,
-            enabledProviders: quotaToastConfig.enabledProviders === "auto"
-                ? "auto"
-                : Array.isArray(quotaToastConfig.enabledProviders)
-                    ? dedupe(quotaToastConfig.enabledProviders
-                        .filter((p) => typeof p === "string")
-                        .map(normalizeQuotaProviderId)
-                        .filter(Boolean))
-                    : DEFAULT_CONFIG.enabledProviders,
-            anthropicBinaryPath: normalizeOptionalString(quotaToastConfig.anthropicBinaryPath) ??
-                DEFAULT_CONFIG.anthropicBinaryPath,
-            googleModels: Array.isArray(quotaToastConfig.googleModels)
-                ? quotaToastConfig.googleModels.filter(isValidGoogleModelId)
-                : DEFAULT_CONFIG.googleModels,
-            alibabaCodingPlanTier: quotaToastConfig.alibabaCodingPlanTier === "lite" ||
-                quotaToastConfig.alibabaCodingPlanTier === "pro"
-                ? quotaToastConfig.alibabaCodingPlanTier
-                : DEFAULT_CONFIG.alibabaCodingPlanTier,
-            cursorPlan: isValidCursorQuotaPlan(quotaToastConfig.cursorPlan)
-                ? quotaToastConfig.cursorPlan
-                : DEFAULT_CONFIG.cursorPlan,
-            cursorIncludedApiUsd: typeof quotaToastConfig.cursorIncludedApiUsd === "number" &&
-                Number.isFinite(quotaToastConfig.cursorIncludedApiUsd) &&
-                quotaToastConfig.cursorIncludedApiUsd > 0
-                ? quotaToastConfig.cursorIncludedApiUsd
-                : undefined,
-            cursorBillingCycleStartDay: typeof quotaToastConfig.cursorBillingCycleStartDay === "number" &&
-                Number.isInteger(quotaToastConfig.cursorBillingCycleStartDay) &&
-                quotaToastConfig.cursorBillingCycleStartDay >= 1 &&
-                quotaToastConfig.cursorBillingCycleStartDay <= 28
-                ? quotaToastConfig.cursorBillingCycleStartDay
-                : undefined,
-            pricingSnapshot: {
-                source: isValidPricingSnapshotSource(quotaToastConfig.pricingSnapshot?.source)
-                    ? quotaToastConfig.pricingSnapshot.source
-                    : DEFAULT_CONFIG.pricingSnapshot.source,
-                autoRefresh: isValidPricingSnapshotAutoRefresh(quotaToastConfig.pricingSnapshot?.autoRefresh)
-                    ? quotaToastConfig.pricingSnapshot.autoRefresh
-                    : DEFAULT_CONFIG.pricingSnapshot.autoRefresh,
-            },
-            showOnIdle: typeof quotaToastConfig.showOnIdle === "boolean"
-                ? quotaToastConfig.showOnIdle
-                : DEFAULT_CONFIG.showOnIdle,
-            showOnQuestion: typeof quotaToastConfig.showOnQuestion === "boolean"
-                ? quotaToastConfig.showOnQuestion
-                : DEFAULT_CONFIG.showOnQuestion,
-            showOnCompact: typeof quotaToastConfig.showOnCompact === "boolean"
-                ? quotaToastConfig.showOnCompact
-                : DEFAULT_CONFIG.showOnCompact,
-            showOnBothFail: typeof quotaToastConfig.showOnBothFail === "boolean"
-                ? quotaToastConfig.showOnBothFail
-                : DEFAULT_CONFIG.showOnBothFail,
-            toastDurationMs: typeof quotaToastConfig.toastDurationMs === "number" && quotaToastConfig.toastDurationMs > 0
-                ? quotaToastConfig.toastDurationMs
-                : DEFAULT_CONFIG.toastDurationMs,
-            onlyCurrentModel: typeof quotaToastConfig.onlyCurrentModel === "boolean"
-                ? quotaToastConfig.onlyCurrentModel
-                : DEFAULT_CONFIG.onlyCurrentModel,
-            showSessionTokens: typeof quotaToastConfig.showSessionTokens === "boolean"
-                ? quotaToastConfig.showSessionTokens
-                : DEFAULT_CONFIG.showSessionTokens,
-            layout: {
-                maxWidth: typeof quotaToastConfig.layout?.maxWidth === "number" &&
-                    quotaToastConfig.layout.maxWidth > 0
-                    ? quotaToastConfig.layout.maxWidth
-                    : DEFAULT_CONFIG.layout.maxWidth,
-                narrowAt: typeof quotaToastConfig.layout?.narrowAt === "number" &&
-                    quotaToastConfig.layout.narrowAt > 0
-                    ? quotaToastConfig.layout.narrowAt
-                    : DEFAULT_CONFIG.layout.narrowAt,
-                tinyAt: typeof quotaToastConfig.layout?.tinyAt === "number" && quotaToastConfig.layout.tinyAt > 0
-                    ? quotaToastConfig.layout.tinyAt
-                    : DEFAULT_CONFIG.layout.tinyAt,
-            },
-        };
-        // enabledProviders: "auto" means auto-detect; explicit array means user-specified.
-        // Ensure at least one Google model is configured
-        if (config.googleModels.length === 0) {
-            config.googleModels = DEFAULT_CONFIG.googleModels;
-        }
-        return config;
-    }
     async function readJson(path) {
         try {
             const content = await readFile(path, "utf-8");
@@ -242,80 +465,58 @@ export async function loadConfig(client, meta, options) {
             return null;
         }
     }
-    async function loadQuotaToastFromLocations(locations) {
-        const quota = {};
-        const usedPaths = [];
-        const networkSettingSources = {};
-        for (const dir of locations) {
-            for (const filename of ["opencode.json", "opencode.jsonc"]) {
-                const p = join(dir, filename);
-                if (!existsSync(p))
-                    continue;
-                const parsed = await readJson(p);
-                if (!parsed || typeof parsed !== "object")
-                    continue;
-                const root = parsed;
-                const rawQuotaToast = root?.experimental?.quotaToast;
-                if (!rawQuotaToast || typeof rawQuotaToast !== "object")
-                    continue;
-                Object.assign(quota, rawQuotaToast);
-                const sourcePath = `${p} (experimental.quotaToast)`;
-                usedPaths.push(sourcePath);
-                recordNetworkSettingSource(networkSettingSources, rawQuotaToast, sourcePath);
-            }
-        }
-        return { quota, usedPaths, networkSettingSources };
-    }
     async function loadFromFiles() {
-        const cwd = options?.cwd ?? process.cwd();
+        const configRootDir = options?.configRootDir ?? options?.cwd ?? process.cwd();
         const { configDirs } = getOpencodeRuntimeDirCandidates();
-        const globalConfig = await loadQuotaToastFromLocations(configDirs);
-        const localConfig = await loadQuotaToastFromLocations([cwd]);
-        const usedPaths = [...globalConfig.usedPaths, ...localConfig.usedPaths];
-        const networkSettingSources = resolveEffectiveNetworkSettingSources({
-            globalSources: globalConfig.networkSettingSources,
-            localSources: localConfig.networkSettingSources,
-        });
-        if (usedPaths.length === 0) {
-            return { config: null, usedPaths: [], networkSettingSources: {} };
-        }
-        const quota = {
-            ...globalConfig.quota,
-            ...localConfig.quota,
-        };
-        for (const key of NETWORK_AFFECTING_KEYS) {
-            if (hasOwnKey(globalConfig.quota, key)) {
-                quota[key] = globalConfig.quota[key];
+        const config = cloneDefaultConfig();
+        const usedPaths = [];
+        const globalConfigPaths = [];
+        const workspaceConfigPaths = [];
+        const settingSources = {};
+        const configIssues = [];
+        for (const candidate of buildConfigLayerCandidates(configDirs, configRootDir)) {
+            if (!existsSync(candidate.path)) {
+                continue;
             }
-            else if (hasOwnKey(localConfig.quota, key)) {
-                quota[key] = localConfig.quota[key];
+            const parsed = await readJson(candidate.path);
+            if (!isPlainObject(parsed) || !isPlainObject(parsed.experimental)) {
+                continue;
             }
+            const rawQuotaToast = parsed.experimental.quotaToast;
+            if (!isPlainObject(rawQuotaToast)) {
+                continue;
+            }
+            const sourcePath = `${candidate.path} (experimental.quotaToast)`;
+            usedPaths.push(sourcePath);
+            if (candidate.scope === "global") {
+                globalConfigPaths.push(sourcePath);
+            }
+            else {
+                workspaceConfigPaths.push(sourcePath);
+            }
+            applyValidatedQuotaToastPatch(config, extractValidatedQuotaToastPatch(rawQuotaToast, (key, message) => {
+                configIssues.push({ path: sourcePath, key, message });
+            }), sourcePath, settingSources);
         }
-        const mergedPricingSnapshot = {};
-        let hasMergedPricingSnapshot = false;
-        if (isPlainObject(localConfig.quota.pricingSnapshot)) {
-            Object.assign(mergedPricingSnapshot, localConfig.quota.pricingSnapshot);
-            hasMergedPricingSnapshot = true;
-        }
-        if (isPlainObject(globalConfig.quota.pricingSnapshot)) {
-            Object.assign(mergedPricingSnapshot, globalConfig.quota.pricingSnapshot);
-            hasMergedPricingSnapshot = true;
-        }
-        if (hasMergedPricingSnapshot) {
-            quota.pricingSnapshot = mergedPricingSnapshot;
-        }
-        const localFormatStyle = getConfiguredFormatStyle(localConfig.quota);
-        const globalFormatStyle = getConfiguredFormatStyle(globalConfig.quota);
-        if (localFormatStyle) {
-            quota.formatStyle = localFormatStyle;
-        }
-        else if (globalFormatStyle) {
-            quota.formatStyle = globalFormatStyle;
+        if (usedPaths.length === 0) {
+            return {
+                config: null,
+                usedPaths: [],
+                globalConfigPaths: [],
+                workspaceConfigPaths: [],
+                settingSources: {},
+                networkSettingSources: {},
+                configIssues: [],
+            };
         }
         return {
-            config: normalize(quota),
+            config,
             usedPaths,
-            networkSettingSources,
+            globalConfigPaths,
+            workspaceConfigPaths,
+            settingSources,
+            networkSettingSources: projectNetworkSettingSources(settingSources),
+            configIssues,
         };
     }
     const fileConfig = await loadFromFiles();
@@ -323,7 +524,11 @@ export async function loadConfig(client, meta, options) {
         if (meta) {
             meta.source = "files";
             meta.paths = fileConfig.usedPaths;
+            meta.globalConfigPaths = fileConfig.globalConfigPaths;
+            meta.workspaceConfigPaths = fileConfig.workspaceConfigPaths;
+            meta.settingSources = fileConfig.settingSources;
             meta.networkSettingSources = fileConfig.networkSettingSources;
+            meta.configIssues = fileConfig.configIssues;
         }
         return fileConfig.config;
     }
@@ -333,14 +538,23 @@ export async function loadConfig(client, meta, options) {
             // OpenCode config schema is strict; plugin-specific config must live under
             // experimental.* to avoid "unrecognized key" validation errors.
             const quotaToastConfig = response.data?.experimental?.quotaToast;
-            if (quotaToastConfig && typeof quotaToastConfig === "object") {
+            if (isPlainObject(quotaToastConfig)) {
+                const config = cloneDefaultConfig();
+                const settingSources = {};
+                const configIssues = [];
+                applyValidatedQuotaToastPatch(config, extractValidatedQuotaToastPatch(quotaToastConfig, (key, message) => {
+                    configIssues.push({ path: "client.config.get", key, message });
+                }), "client.config.get", settingSources);
                 if (meta) {
                     meta.source = "sdk";
                     meta.paths = ["client.config.get"];
-                    meta.networkSettingSources = {};
-                    recordNetworkSettingSource(meta.networkSettingSources, quotaToastConfig, "client.config.get");
+                    meta.globalConfigPaths = [];
+                    meta.workspaceConfigPaths = [];
+                    meta.settingSources = settingSources;
+                    meta.networkSettingSources = projectNetworkSettingSources(settingSources);
+                    meta.configIssues = configIssues;
                 }
-                return normalize(quotaToastConfig);
+                return config;
             }
         }
         catch {
@@ -350,7 +564,11 @@ export async function loadConfig(client, meta, options) {
     if (meta) {
         meta.source = "defaults";
         meta.paths = [];
+        meta.globalConfigPaths = [];
+        meta.workspaceConfigPaths = [];
+        meta.settingSources = {};
         meta.networkSettingSources = {};
+        meta.configIssues = [];
     }
     return DEFAULT_CONFIG;
 }