@tarquinen/opencode-dcp 1.1.0-beta.1 → 1.1.0-beta.2

package/dist/lib/config.js

@@ -1,59 +1,51 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync } from 'fs';
-import { join, dirname } from 'path';
-import { homedir } from 'os';
-import { parse } from 'jsonc-parser';
-const DEFAULT_PROTECTED_TOOLS = ['task', 'todowrite', 'todoread', 'discard', 'extract', 'batch'];
+import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { parse } from "jsonc-parser";
+const DEFAULT_PROTECTED_TOOLS = ["task", "todowrite", "todoread", "discard", "extract", "batch"];
 // Valid config keys for validation against user config
 export const VALID_CONFIG_KEYS = new Set([
     // Top-level keys
-    'enabled',
-    'debug',
-    'showUpdateToasts', // Deprecated but kept for backwards compatibility
-    'pruningSummary',
-    'strategies',
+    "enabled",
+    "debug",
+    "showUpdateToasts", // Deprecated but kept for backwards compatibility
+    "pruneNotification",
+    "turnProtection",
+    "turnProtection.enabled",
+    "turnProtection.turns",
+    "tools",
+    "tools.settings",
+    "tools.settings.nudgeEnabled",
+    "tools.settings.nudgeFrequency",
+    "tools.settings.protectedTools",
+    "tools.discard",
+    "tools.discard.enabled",
+    "tools.extract",
+    "tools.extract.enabled",
+    "tools.extract.showDistillation",
+    "strategies",
     // strategies.deduplication
-    'strategies.deduplication',
-    'strategies.deduplication.enabled',
-    'strategies.deduplication.protectedTools',
+    "strategies.deduplication",
+    "strategies.deduplication.enabled",
+    "strategies.deduplication.protectedTools",
     // strategies.supersedeWrites
-    'strategies.supersedeWrites',
-    'strategies.supersedeWrites.enabled',
+    "strategies.supersedeWrites",
+    "strategies.supersedeWrites.enabled",
     // strategies.onIdle
-    'strategies.onIdle',
-    'strategies.onIdle.enabled',
-    'strategies.onIdle.model',
-    'strategies.onIdle.showModelErrorToasts',
-    'strategies.onIdle.strictModelSelection',
-    'strategies.onIdle.protectedTools',
-    // strategies.discardTool
-    'strategies.discardTool',
-    'strategies.discardTool.enabled',
-    'strategies.discardTool.protectedTools',
-    'strategies.discardTool.turnProtection',
-    'strategies.discardTool.turnProtection.enabled',
-    'strategies.discardTool.turnProtection.turns',
-    'strategies.discardTool.nudge',
-    'strategies.discardTool.nudge.enabled',
-    'strategies.discardTool.nudge.frequency',
-    // strategies.extractTool
-    'strategies.extractTool',
-    'strategies.extractTool.enabled',
-    'strategies.extractTool.protectedTools',
-    'strategies.extractTool.turnProtection',
-    'strategies.extractTool.turnProtection.enabled',
-    'strategies.extractTool.turnProtection.turns',
-    'strategies.extractTool.nudge',
-    'strategies.extractTool.nudge.enabled',
-    'strategies.extractTool.nudge.frequency',
-    'strategies.extractTool.showDistillation'
+    "strategies.onIdle",
+    "strategies.onIdle.enabled",
+    "strategies.onIdle.model",
+    "strategies.onIdle.showModelErrorToasts",
+    "strategies.onIdle.strictModelSelection",
+    "strategies.onIdle.protectedTools",
 ]);
 // Extract all key paths from a config object for validation
-function getConfigKeyPaths(obj, prefix = '') {
+function getConfigKeyPaths(obj, prefix = "") {
     const keys = [];
     for (const key of Object.keys(obj)) {
         const fullKey = prefix ? `${prefix}.${key}` : key;
         keys.push(fullKey);
-        if (obj[key] && typeof obj[key] === 'object' && !Array.isArray(obj[key])) {
+        if (obj[key] && typeof obj[key] === "object" && !Array.isArray(obj[key])) {
             keys.push(...getConfigKeyPaths(obj[key], fullKey));
         }
     }
@@ -62,108 +54,174 @@ function getConfigKeyPaths(obj, prefix = '') {
 // Returns invalid keys found in user config
 export function getInvalidConfigKeys(userConfig) {
     const userKeys = getConfigKeyPaths(userConfig);
-    return userKeys.filter(key => !VALID_CONFIG_KEYS.has(key));
+    return userKeys.filter((key) => !VALID_CONFIG_KEYS.has(key));
 }
 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 });
+    if (config.enabled !== undefined && typeof config.enabled !== "boolean") {
+        errors.push({ key: "enabled", expected: "boolean", actual: typeof config.enabled });
     }
-    if (config.debug !== undefined && typeof config.debug !== 'boolean') {
-        errors.push({ key: 'debug', expected: 'boolean', actual: typeof config.debug });
+    if (config.debug !== undefined && typeof config.debug !== "boolean") {
+        errors.push({ key: "debug", expected: "boolean", actual: typeof config.debug });
     }
-    if (config.pruningSummary !== undefined) {
-        const validValues = ['off', 'minimal', 'detailed'];
-        if (!validValues.includes(config.pruningSummary)) {
-            errors.push({ key: 'pruningSummary', expected: '"off" | "minimal" | "detailed"', actual: JSON.stringify(config.pruningSummary) });
+    if (config.pruneNotification !== undefined) {
+        const validValues = ["off", "minimal", "detailed"];
+        if (!validValues.includes(config.pruneNotification)) {
+            errors.push({
+                key: "pruneNotification",
+                expected: '"off" | "minimal" | "detailed"',
+                actual: JSON.stringify(config.pruneNotification),
+            });
         }
     }
-    // Strategies validators
-    const strategies = config.strategies;
-    if (strategies) {
-        // deduplication
-        if (strategies.deduplication?.enabled !== undefined && typeof strategies.deduplication.enabled !== 'boolean') {
-            errors.push({ key: 'strategies.deduplication.enabled', expected: 'boolean', actual: typeof strategies.deduplication.enabled });
+    // Top-level turnProtection validator
+    if (config.turnProtection) {
+        if (config.turnProtection.enabled !== undefined &&
+            typeof config.turnProtection.enabled !== "boolean") {
+            errors.push({
+                key: "turnProtection.enabled",
+                expected: "boolean",
+                actual: typeof config.turnProtection.enabled,
+            });
         }
-        if (strategies.deduplication?.protectedTools !== undefined && !Array.isArray(strategies.deduplication.protectedTools)) {
-            errors.push({ key: 'strategies.deduplication.protectedTools', expected: 'string[]', actual: typeof strategies.deduplication.protectedTools });
+        if (config.turnProtection.turns !== undefined &&
+            typeof config.turnProtection.turns !== "number") {
+            errors.push({
+                key: "turnProtection.turns",
+                expected: "number",
+                actual: typeof config.turnProtection.turns,
+            });
         }
-        // onIdle
-        if (strategies.onIdle) {
-            if (strategies.onIdle.enabled !== undefined && typeof strategies.onIdle.enabled !== 'boolean') {
-                errors.push({ key: 'strategies.onIdle.enabled', expected: 'boolean', actual: typeof strategies.onIdle.enabled });
-            }
-            if (strategies.onIdle.model !== undefined && typeof strategies.onIdle.model !== 'string') {
-                errors.push({ key: 'strategies.onIdle.model', expected: 'string', actual: typeof strategies.onIdle.model });
-            }
-            if (strategies.onIdle.showModelErrorToasts !== undefined && typeof strategies.onIdle.showModelErrorToasts !== 'boolean') {
-                errors.push({ key: 'strategies.onIdle.showModelErrorToasts', expected: 'boolean', actual: typeof strategies.onIdle.showModelErrorToasts });
+    }
+    // Tools validators
+    const tools = config.tools;
+    if (tools) {
+        if (tools.settings) {
+            if (tools.settings.nudgeEnabled !== undefined &&
+                typeof tools.settings.nudgeEnabled !== "boolean") {
+                errors.push({
+                    key: "tools.settings.nudgeEnabled",
+                    expected: "boolean",
+                    actual: typeof tools.settings.nudgeEnabled,
+                });
             }
-            if (strategies.onIdle.strictModelSelection !== undefined && typeof strategies.onIdle.strictModelSelection !== 'boolean') {
-                errors.push({ key: 'strategies.onIdle.strictModelSelection', expected: 'boolean', actual: typeof strategies.onIdle.strictModelSelection });
+            if (tools.settings.nudgeFrequency !== undefined &&
+                typeof tools.settings.nudgeFrequency !== "number") {
+                errors.push({
+                    key: "tools.settings.nudgeFrequency",
+                    expected: "number",
+                    actual: typeof tools.settings.nudgeFrequency,
+                });
             }
-            if (strategies.onIdle.protectedTools !== undefined && !Array.isArray(strategies.onIdle.protectedTools)) {
-                errors.push({ key: 'strategies.onIdle.protectedTools', expected: 'string[]', actual: typeof strategies.onIdle.protectedTools });
+            if (tools.settings.protectedTools !== undefined &&
+                !Array.isArray(tools.settings.protectedTools)) {
+                errors.push({
+                    key: "tools.settings.protectedTools",
+                    expected: "string[]",
+                    actual: typeof tools.settings.protectedTools,
+                });
             }
         }
-        // discardTool
-        if (strategies.discardTool) {
-            if (strategies.discardTool.enabled !== undefined && typeof strategies.discardTool.enabled !== 'boolean') {
-                errors.push({ key: 'strategies.discardTool.enabled', expected: 'boolean', actual: typeof strategies.discardTool.enabled });
-            }
-            if (strategies.discardTool.protectedTools !== undefined && !Array.isArray(strategies.discardTool.protectedTools)) {
-                errors.push({ key: 'strategies.discardTool.protectedTools', expected: 'string[]', actual: typeof strategies.discardTool.protectedTools });
+        if (tools.discard) {
+            if (tools.discard.enabled !== undefined && typeof tools.discard.enabled !== "boolean") {
+                errors.push({
+                    key: "tools.discard.enabled",
+                    expected: "boolean",
+                    actual: typeof tools.discard.enabled,
+                });
             }
-            if (strategies.discardTool.turnProtection) {
-                if (strategies.discardTool.turnProtection.enabled !== undefined && typeof strategies.discardTool.turnProtection.enabled !== 'boolean') {
-                    errors.push({ key: 'strategies.discardTool.turnProtection.enabled', expected: 'boolean', actual: typeof strategies.discardTool.turnProtection.enabled });
-                }
-                if (strategies.discardTool.turnProtection.turns !== undefined && typeof strategies.discardTool.turnProtection.turns !== 'number') {
-                    errors.push({ key: 'strategies.discardTool.turnProtection.turns', expected: 'number', actual: typeof strategies.discardTool.turnProtection.turns });
-                }
+        }
+        if (tools.extract) {
+            if (tools.extract.enabled !== undefined && typeof tools.extract.enabled !== "boolean") {
+                errors.push({
+                    key: "tools.extract.enabled",
+                    expected: "boolean",
+                    actual: typeof tools.extract.enabled,
+                });
             }
-            if (strategies.discardTool.nudge) {
-                if (strategies.discardTool.nudge.enabled !== undefined && typeof strategies.discardTool.nudge.enabled !== 'boolean') {
-                    errors.push({ key: 'strategies.discardTool.nudge.enabled', expected: 'boolean', actual: typeof strategies.discardTool.nudge.enabled });
-                }
-                if (strategies.discardTool.nudge.frequency !== undefined && typeof strategies.discardTool.nudge.frequency !== 'number') {
-                    errors.push({ key: 'strategies.discardTool.nudge.frequency', expected: 'number', actual: typeof strategies.discardTool.nudge.frequency });
-                }
+            if (tools.extract.showDistillation !== undefined &&
+                typeof tools.extract.showDistillation !== "boolean") {
+                errors.push({
+                    key: "tools.extract.showDistillation",
+                    expected: "boolean",
+                    actual: typeof tools.extract.showDistillation,
+                });
             }
         }
-        // extractTool
-        if (strategies.extractTool) {
-            if (strategies.extractTool.enabled !== undefined && typeof strategies.extractTool.enabled !== 'boolean') {
-                errors.push({ key: 'strategies.extractTool.enabled', expected: 'boolean', actual: typeof strategies.extractTool.enabled });
+    }
+    // Strategies validators
+    const strategies = config.strategies;
+    if (strategies) {
+        // deduplication
+        if (strategies.deduplication?.enabled !== undefined &&
+            typeof strategies.deduplication.enabled !== "boolean") {
+            errors.push({
+                key: "strategies.deduplication.enabled",
+                expected: "boolean",
+                actual: typeof strategies.deduplication.enabled,
+            });
+        }
+        if (strategies.deduplication?.protectedTools !== undefined &&
+            !Array.isArray(strategies.deduplication.protectedTools)) {
+            errors.push({
+                key: "strategies.deduplication.protectedTools",
+                expected: "string[]",
+                actual: typeof strategies.deduplication.protectedTools,
+            });
+        }
+        // onIdle
+        if (strategies.onIdle) {
+            if (strategies.onIdle.enabled !== undefined &&
+                typeof strategies.onIdle.enabled !== "boolean") {
+                errors.push({
+                    key: "strategies.onIdle.enabled",
+                    expected: "boolean",
+                    actual: typeof strategies.onIdle.enabled,
+                });
             }
-            if (strategies.extractTool.protectedTools !== undefined && !Array.isArray(strategies.extractTool.protectedTools)) {
-                errors.push({ key: 'strategies.extractTool.protectedTools', expected: 'string[]', actual: typeof strategies.extractTool.protectedTools });
+            if (strategies.onIdle.model !== undefined &&
+                typeof strategies.onIdle.model !== "string") {
+                errors.push({
+                    key: "strategies.onIdle.model",
+                    expected: "string",
+                    actual: typeof strategies.onIdle.model,
+                });
             }
-            if (strategies.extractTool.turnProtection) {
-                if (strategies.extractTool.turnProtection.enabled !== undefined && typeof strategies.extractTool.turnProtection.enabled !== 'boolean') {
-                    errors.push({ key: 'strategies.extractTool.turnProtection.enabled', expected: 'boolean', actual: typeof strategies.extractTool.turnProtection.enabled });
-                }
-                if (strategies.extractTool.turnProtection.turns !== undefined && typeof strategies.extractTool.turnProtection.turns !== 'number') {
-                    errors.push({ key: 'strategies.extractTool.turnProtection.turns', expected: 'number', actual: typeof strategies.extractTool.turnProtection.turns });
-                }
+            if (strategies.onIdle.showModelErrorToasts !== undefined &&
+                typeof strategies.onIdle.showModelErrorToasts !== "boolean") {
+                errors.push({
+                    key: "strategies.onIdle.showModelErrorToasts",
+                    expected: "boolean",
+                    actual: typeof strategies.onIdle.showModelErrorToasts,
+                });
             }
-            if (strategies.extractTool.nudge) {
-                if (strategies.extractTool.nudge.enabled !== undefined && typeof strategies.extractTool.nudge.enabled !== 'boolean') {
-                    errors.push({ key: 'strategies.extractTool.nudge.enabled', expected: 'boolean', actual: typeof strategies.extractTool.nudge.enabled });
-                }
-                if (strategies.extractTool.nudge.frequency !== undefined && typeof strategies.extractTool.nudge.frequency !== 'number') {
-                    errors.push({ key: 'strategies.extractTool.nudge.frequency', expected: 'number', actual: typeof strategies.extractTool.nudge.frequency });
-                }
+            if (strategies.onIdle.strictModelSelection !== undefined &&
+                typeof strategies.onIdle.strictModelSelection !== "boolean") {
+                errors.push({
+                    key: "strategies.onIdle.strictModelSelection",
+                    expected: "boolean",
+                    actual: typeof strategies.onIdle.strictModelSelection,
+                });
             }
-            if (strategies.extractTool.showDistillation !== undefined && typeof strategies.extractTool.showDistillation !== 'boolean') {
-                errors.push({ key: 'strategies.extractTool.showDistillation', expected: 'boolean', actual: typeof strategies.extractTool.showDistillation });
+            if (strategies.onIdle.protectedTools !== undefined &&
+                !Array.isArray(strategies.onIdle.protectedTools)) {
+                errors.push({
+                    key: "strategies.onIdle.protectedTools",
+                    expected: "string[]",
+                    actual: typeof strategies.onIdle.protectedTools,
+                });
             }
         }
         // supersedeWrites
         if (strategies.supersedeWrites) {
-            if (strategies.supersedeWrites.enabled !== undefined && typeof strategies.supersedeWrites.enabled !== 'boolean') {
-                errors.push({ key: 'strategies.supersedeWrites.enabled', expected: 'boolean', actual: typeof strategies.supersedeWrites.enabled });
+            if (strategies.supersedeWrites.enabled !== undefined &&
+                typeof strategies.supersedeWrites.enabled !== "boolean") {
+                errors.push({
+                    key: "strategies.supersedeWrites.enabled",
+                    expected: "boolean",
+                    actual: typeof strategies.supersedeWrites.enabled,
+                });
             }
         }
     }
@@ -176,11 +234,11 @@ function showConfigValidationWarnings(ctx, configPath, configData, isProject) {
     if (invalidKeys.length === 0 && typeErrors.length === 0) {
         return;
     }
-    const configType = isProject ? 'project config' : 'config';
+    const configType = isProject ? "project config" : "config";
     const messages = [];
     if (invalidKeys.length > 0) {
-        const keyList = invalidKeys.slice(0, 3).join(', ');
-        const suffix = invalidKeys.length > 3 ? ` (+${invalidKeys.length - 3} more)` : '';
+        const keyList = invalidKeys.slice(0, 3).join(", ");
+        const suffix = invalidKeys.length > 3 ? ` (+${invalidKeys.length - 3} more)` : "";
         messages.push(`Unknown keys: ${keyList}${suffix}`);
     }
     if (typeErrors.length > 0) {
@@ -196,10 +254,10 @@ function showConfigValidationWarnings(ctx, configPath, configData, isProject) {
             ctx.client.tui.showToast({
                 body: {
                     title: `DCP: Invalid ${configType}`,
-                    message: `${configPath}\n${messages.join('\n')}`,
+                    message: `${configPath}\n${messages.join("\n")}`,
                     variant: "warning",
-                    duration: 7000
-                }
+                    duration: 7000,
+                },
             });
         }
         catch { }
@@ -208,55 +266,48 @@ function showConfigValidationWarnings(ctx, configPath, configData, isProject) {
 const defaultConfig = {
     enabled: true,
     debug: false,
-    pruningSummary: 'detailed',
-    strategies: {
-        deduplication: {
+    pruneNotification: "detailed",
+    turnProtection: {
+        enabled: false,
+        turns: 4,
+    },
+    tools: {
+        settings: {
+            nudgeEnabled: true,
+            nudgeFrequency: 10,
+            protectedTools: [...DEFAULT_PROTECTED_TOOLS],
+        },
+        discard: {
             enabled: true,
-            protectedTools: [...DEFAULT_PROTECTED_TOOLS]
         },
-        supersedeWrites: {
-            enabled: true
+        extract: {
+            enabled: true,
+            showDistillation: false,
         },
-        discardTool: {
+    },
+    strategies: {
+        deduplication: {
             enabled: true,
             protectedTools: [...DEFAULT_PROTECTED_TOOLS],
-            turnProtection: {
-                enabled: false,
-                turns: 4
-            },
-            nudge: {
-                enabled: true,
-                frequency: 10
-            }
         },
-        extractTool: {
+        supersedeWrites: {
             enabled: true,
-            protectedTools: [...DEFAULT_PROTECTED_TOOLS],
-            turnProtection: {
-                enabled: false,
-                turns: 4
-            },
-            nudge: {
-                enabled: true,
-                frequency: 10
-            },
-            showDistillation: false
         },
         onIdle: {
             enabled: false,
             protectedTools: [...DEFAULT_PROTECTED_TOOLS],
             showModelErrorToasts: true,
-            strictModelSelection: false
-        }
-    }
+            strictModelSelection: false,
+        },
+    },
 };
-const GLOBAL_CONFIG_DIR = join(homedir(), '.config', 'opencode');
-const GLOBAL_CONFIG_PATH_JSONC = join(GLOBAL_CONFIG_DIR, 'dcp.jsonc');
-const GLOBAL_CONFIG_PATH_JSON = join(GLOBAL_CONFIG_DIR, 'dcp.json');
+const GLOBAL_CONFIG_DIR = join(homedir(), ".config", "opencode");
+const GLOBAL_CONFIG_PATH_JSONC = join(GLOBAL_CONFIG_DIR, "dcp.jsonc");
+const GLOBAL_CONFIG_PATH_JSON = join(GLOBAL_CONFIG_DIR, "dcp.json");
 function findOpencodeDir(startDir) {
     let current = startDir;
-    while (current !== '/') {
-        const candidate = join(current, '.opencode');
+    while (current !== "/") {
+        const candidate = join(current, ".opencode");
         if (existsSync(candidate) && statSync(candidate).isDirectory()) {
             return candidate;
         }
@@ -280,8 +331,8 @@ function getConfigPaths(ctx) {
     let configDirPath = null;
     const opencodeConfigDir = process.env.OPENCODE_CONFIG_DIR;
     if (opencodeConfigDir) {
-        const configJsonc = join(opencodeConfigDir, 'dcp.jsonc');
-        const configJson = join(opencodeConfigDir, 'dcp.json');
+        const configJsonc = join(opencodeConfigDir, "dcp.jsonc");
+        const configJson = join(opencodeConfigDir, "dcp.json");
         if (existsSync(configJsonc)) {
             configDirPath = configJsonc;
         }
@@ -294,8 +345,8 @@ function getConfigPaths(ctx) {
     if (ctx?.directory) {
         const opencodeDir = findOpencodeDir(ctx.directory);
         if (opencodeDir) {
-            const projectJsonc = join(opencodeDir, 'dcp.jsonc');
-            const projectJson = join(opencodeDir, 'dcp.json');
+            const projectJsonc = join(opencodeDir, "dcp.jsonc");
+            const projectJson = join(opencodeDir, "dcp.json");
             if (existsSync(projectJsonc)) {
                 projectPath = projectJsonc;
             }
@@ -315,9 +366,35 @@ function createDefaultConfig() {
   "enabled": true,
   // Enable debug logging to ~/.config/opencode/logs/dcp/
   "debug": false,
-  // Summary display: "off", "minimal", or "detailed"
-  "pruningSummary": "detailed",
-  // Strategies for pruning tokens from chat history
+  // Notification display: "off", "minimal", or "detailed"
+  "pruneNotification": "detailed",
+  // Protect from pruning for <turns> message turns
+  "turnProtection": {
+    "enabled": false,
+    "turns": 4
+  },
+  // LLM-driven context pruning tools
+  "tools": {
+    // Shared settings for all prune tools
+    "settings": {
+      // Nudge the LLM to use prune tools (every <nudgeFrequency> tool results)
+      "nudgeEnabled": true,
+      "nudgeFrequency": 10,
+      // Additional tools to protect from pruning
+      "protectedTools": []
+    },
+    // Removes tool content from context without preservation (for completed tasks or noise)
+    "discard": {
+      "enabled": true
+    },
+    // Distills key findings into preserved knowledge before removing raw content
+    "extract": {
+      "enabled": true,
+      // Show distillation content as an ignored message notification
+      "showDistillation": false
+    }
+  },
+  // Automatic pruning strategies
   "strategies": {
     // Remove duplicate tool calls (same tool with same arguments)
     "deduplication": {
@@ -329,40 +406,6 @@ function createDefaultConfig() {
     "supersedeWrites": {
       "enabled": true
     },
-    // Removes tool content from context without preservation (for completed tasks or noise)
-    "discardTool": {
-      "enabled": true,
-      // Additional tools to protect from pruning
-      "protectedTools": [],
-      // Protect from pruning for <turn protection> message turns
-      "turnProtection": {
-        "enabled": false,
-        "turns": 4
-      },
-      // Nudge the LLM to use the discard tool (every <frequency> tool results)
-      "nudge": {
-        "enabled": true,
-        "frequency": 10
-      }
-    },
-    // Distills key findings into preserved knowledge before removing raw content
-    "extractTool": {
-      "enabled": true,
-      // Additional tools to protect from pruning
-      "protectedTools": [],
-      // Protect from pruning for <turn protection> message turns
-      "turnProtection": {
-        "enabled": false,
-        "turns": 4
-      },
-      // Nudge the LLM to use the extract tool (every <frequency> tool results)
-      "nudge": {
-        "enabled": true,
-        "frequency": 10
-      },
-      // Show distillation content as an ignored message notification
-      "showDistillation": false
-    },
     // (Legacy) Run an LLM to analyze what tool calls are no longer relevant on idle
     "onIdle": {
       "enabled": false,
@@ -378,12 +421,12 @@ function createDefaultConfig() {
   }
 }
 `;
-    writeFileSync(GLOBAL_CONFIG_PATH_JSONC, configContent, 'utf-8');
+    writeFileSync(GLOBAL_CONFIG_PATH_JSONC, configContent, "utf-8");
 }
 function loadConfigFile(configPath) {
     let fileContent;
     try {
-        fileContent = readFileSync(configPath, 'utf-8');
+        fileContent = readFileSync(configPath, "utf-8");
     }
     catch {
         // File doesn't exist or can't be read - not a parse error
@@ -392,12 +435,12 @@ function loadConfigFile(configPath) {
     try {
         const parsed = parse(fileContent);
         if (parsed === undefined || parsed === null) {
-            return { data: null, parseError: 'Config file is empty or invalid' };
+            return { data: null, parseError: "Config file is empty or invalid" };
         }
         return { data: parsed };
     }
     catch (error) {
-        return { data: null, parseError: error.message || 'Failed to parse config' };
+        return { data: null, parseError: error.message || "Failed to parse config" };
     }
 }
 function mergeStrategies(base, override) {
@@ -409,9 +452,9 @@ function mergeStrategies(base, override) {
             protectedTools: [
                 ...new Set([
                     ...base.deduplication.protectedTools,
-                    ...(override.deduplication?.protectedTools ?? [])
-                ])
-            ]
+                    ...(override.deduplication?.protectedTools ?? []),
+                ]),
+            ],
         },
         onIdle: {
             enabled: override.onIdle?.enabled ?? base.onIdle.enabled,
@@ -421,79 +464,63 @@ function mergeStrategies(base, override) {
             protectedTools: [
                 ...new Set([
                     ...base.onIdle.protectedTools,
-                    ...(override.onIdle?.protectedTools ?? [])
-                ])
-            ]
-        },
-        discardTool: {
-            enabled: override.discardTool?.enabled ?? base.discardTool.enabled,
-            protectedTools: [
-                ...new Set([
-                    ...base.discardTool.protectedTools,
-                    ...(override.discardTool?.protectedTools ?? [])
-                ])
+                    ...(override.onIdle?.protectedTools ?? []),
+                ]),
             ],
-            turnProtection: {
-                enabled: override.discardTool?.turnProtection?.enabled ?? base.discardTool.turnProtection.enabled,
-                turns: override.discardTool?.turnProtection?.turns ?? base.discardTool.turnProtection.turns
-            },
-            nudge: {
-                enabled: override.discardTool?.nudge?.enabled ?? base.discardTool.nudge.enabled,
-                frequency: override.discardTool?.nudge?.frequency ?? base.discardTool.nudge.frequency
-            }
         },
-        extractTool: {
-            enabled: override.extractTool?.enabled ?? base.extractTool.enabled,
+        supersedeWrites: {
+            enabled: override.supersedeWrites?.enabled ?? base.supersedeWrites.enabled,
+        },
+    };
+}
+function mergeTools(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.extractTool.protectedTools,
-                    ...(override.extractTool?.protectedTools ?? [])
-                ])
+                    ...base.settings.protectedTools,
+                    ...(override.settings?.protectedTools ?? []),
+                ]),
             ],
-            turnProtection: {
-                enabled: override.extractTool?.turnProtection?.enabled ?? base.extractTool.turnProtection.enabled,
-                turns: override.extractTool?.turnProtection?.turns ?? base.extractTool.turnProtection.turns
-            },
-            nudge: {
-                enabled: override.extractTool?.nudge?.enabled ?? base.extractTool.nudge.enabled,
-                frequency: override.extractTool?.nudge?.frequency ?? base.extractTool.nudge.frequency
-            },
-            showDistillation: override.extractTool?.showDistillation ?? base.extractTool.showDistillation
         },
-        supersedeWrites: {
-            enabled: override.supersedeWrites?.enabled ?? base.supersedeWrites.enabled
-        }
+        discard: {
+            enabled: override.discard?.enabled ?? base.discard.enabled,
+        },
+        extract: {
+            enabled: override.extract?.enabled ?? base.extract.enabled,
+            showDistillation: override.extract?.showDistillation ?? base.extract.showDistillation,
+        },
     };
 }
 function deepCloneConfig(config) {
     return {
         ...config,
+        turnProtection: { ...config.turnProtection },
+        tools: {
+            settings: {
+                ...config.tools.settings,
+                protectedTools: [...config.tools.settings.protectedTools],
+            },
+            discard: { ...config.tools.discard },
+            extract: { ...config.tools.extract },
+        },
         strategies: {
             deduplication: {
                 ...config.strategies.deduplication,
-                protectedTools: [...config.strategies.deduplication.protectedTools]
+                protectedTools: [...config.strategies.deduplication.protectedTools],
             },
             onIdle: {
                 ...config.strategies.onIdle,
-                protectedTools: [...config.strategies.onIdle.protectedTools]
-            },
-            discardTool: {
-                ...config.strategies.discardTool,
-                protectedTools: [...config.strategies.discardTool.protectedTools],
-                turnProtection: { ...config.strategies.discardTool.turnProtection },
-                nudge: { ...config.strategies.discardTool.nudge }
-            },
-            extractTool: {
-                ...config.strategies.extractTool,
-                protectedTools: [...config.strategies.extractTool.protectedTools],
-                turnProtection: { ...config.strategies.extractTool.turnProtection },
-                nudge: { ...config.strategies.extractTool.nudge },
-                showDistillation: config.strategies.extractTool.showDistillation
+                protectedTools: [...config.strategies.onIdle.protectedTools],
             },
             supersedeWrites: {
-                ...config.strategies.supersedeWrites
-            }
-        }
+                ...config.strategies.supersedeWrites,
+            },
+        },
     };
 }
 export function getConfig(ctx) {
@@ -510,8 +537,8 @@ export function getConfig(ctx) {
                             title: "DCP: Invalid config",
                             message: `${configPaths.global}\n${result.parseError}\nUsing default values`,
                             variant: "warning",
-                            duration: 7000
-                        }
+                            duration: 7000,
+                        },
                     });
                 }
                 catch { }
@@ -523,8 +550,13 @@ export function getConfig(ctx) {
             config = {
                 enabled: result.data.enabled ?? config.enabled,
                 debug: result.data.debug ?? config.debug,
-                pruningSummary: result.data.pruningSummary ?? config.pruningSummary,
-                strategies: mergeStrategies(config.strategies, result.data.strategies)
+                pruneNotification: result.data.pruneNotification ?? config.pruneNotification,
+                turnProtection: {
+                    enabled: result.data.turnProtection?.enabled ?? config.turnProtection.enabled,
+                    turns: result.data.turnProtection?.turns ?? config.turnProtection.turns,
+                },
+                tools: mergeTools(config.tools, result.data.tools),
+                strategies: mergeStrategies(config.strategies, result.data.strategies),
             };
         }
     }
@@ -543,8 +575,8 @@ export function getConfig(ctx) {
                             title: "DCP: Invalid configDir config",
                             message: `${configPaths.configDir}\n${result.parseError}\nUsing global/default values`,
                             variant: "warning",
-                            duration: 7000
-                        }
+                            duration: 7000,
+                        },
                     });
                 }
                 catch { }
@@ -556,8 +588,13 @@ export function getConfig(ctx) {
             config = {
                 enabled: result.data.enabled ?? config.enabled,
                 debug: result.data.debug ?? config.debug,
-                pruningSummary: result.data.pruningSummary ?? config.pruningSummary,
-                strategies: mergeStrategies(config.strategies, result.data.strategies)
+                pruneNotification: result.data.pruneNotification ?? config.pruneNotification,
+                turnProtection: {
+                    enabled: result.data.turnProtection?.enabled ?? config.turnProtection.enabled,
+                    turns: result.data.turnProtection?.turns ?? config.turnProtection.turns,
+                },
+                tools: mergeTools(config.tools, result.data.tools),
+                strategies: mergeStrategies(config.strategies, result.data.strategies),
             };
         }
     }
@@ -572,8 +609,8 @@ export function getConfig(ctx) {
                             title: "DCP: Invalid project config",
                             message: `${configPaths.project}\n${result.parseError}\nUsing global/default values`,
                             variant: "warning",
-                            duration: 7000
-                        }
+                            duration: 7000,
+                        },
                     });
                 }
                 catch { }
@@ -585,8 +622,13 @@ export function getConfig(ctx) {
             config = {
                 enabled: result.data.enabled ?? config.enabled,
                 debug: result.data.debug ?? config.debug,
-                pruningSummary: result.data.pruningSummary ?? config.pruningSummary,
-                strategies: mergeStrategies(config.strategies, result.data.strategies)
+                pruneNotification: result.data.pruneNotification ?? config.pruneNotification,
+                turnProtection: {
+                    enabled: result.data.turnProtection?.enabled ?? config.turnProtection.enabled,
+                    turns: result.data.turnProtection?.turns ?? config.turnProtection.turns,
+                },
+                tools: mergeTools(config.tools, result.data.tools),
+                strategies: mergeStrategies(config.strategies, result.data.strategies),
             };
         }
     }