@tarquinen/opencode-dcp 2.1.6 → 2.2.0-beta0

package/dist/lib/config.js

@@ -6,20 +6,16 @@ const DEFAULT_PROTECTED_TOOLS = [
     "task",
     "todowrite",
     "todoread",
-    "distill",
     "compress",
-    "prune",
     "batch",
     "plan_enter",
     "plan_exit",
 ];
-// Valid config keys for validation against user config
 export const VALID_CONFIG_KEYS = new Set([
-    // Top-level keys
     "$schema",
     "enabled",
     "debug",
-    "showUpdateToasts", // Deprecated but kept for backwards compatibility
+    "showUpdateToasts",
     "pruneNotification",
     "pruneNotificationType",
     "turnProtection",
@@ -32,43 +28,31 @@ export const VALID_CONFIG_KEYS = new Set([
     "manualMode",
     "manualMode.enabled",
     "manualMode.automaticStrategies",
-    "tools",
-    "tools.settings",
-    "tools.settings.nudgeEnabled",
-    "tools.settings.nudgeFrequency",
-    "tools.settings.protectedTools",
-    "tools.settings.contextLimit",
-    "tools.settings.modelLimits",
-    "tools.distill",
-    "tools.distill.permission",
-    "tools.distill.showDistillation",
-    "tools.compress",
-    "tools.compress.permission",
-    "tools.compress.showCompression",
-    "tools.prune",
-    "tools.prune.permission",
+    "compress",
+    "compress.permission",
+    "compress.showCompression",
+    "compress.contextLimit",
+    "compress.modelLimits",
+    "compress.nudgeFrequency",
+    "compress.iterationNudgeThreshold",
     "strategies",
-    // strategies.deduplication
     "strategies.deduplication",
     "strategies.deduplication.enabled",
     "strategies.deduplication.protectedTools",
-    // strategies.supersedeWrites
     "strategies.supersedeWrites",
     "strategies.supersedeWrites.enabled",
-    // strategies.purgeErrors
     "strategies.purgeErrors",
     "strategies.purgeErrors.enabled",
     "strategies.purgeErrors.turns",
     "strategies.purgeErrors.protectedTools",
 ]);
-// Extract all key paths from a config object for validation
 function getConfigKeyPaths(obj, prefix = "") {
     const keys = [];
     for (const key of Object.keys(obj)) {
         const fullKey = prefix ? `${prefix}.${key}` : key;
         keys.push(fullKey);
         // modelLimits is a dynamic map keyed by providerID/modelID; do not recurse into arbitrary IDs.
-        if (fullKey === "tools.settings.modelLimits") {
+        if (fullKey === "compress.modelLimits") {
             continue;
         }
         if (obj[key] && typeof obj[key] === "object" && !Array.isArray(obj[key])) {
@@ -77,14 +61,12 @@ function getConfigKeyPaths(obj, prefix = "") {
     }
     return keys;
 }
-// Returns invalid keys found in user config
 export function getInvalidConfigKeys(userConfig) {
     const userKeys = getConfigKeyPaths(userConfig);
     return userKeys.filter((key) => !VALID_CONFIG_KEYS.has(key));
 }
 export function validateConfigTypes(config) {
     const errors = [];
-    // Top-level validators
     if (config.enabled !== undefined && typeof config.enabled !== "boolean") {
         errors.push({ key: "enabled", expected: "boolean", actual: typeof config.enabled });
     }
@@ -127,7 +109,6 @@ export function validateConfigTypes(config) {
             });
         }
     }
-    // Top-level turnProtection validator
     if (config.turnProtection) {
         if (config.turnProtection.enabled !== undefined &&
             typeof config.turnProtection.enabled !== "boolean") {
@@ -153,10 +134,16 @@ export function validateConfigTypes(config) {
             });
         }
     }
-    // Commands validator
     const commands = config.commands;
     if (commands !== undefined) {
-        if (typeof commands === "object") {
+        if (typeof commands !== "object" || commands === null || Array.isArray(commands)) {
+            errors.push({
+                key: "commands",
+                expected: "object",
+                actual: typeof commands,
+            });
+        }
+        else {
             if (commands.enabled !== undefined && typeof commands.enabled !== "boolean") {
                 errors.push({
                     key: "commands.enabled",
@@ -172,18 +159,17 @@ export function validateConfigTypes(config) {
                 });
             }
         }
-        else {
-            errors.push({
-                key: "commands",
-                expected: "{ enabled: boolean, protectedTools: string[] }",
-                actual: typeof commands,
-            });
-        }
     }
-    // Manual mode validator
     const manualMode = config.manualMode;
     if (manualMode !== undefined) {
-        if (typeof manualMode === "object") {
+        if (typeof manualMode !== "object" || manualMode === null || Array.isArray(manualMode)) {
+            errors.push({
+                key: "manualMode",
+                expected: "object",
+                actual: typeof manualMode,
+            });
+        }
+        else {
             if (manualMode.enabled !== undefined && typeof manualMode.enabled !== "boolean") {
                 errors.push({
                     key: "manualMode.enabled",
@@ -200,78 +186,76 @@ export function validateConfigTypes(config) {
                 });
             }
         }
-        else {
+    }
+    const compress = config.compress;
+    if (compress !== undefined) {
+        if (typeof compress !== "object" || compress === null || Array.isArray(compress)) {
             errors.push({
-                key: "manualMode",
-                expected: "{ enabled: boolean, automaticStrategies: boolean }",
-                actual: typeof manualMode,
+                key: "compress",
+                expected: "object",
+                actual: typeof compress,
             });
         }
-    }
-    // Tools validators
-    const tools = config.tools;
-    if (tools) {
-        if (tools.settings) {
-            if (tools.settings.nudgeEnabled !== undefined &&
-                typeof tools.settings.nudgeEnabled !== "boolean") {
+        else {
+            if (compress.nudgeFrequency !== undefined &&
+                typeof compress.nudgeFrequency !== "number") {
                 errors.push({
-                    key: "tools.settings.nudgeEnabled",
-                    expected: "boolean",
-                    actual: typeof tools.settings.nudgeEnabled,
+                    key: "compress.nudgeFrequency",
+                    expected: "number",
+                    actual: typeof compress.nudgeFrequency,
                 });
             }
-            if (tools.settings.nudgeFrequency !== undefined &&
-                typeof tools.settings.nudgeFrequency !== "number") {
+            if (typeof compress.nudgeFrequency === "number" && compress.nudgeFrequency < 1) {
                 errors.push({
-                    key: "tools.settings.nudgeFrequency",
-                    expected: "number",
-                    actual: typeof tools.settings.nudgeFrequency,
+                    key: "compress.nudgeFrequency",
+                    expected: "positive number (>= 1)",
+                    actual: `${compress.nudgeFrequency} (will be clamped to 1)`,
                 });
             }
-            if (typeof tools.settings.nudgeFrequency === "number" &&
-                tools.settings.nudgeFrequency < 1) {
+            if (compress.iterationNudgeThreshold !== undefined &&
+                typeof compress.iterationNudgeThreshold !== "number") {
                 errors.push({
-                    key: "tools.settings.nudgeFrequency",
-                    expected: "positive number (>= 1)",
-                    actual: `${tools.settings.nudgeFrequency} (will be clamped to 1)`,
+                    key: "compress.iterationNudgeThreshold",
+                    expected: "number",
+                    actual: typeof compress.iterationNudgeThreshold,
                 });
             }
-            if (tools.settings.protectedTools !== undefined &&
-                !Array.isArray(tools.settings.protectedTools)) {
+            if (typeof compress.iterationNudgeThreshold === "number" &&
+                compress.iterationNudgeThreshold < 1) {
                 errors.push({
-                    key: "tools.settings.protectedTools",
-                    expected: "string[]",
-                    actual: typeof tools.settings.protectedTools,
+                    key: "compress.iterationNudgeThreshold",
+                    expected: "positive number (>= 1)",
+                    actual: `${compress.iterationNudgeThreshold} (will be clamped to 1)`,
                 });
             }
-            if (tools.settings.contextLimit !== undefined) {
-                const isValidNumber = typeof tools.settings.contextLimit === "number";
-                const isPercentString = typeof tools.settings.contextLimit === "string" &&
-                    tools.settings.contextLimit.endsWith("%");
+            if (compress.contextLimit !== undefined) {
+                const isValidNumber = typeof compress.contextLimit === "number";
+                const isPercentString = typeof compress.contextLimit === "string" && compress.contextLimit.endsWith("%");
                 if (!isValidNumber && !isPercentString) {
                     errors.push({
-                        key: "tools.settings.contextLimit",
+                        key: "compress.contextLimit",
                         expected: 'number | "${number}%"',
-                        actual: JSON.stringify(tools.settings.contextLimit),
+                        actual: JSON.stringify(compress.contextLimit),
                     });
                 }
             }
-            if (tools.settings.modelLimits !== undefined) {
-                if (typeof tools.settings.modelLimits !== "object" ||
-                    Array.isArray(tools.settings.modelLimits)) {
+            if (compress.modelLimits !== undefined) {
+                if (typeof compress.modelLimits !== "object" ||
+                    compress.modelLimits === null ||
+                    Array.isArray(compress.modelLimits)) {
                     errors.push({
-                        key: "tools.settings.modelLimits",
+                        key: "compress.modelLimits",
                         expected: "Record<string, number | ${number}%>",
-                        actual: typeof tools.settings.modelLimits,
+                        actual: typeof compress.modelLimits,
                     });
                 }
                 else {
-                    for (const [providerModelKey, limit] of Object.entries(tools.settings.modelLimits)) {
+                    for (const [providerModelKey, limit] of Object.entries(compress.modelLimits)) {
                         const isValidNumber = typeof limit === "number";
                         const isPercentString = typeof limit === "string" && /^\d+(?:\.\d+)?%$/.test(limit);
                         if (!isValidNumber && !isPercentString) {
                             errors.push({
-                                key: `tools.settings.modelLimits.${providerModelKey}`,
+                                key: `compress.modelLimits.${providerModelKey}`,
                                 expected: 'number | "${number}%"',
                                 actual: JSON.stringify(limit),
                             });
@@ -279,64 +263,26 @@ export function validateConfigTypes(config) {
                     }
                 }
             }
-            if (tools.distill) {
-                if (tools.distill.permission !== undefined) {
-                    const validValues = ["ask", "allow", "deny"];
-                    if (!validValues.includes(tools.distill.permission)) {
-                        errors.push({
-                            key: "tools.distill.permission",
-                            expected: '"ask" | "allow" | "deny"',
-                            actual: JSON.stringify(tools.distill.permission),
-                        });
-                    }
-                }
-                if (tools.distill.showDistillation !== undefined &&
-                    typeof tools.distill.showDistillation !== "boolean") {
-                    errors.push({
-                        key: "tools.distill.showDistillation",
-                        expected: "boolean",
-                        actual: typeof tools.distill.showDistillation,
-                    });
-                }
-            }
-        }
-        if (tools.compress) {
-            if (tools.compress.permission !== undefined) {
-                const validValues = ["ask", "allow", "deny"];
-                if (!validValues.includes(tools.compress.permission)) {
-                    errors.push({
-                        key: "tools.compress.permission",
-                        expected: '"ask" | "allow" | "deny"',
-                        actual: JSON.stringify(tools.compress.permission),
-                    });
-                }
+            const validValues = ["ask", "allow", "deny"];
+            if (compress.permission !== undefined && !validValues.includes(compress.permission)) {
+                errors.push({
+                    key: "compress.permission",
+                    expected: '"ask" | "allow" | "deny"',
+                    actual: JSON.stringify(compress.permission),
+                });
             }
-            if (tools.compress.showCompression !== undefined &&
-                typeof tools.compress.showCompression !== "boolean") {
+            if (compress.showCompression !== undefined &&
+                typeof compress.showCompression !== "boolean") {
                 errors.push({
-                    key: "tools.compress.showCompression",
+                    key: "compress.showCompression",
                     expected: "boolean",
-                    actual: typeof tools.compress.showCompression,
+                    actual: typeof compress.showCompression,
                 });
             }
         }
-        if (tools.prune) {
-            if (tools.prune.permission !== undefined) {
-                const validValues = ["ask", "allow", "deny"];
-                if (!validValues.includes(tools.prune.permission)) {
-                    errors.push({
-                        key: "tools.prune.permission",
-                        expected: '"ask" | "allow" | "deny"',
-                        actual: JSON.stringify(tools.prune.permission),
-                    });
-                }
-            }
-        }
     }
-    // Strategies validators
     const strategies = config.strategies;
     if (strategies) {
-        // deduplication
         if (strategies.deduplication?.enabled !== undefined &&
             typeof strategies.deduplication.enabled !== "boolean") {
             errors.push({
@@ -353,7 +299,6 @@ export function validateConfigTypes(config) {
                 actual: typeof strategies.deduplication.protectedTools,
             });
         }
-        // supersedeWrites
         if (strategies.supersedeWrites) {
             if (strategies.supersedeWrites.enabled !== undefined &&
                 typeof strategies.supersedeWrites.enabled !== "boolean") {
@@ -364,7 +309,6 @@ export function validateConfigTypes(config) {
                 });
             }
         }
-        // purgeErrors
         if (strategies.purgeErrors) {
             if (strategies.purgeErrors.enabled !== undefined &&
                 typeof strategies.purgeErrors.enabled !== "boolean") {
@@ -403,7 +347,6 @@ export function validateConfigTypes(config) {
     }
     return errors;
 }
-// Show validation warnings for a config file
 function showConfigValidationWarnings(ctx, configPath, configData, isProject) {
     const invalidKeys = getInvalidConfigKeys(configData);
     const typeErrors = validateConfigTypes(configData);
@@ -429,7 +372,7 @@ function showConfigValidationWarnings(ctx, configPath, configData, isProject) {
         try {
             ctx.client.tui.showToast({
                 body: {
-                    title: `DCP: Invalid ${configType}`,
+                    title: `DCP: ${configType} warning`,
                     message: `${configPath}\n${messages.join("\n")}`,
                     variant: "warning",
                     duration: 7000,
@@ -457,24 +400,12 @@ const defaultConfig = {
         turns: 4,
     },
     protectedFilePatterns: [],
-    tools: {
-        settings: {
-            nudgeEnabled: true,
-            nudgeFrequency: 10,
-            protectedTools: [...DEFAULT_PROTECTED_TOOLS],
-            contextLimit: 100000,
-        },
-        distill: {
-            permission: "allow",
-            showDistillation: false,
-        },
-        compress: {
-            permission: "deny",
-            showCompression: false,
-        },
-        prune: {
-            permission: "allow",
-        },
+    compress: {
+        permission: "allow",
+        showCompression: false,
+        contextLimit: 100000,
+        nudgeFrequency: 5,
+        iterationNudgeThreshold: 15,
     },
     strategies: {
         deduplication: {
@@ -504,50 +435,44 @@ function findOpencodeDir(startDir) {
             return candidate;
         }
         const parent = dirname(current);
-        if (parent === current)
+        if (parent === current) {
             break;
+        }
         current = parent;
     }
     return null;
 }
 function getConfigPaths(ctx) {
-    // Global: ~/.config/opencode/dcp.jsonc|json
-    let globalPath = null;
-    if (existsSync(GLOBAL_CONFIG_PATH_JSONC)) {
-        globalPath = GLOBAL_CONFIG_PATH_JSONC;
-    }
-    else if (existsSync(GLOBAL_CONFIG_PATH_JSON)) {
-        globalPath = GLOBAL_CONFIG_PATH_JSON;
-    }
-    // Custom config directory: $OPENCODE_CONFIG_DIR/dcp.jsonc|json
-    let configDirPath = null;
+    const global = existsSync(GLOBAL_CONFIG_PATH_JSONC)
+        ? GLOBAL_CONFIG_PATH_JSONC
+        : existsSync(GLOBAL_CONFIG_PATH_JSON)
+            ? GLOBAL_CONFIG_PATH_JSON
+            : null;
+    let configDir = null;
     const opencodeConfigDir = process.env.OPENCODE_CONFIG_DIR;
     if (opencodeConfigDir) {
         const configJsonc = join(opencodeConfigDir, "dcp.jsonc");
         const configJson = join(opencodeConfigDir, "dcp.json");
-        if (existsSync(configJsonc)) {
-            configDirPath = configJsonc;
-        }
-        else if (existsSync(configJson)) {
-            configDirPath = configJson;
-        }
+        configDir = existsSync(configJsonc)
+            ? configJsonc
+            : existsSync(configJson)
+                ? configJson
+                : null;
     }
-    // Project: <project>/.opencode/dcp.jsonc|json
-    let projectPath = null;
+    let project = null;
     if (ctx?.directory) {
         const opencodeDir = findOpencodeDir(ctx.directory);
         if (opencodeDir) {
             const projectJsonc = join(opencodeDir, "dcp.jsonc");
             const projectJson = join(opencodeDir, "dcp.json");
-            if (existsSync(projectJsonc)) {
-                projectPath = projectJsonc;
-            }
-            else if (existsSync(projectJson)) {
-                projectPath = projectJson;
-            }
+            project = existsSync(projectJsonc)
+                ? projectJsonc
+                : existsSync(projectJson)
+                    ? projectJson
+                    : null;
         }
     }
-    return { global: globalPath, configDir: configDirPath, project: projectPath };
+    return { global, configDir, project };
 }
 function createDefaultConfig() {
     if (!existsSync(GLOBAL_CONFIG_DIR)) {
@@ -560,16 +485,15 @@ function createDefaultConfig() {
     writeFileSync(GLOBAL_CONFIG_PATH_JSONC, configContent, "utf-8");
 }
 function loadConfigFile(configPath) {
-    let fileContent;
+    let fileContent = "";
     try {
         fileContent = readFileSync(configPath, "utf-8");
     }
     catch {
-        // File doesn't exist or can't be read - not a parse error
         return { data: null };
     }
     try {
-        const parsed = parse(fileContent);
+        const parsed = parse(fileContent, undefined, { allowTrailingComma: true });
         if (parsed === undefined || parsed === null) {
             return { data: null, parseError: "Config file is empty or invalid" };
         }
@@ -580,8 +504,9 @@ function loadConfigFile(configPath) {
     }
 }
 function mergeStrategies(base, override) {
-    if (!override)
+    if (!override) {
         return base;
+    }
     return {
         deduplication: {
             enabled: override.deduplication?.enabled ?? base.deduplication.enabled,
@@ -607,38 +532,23 @@ function mergeStrategies(base, override) {
         },
     };
 }
-function mergeTools(base, override) {
-    if (!override)
+function mergeCompress(base, override) {
+    if (!override) {
         return base;
+    }
     return {
-        settings: {
-            nudgeEnabled: override.settings?.nudgeEnabled ?? base.settings.nudgeEnabled,
-            nudgeFrequency: override.settings?.nudgeFrequency ?? base.settings.nudgeFrequency,
-            protectedTools: [
-                ...new Set([
-                    ...base.settings.protectedTools,
-                    ...(override.settings?.protectedTools ?? []),
-                ]),
-            ],
-            contextLimit: override.settings?.contextLimit ?? base.settings.contextLimit,
-            modelLimits: override.settings?.modelLimits ?? base.settings.modelLimits,
-        },
-        distill: {
-            permission: override.distill?.permission ?? base.distill.permission,
-            showDistillation: override.distill?.showDistillation ?? base.distill.showDistillation,
-        },
-        compress: {
-            permission: override.compress?.permission ?? base.compress.permission,
-            showCompression: override.compress?.showCompression ?? base.compress.showCompression,
-        },
-        prune: {
-            permission: override.prune?.permission ?? base.prune.permission,
-        },
+        permission: override.permission ?? base.permission,
+        showCompression: override.showCompression ?? base.showCompression,
+        contextLimit: override.contextLimit ?? base.contextLimit,
+        modelLimits: override.modelLimits ?? base.modelLimits,
+        nudgeFrequency: override.nudgeFrequency ?? base.nudgeFrequency,
+        iterationNudgeThreshold: override.iterationNudgeThreshold ?? base.iterationNudgeThreshold,
     };
 }
 function mergeCommands(base, override) {
-    if (override === undefined)
+    if (!override) {
         return base;
+    }
     return {
         enabled: override.enabled ?? base.enabled,
         protectedTools: [...new Set([...base.protectedTools, ...(override.protectedTools ?? [])])],
@@ -665,24 +575,16 @@ function deepCloneConfig(config) {
         },
         turnProtection: { ...config.turnProtection },
         protectedFilePatterns: [...config.protectedFilePatterns],
-        tools: {
-            settings: {
-                ...config.tools.settings,
-                protectedTools: [...config.tools.settings.protectedTools],
-                modelLimits: { ...config.tools.settings.modelLimits },
-            },
-            distill: { ...config.tools.distill },
-            compress: { ...config.tools.compress },
-            prune: { ...config.tools.prune },
+        compress: {
+            ...config.compress,
+            modelLimits: { ...config.compress.modelLimits },
         },
         strategies: {
             deduplication: {
                 ...config.strategies.deduplication,
                 protectedTools: [...config.strategies.deduplication.protectedTools],
             },
-            supersedeWrites: {
-                ...config.strategies.supersedeWrites,
-            },
+            supersedeWrites: { ...config.strategies.supersedeWrites },
             purgeErrors: {
                 ...config.strategies.purgeErrors,
                 protectedTools: [...config.strategies.purgeErrors.protectedTools],
@@ -690,141 +592,65 @@ function deepCloneConfig(config) {
         },
     };
 }
+function mergeLayer(config, data) {
+    return {
+        enabled: data.enabled ?? config.enabled,
+        debug: data.debug ?? config.debug,
+        pruneNotification: data.pruneNotification ?? config.pruneNotification,
+        pruneNotificationType: data.pruneNotificationType ?? config.pruneNotificationType,
+        commands: mergeCommands(config.commands, data.commands),
+        manualMode: mergeManualMode(config.manualMode, data.manualMode),
+        turnProtection: {
+            enabled: data.turnProtection?.enabled ?? config.turnProtection.enabled,
+            turns: data.turnProtection?.turns ?? config.turnProtection.turns,
+        },
+        protectedFilePatterns: [
+            ...new Set([...config.protectedFilePatterns, ...(data.protectedFilePatterns ?? [])]),
+        ],
+        compress: mergeCompress(config.compress, data.compress),
+        strategies: mergeStrategies(config.strategies, data.strategies),
+    };
+}
+function scheduleParseWarning(ctx, title, message) {
+    setTimeout(() => {
+        try {
+            ctx.client.tui.showToast({
+                body: {
+                    title,
+                    message,
+                    variant: "warning",
+                    duration: 7000,
+                },
+            });
+        }
+        catch { }
+    }, 7000);
+}
 export function getConfig(ctx) {
     let config = deepCloneConfig(defaultConfig);
     const configPaths = getConfigPaths(ctx);
-    // Load and merge global config
-    if (configPaths.global) {
-        const result = loadConfigFile(configPaths.global);
-        if (result.parseError) {
-            setTimeout(async () => {
-                try {
-                    ctx.client.tui.showToast({
-                        body: {
-                            title: "DCP: Invalid config",
-                            message: `${configPaths.global}\n${result.parseError}\nUsing default values`,
-                            variant: "warning",
-                            duration: 7000,
-                        },
-                    });
-                }
-                catch { }
-            }, 7000);
-        }
-        else if (result.data) {
-            // Validate config keys and types
-            showConfigValidationWarnings(ctx, configPaths.global, result.data, false);
-            config = {
-                enabled: result.data.enabled ?? config.enabled,
-                debug: result.data.debug ?? config.debug,
-                pruneNotification: result.data.pruneNotification ?? config.pruneNotification,
-                pruneNotificationType: result.data.pruneNotificationType ?? config.pruneNotificationType,
-                commands: mergeCommands(config.commands, result.data.commands),
-                manualMode: mergeManualMode(config.manualMode, result.data.manualMode),
-                turnProtection: {
-                    enabled: result.data.turnProtection?.enabled ?? config.turnProtection.enabled,
-                    turns: result.data.turnProtection?.turns ?? config.turnProtection.turns,
-                },
-                protectedFilePatterns: [
-                    ...new Set([
-                        ...config.protectedFilePatterns,
-                        ...(result.data.protectedFilePatterns ?? []),
-                    ]),
-                ],
-                tools: mergeTools(config.tools, result.data.tools),
-                strategies: mergeStrategies(config.strategies, result.data.strategies),
-            };
-        }
-    }
-    else {
-        // No config exists, create default
+    if (!configPaths.global) {
         createDefaultConfig();
     }
-    // Load and merge $OPENCODE_CONFIG_DIR/dcp.jsonc|json (overrides global)
-    if (configPaths.configDir) {
-        const result = loadConfigFile(configPaths.configDir);
-        if (result.parseError) {
-            setTimeout(async () => {
-                try {
-                    ctx.client.tui.showToast({
-                        body: {
-                            title: "DCP: Invalid configDir config",
-                            message: `${configPaths.configDir}\n${result.parseError}\nUsing global/default values`,
-                            variant: "warning",
-                            duration: 7000,
-                        },
-                    });
-                }
-                catch { }
-            }, 7000);
-        }
-        else if (result.data) {
-            // Validate config keys and types
-            showConfigValidationWarnings(ctx, configPaths.configDir, result.data, true);
-            config = {
-                enabled: result.data.enabled ?? config.enabled,
-                debug: result.data.debug ?? config.debug,
-                pruneNotification: result.data.pruneNotification ?? config.pruneNotification,
-                pruneNotificationType: result.data.pruneNotificationType ?? config.pruneNotificationType,
-                commands: mergeCommands(config.commands, result.data.commands),
-                manualMode: mergeManualMode(config.manualMode, result.data.manualMode),
-                turnProtection: {
-                    enabled: result.data.turnProtection?.enabled ?? config.turnProtection.enabled,
-                    turns: result.data.turnProtection?.turns ?? config.turnProtection.turns,
-                },
-                protectedFilePatterns: [
-                    ...new Set([
-                        ...config.protectedFilePatterns,
-                        ...(result.data.protectedFilePatterns ?? []),
-                    ]),
-                ],
-                tools: mergeTools(config.tools, result.data.tools),
-                strategies: mergeStrategies(config.strategies, result.data.strategies),
-            };
+    const layers = [
+        { path: configPaths.global, name: "config", isProject: false },
+        { path: configPaths.configDir, name: "configDir config", isProject: true },
+        { path: configPaths.project, name: "project config", isProject: true },
+    ];
+    for (const layer of layers) {
+        if (!layer.path) {
+            continue;
         }
-    }
-    // Load and merge project config (overrides global)
-    if (configPaths.project) {
-        const result = loadConfigFile(configPaths.project);
+        const result = loadConfigFile(layer.path);
         if (result.parseError) {
-            setTimeout(async () => {
-                try {
-                    ctx.client.tui.showToast({
-                        body: {
-                            title: "DCP: Invalid project config",
-                            message: `${configPaths.project}\n${result.parseError}\nUsing global/default values`,
-                            variant: "warning",
-                            duration: 7000,
-                        },
-                    });
-                }
-                catch { }
-            }, 7000);
+            scheduleParseWarning(ctx, `DCP: Invalid ${layer.name}`, `${layer.path}\n${result.parseError}\nUsing previous/default values`);
+            continue;
         }
-        else if (result.data) {
-            // Validate config keys and types
-            showConfigValidationWarnings(ctx, configPaths.project, result.data, true);
-            config = {
-                enabled: result.data.enabled ?? config.enabled,
-                debug: result.data.debug ?? config.debug,
-                pruneNotification: result.data.pruneNotification ?? config.pruneNotification,
-                pruneNotificationType: result.data.pruneNotificationType ?? config.pruneNotificationType,
-                commands: mergeCommands(config.commands, result.data.commands),
-                manualMode: mergeManualMode(config.manualMode, result.data.manualMode),
-                turnProtection: {
-                    enabled: result.data.turnProtection?.enabled ?? config.turnProtection.enabled,
-                    turns: result.data.turnProtection?.turns ?? config.turnProtection.turns,
-                },
-                protectedFilePatterns: [
-                    ...new Set([
-                        ...config.protectedFilePatterns,
-                        ...(result.data.protectedFilePatterns ?? []),
-                    ]),
-                ],
-                tools: mergeTools(config.tools, result.data.tools),
-                strategies: mergeStrategies(config.strategies, result.data.strategies),
-            };
+        if (!result.data) {
+            continue;
         }
+        showConfigValidationWarnings(ctx, layer.path, result.data, layer.isProject);
+        config = mergeLayer(config, result.data);
     }
     return config;
 }