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

package/dist/lib/config.js

@@ -1,45 +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', 'prune', '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.pruneTool
-    'strategies.pruneTool',
-    'strategies.pruneTool.enabled',
-    'strategies.pruneTool.protectedTools',
-    'strategies.pruneTool.nudge',
-    'strategies.pruneTool.nudge.enabled',
-    'strategies.pruneTool.nudge.frequency'
+    "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));
         }
     }
@@ -48,72 +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),
+            });
+        }
+    }
+    // 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 (config.turnProtection.turns !== undefined &&
+            typeof config.turnProtection.turns !== "number") {
+            errors.push({
+                key: "turnProtection.turns",
+                expected: "number",
+                actual: typeof config.turnProtection.turns,
+            });
+        }
+    }
+    // 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 (tools.settings.nudgeFrequency !== undefined &&
+                typeof tools.settings.nudgeFrequency !== "number") {
+                errors.push({
+                    key: "tools.settings.nudgeFrequency",
+                    expected: "number",
+                    actual: typeof tools.settings.nudgeFrequency,
+                });
+            }
+            if (tools.settings.protectedTools !== undefined &&
+                !Array.isArray(tools.settings.protectedTools)) {
+                errors.push({
+                    key: "tools.settings.protectedTools",
+                    expected: "string[]",
+                    actual: typeof tools.settings.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 (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 (tools.extract.showDistillation !== undefined &&
+                typeof tools.extract.showDistillation !== "boolean") {
+                errors.push({
+                    key: "tools.extract.showDistillation",
+                    expected: "boolean",
+                    actual: typeof tools.extract.showDistillation,
+                });
+            }
         }
     }
     // 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?.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 });
+        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.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.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 });
+            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.onIdle.strictModelSelection !== undefined && typeof strategies.onIdle.strictModelSelection !== 'boolean') {
-                errors.push({ key: 'strategies.onIdle.strictModelSelection', expected: 'boolean', actual: typeof strategies.onIdle.strictModelSelection });
+            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.onIdle.protectedTools !== undefined && !Array.isArray(strategies.onIdle.protectedTools)) {
-                errors.push({ key: 'strategies.onIdle.protectedTools', expected: 'string[]', actual: typeof strategies.onIdle.protectedTools });
-            }
-        }
-        // pruneTool
-        if (strategies.pruneTool) {
-            if (strategies.pruneTool.enabled !== undefined && typeof strategies.pruneTool.enabled !== 'boolean') {
-                errors.push({ key: 'strategies.pruneTool.enabled', expected: 'boolean', actual: typeof strategies.pruneTool.enabled });
-            }
-            if (strategies.pruneTool.protectedTools !== undefined && !Array.isArray(strategies.pruneTool.protectedTools)) {
-                errors.push({ key: 'strategies.pruneTool.protectedTools', expected: 'string[]', actual: typeof strategies.pruneTool.protectedTools });
-            }
-            if (strategies.pruneTool.nudge) {
-                if (strategies.pruneTool.nudge.enabled !== undefined && typeof strategies.pruneTool.nudge.enabled !== 'boolean') {
-                    errors.push({ key: 'strategies.pruneTool.nudge.enabled', expected: 'boolean', actual: typeof strategies.pruneTool.nudge.enabled });
-                }
-                if (strategies.pruneTool.nudge.frequency !== undefined && typeof strategies.pruneTool.nudge.frequency !== 'number') {
-                    errors.push({ key: 'strategies.pruneTool.nudge.frequency', expected: 'number', actual: typeof strategies.pruneTool.nudge.frequency });
-                }
+            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,
+                });
             }
         }
     }
@@ -126,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) {
@@ -146,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 { }
@@ -158,38 +266,48 @@ function showConfigValidationWarnings(ctx, configPath, configData, isProject) {
 const defaultConfig = {
     enabled: true,
     debug: false,
-    pruningSummary: 'detailed',
+    pruneNotification: "detailed",
+    turnProtection: {
+        enabled: false,
+        turns: 4,
+    },
+    tools: {
+        settings: {
+            nudgeEnabled: true,
+            nudgeFrequency: 10,
+            protectedTools: [...DEFAULT_PROTECTED_TOOLS],
+        },
+        discard: {
+            enabled: true,
+        },
+        extract: {
+            enabled: true,
+            showDistillation: false,
+        },
+    },
     strategies: {
         deduplication: {
             enabled: true,
-            protectedTools: [...DEFAULT_PROTECTED_TOOLS]
+            protectedTools: [...DEFAULT_PROTECTED_TOOLS],
         },
         supersedeWrites: {
-            enabled: true
-        },
-        pruneTool: {
             enabled: true,
-            protectedTools: [...DEFAULT_PROTECTED_TOOLS],
-            nudge: {
-                enabled: true,
-                frequency: 10
-            }
         },
         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;
         }
@@ -213,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;
         }
@@ -227,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;
             }
@@ -248,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": {
@@ -262,17 +406,6 @@ function createDefaultConfig() {
     "supersedeWrites": {
       "enabled": true
     },
-    // Exposes a prune tool to your LLM to call when it determines pruning is necessary
-    "pruneTool": {
-      "enabled": true,
-      // Additional tools to protect from pruning
-      "protectedTools": [],
-      // Nudge the LLM to use the prune tool (every <frequency> tool results)
-      "nudge": {
-        "enabled": true,
-        "frequency": 10
-      }
-    },
     // (Legacy) Run an LLM to analyze what tool calls are no longer relevant on idle
     "onIdle": {
       "enabled": false,
@@ -288,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
@@ -302,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) {
@@ -319,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,
@@ -331,49 +464,63 @@ function mergeStrategies(base, override) {
             protectedTools: [
                 ...new Set([
                     ...base.onIdle.protectedTools,
-                    ...(override.onIdle?.protectedTools ?? [])
-                ])
-            ]
+                    ...(override.onIdle?.protectedTools ?? []),
+                ]),
+            ],
+        },
+        supersedeWrites: {
+            enabled: override.supersedeWrites?.enabled ?? base.supersedeWrites.enabled,
         },
-        pruneTool: {
-            enabled: override.pruneTool?.enabled ?? base.pruneTool.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.pruneTool.protectedTools,
-                    ...(override.pruneTool?.protectedTools ?? [])
-                ])
+                    ...base.settings.protectedTools,
+                    ...(override.settings?.protectedTools ?? []),
+                ]),
             ],
-            nudge: {
-                enabled: override.pruneTool?.nudge?.enabled ?? base.pruneTool.nudge.enabled,
-                frequency: override.pruneTool?.nudge?.frequency ?? base.pruneTool.nudge.frequency
-            }
         },
-        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]
-            },
-            pruneTool: {
-                ...config.strategies.pruneTool,
-                protectedTools: [...config.strategies.pruneTool.protectedTools],
-                nudge: { ...config.strategies.pruneTool.nudge }
+                protectedTools: [...config.strategies.onIdle.protectedTools],
             },
             supersedeWrites: {
-                ...config.strategies.supersedeWrites
-            }
-        }
+                ...config.strategies.supersedeWrites,
+            },
+        },
     };
 }
 export function getConfig(ctx) {
@@ -390,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 { }
@@ -403,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),
             };
         }
     }
@@ -423,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 { }
@@ -436,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),
             };
         }
     }
@@ -452,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 { }
@@ -465,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),
             };
         }
     }