@tuanhung303/opencode-acp 2.1.1 → 2.2.1

package/dist/lib/config.js

@@ -2,7 +2,17 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync } from "fs
 import { join, dirname } from "path";
 import { homedir } from "os";
 import { parse } from "jsonc-parser";
+import { validateConfig, getUnknownKeys } from "./config-schema";
+/**
+ * Tools that should never be pruned.
+ *
+ * - `context_info`: Synthetic tool used to inject prunable-tools context
+ *   for DeepSeek/Kimi models. Must be protected to prevent self-pruning
+ *   which would break the context management feedback loop.
+ *   See lib/messages/utils.ts createSyntheticToolPart()
+ */
 const DEFAULT_PROTECTED_TOOLS = [
+    "context_info", // Synthetic tool for context injection
     "task",
     "todowrite",
     "todoread",
@@ -14,424 +24,33 @@ const DEFAULT_PROTECTED_TOOLS = [
     "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
-    "pruneNotification",
-    "turnProtection",
-    "turnProtection.enabled",
-    "turnProtection.turns",
-    "protectedFilePatterns",
-    "commands",
-    "commands.enabled",
-    "commands.protectedTools",
-    "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.supersedeWrites
-    "strategies.supersedeWrites",
-    "strategies.supersedeWrites.enabled",
-    // strategies.purgeErrors
-    "strategies.purgeErrors",
-    "strategies.purgeErrors.enabled",
-    "strategies.purgeErrors.turns",
-    "strategies.purgeErrors.protectedTools",
-    // strategies.pruneThinking
-    "strategies.pruneThinking",
-    "strategies.pruneThinking.enabled",
-    "strategies.pruneThinking.delayTurns",
-    // strategies.placeholderCompression
-    "strategies.placeholderCompression",
-    "strategies.placeholderCompression.enabled",
-    "strategies.placeholderCompression.delayTurns",
-    "strategies.placeholderCompression.minOutputTokens",
-    "strategies.placeholderCompression.protectedTools",
-    // strategies.headTailTruncation
-    "strategies.headTailTruncation",
-    "strategies.headTailTruncation.enabled",
-    "strategies.headTailTruncation.delayTurns",
-    "strategies.headTailTruncation.headRatio",
-    "strategies.headTailTruncation.tailRatio",
-    "strategies.headTailTruncation.protectedTools",
-    // strategies.readConsolidation
-    "strategies.readConsolidation",
-    "strategies.readConsolidation.enabled",
-    "strategies.readConsolidation.tools",
-]);
-// 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);
-        if (obj[key] && typeof obj[key] === "object" && !Array.isArray(obj[key])) {
-            keys.push(...getConfigKeyPaths(obj[key], fullKey));
-        }
-    }
-    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));
-}
-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.debug !== undefined && typeof config.debug !== "boolean") {
-        errors.push({ key: "debug", expected: "boolean", actual: typeof config.debug });
-    }
-    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),
-            });
-        }
-    }
-    if (config.protectedFilePatterns !== undefined) {
-        if (!Array.isArray(config.protectedFilePatterns)) {
-            errors.push({
-                key: "protectedFilePatterns",
-                expected: "string[]",
-                actual: typeof config.protectedFilePatterns,
-            });
-        }
-        else if (!config.protectedFilePatterns.every((v) => typeof v === "string")) {
-            errors.push({
-                key: "protectedFilePatterns",
-                expected: "string[]",
-                actual: "non-string entries",
-            });
-        }
-    }
-    // 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,
-            });
-        }
-    }
-    // Commands validator
-    const commands = config.commands;
-    if (commands !== undefined) {
-        if (typeof commands === "object") {
-            if (commands.enabled !== undefined && typeof commands.enabled !== "boolean") {
-                errors.push({
-                    key: "commands.enabled",
-                    expected: "boolean",
-                    actual: typeof commands.enabled,
-                });
-            }
-            if (commands.protectedTools !== undefined && !Array.isArray(commands.protectedTools)) {
-                errors.push({
-                    key: "commands.protectedTools",
-                    expected: "string[]",
-                    actual: typeof commands.protectedTools,
-                });
-            }
-        }
-        else {
-            errors.push({
-                key: "commands",
-                expected: "{ enabled: boolean, protectedTools: string[] }",
-                actual: typeof commands,
-            });
-        }
-    }
-    // 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?.protectedTools !== undefined &&
-            !Array.isArray(strategies.deduplication.protectedTools)) {
-            errors.push({
-                key: "strategies.deduplication.protectedTools",
-                expected: "string[]",
-                actual: typeof strategies.deduplication.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,
-                });
-            }
-        }
-        // purgeErrors
-        if (strategies.purgeErrors) {
-            if (strategies.purgeErrors.enabled !== undefined &&
-                typeof strategies.purgeErrors.enabled !== "boolean") {
-                errors.push({
-                    key: "strategies.purgeErrors.enabled",
-                    expected: "boolean",
-                    actual: typeof strategies.purgeErrors.enabled,
-                });
-            }
-            if (strategies.purgeErrors.turns !== undefined &&
-                typeof strategies.purgeErrors.turns !== "number") {
-                errors.push({
-                    key: "strategies.purgeErrors.turns",
-                    expected: "number",
-                    actual: typeof strategies.purgeErrors.turns,
-                });
-            }
-            if (strategies.purgeErrors.protectedTools !== undefined &&
-                !Array.isArray(strategies.purgeErrors.protectedTools)) {
-                errors.push({
-                    key: "strategies.purgeErrors.protectedTools",
-                    expected: "string[]",
-                    actual: typeof strategies.purgeErrors.protectedTools,
-                });
-            }
-        }
-        // pruneThinking
-        if (strategies.pruneThinking) {
-            if (strategies.pruneThinking.enabled !== undefined &&
-                typeof strategies.pruneThinking.enabled !== "boolean") {
-                errors.push({
-                    key: "strategies.pruneThinking.enabled",
-                    expected: "boolean",
-                    actual: typeof strategies.pruneThinking.enabled,
-                });
-            }
-            if (strategies.pruneThinking.delayTurns !== undefined &&
-                typeof strategies.pruneThinking.delayTurns !== "number") {
-                errors.push({
-                    key: "strategies.pruneThinking.delayTurns",
-                    expected: "number",
-                    actual: typeof strategies.pruneThinking.delayTurns,
-                });
-            }
-        }
-        // placeholderCompression
-        if (strategies.placeholderCompression) {
-            if (strategies.placeholderCompression.enabled !== undefined &&
-                typeof strategies.placeholderCompression.enabled !== "boolean") {
-                errors.push({
-                    key: "strategies.placeholderCompression.enabled",
-                    expected: "boolean",
-                    actual: typeof strategies.placeholderCompression.enabled,
-                });
-            }
-            if (strategies.placeholderCompression.delayTurns !== undefined &&
-                typeof strategies.placeholderCompression.delayTurns !== "number") {
-                errors.push({
-                    key: "strategies.placeholderCompression.delayTurns",
-                    expected: "number",
-                    actual: typeof strategies.placeholderCompression.delayTurns,
-                });
-            }
-            if (strategies.placeholderCompression.minOutputTokens !== undefined &&
-                typeof strategies.placeholderCompression.minOutputTokens !== "number") {
-                errors.push({
-                    key: "strategies.placeholderCompression.minOutputTokens",
-                    expected: "number",
-                    actual: typeof strategies.placeholderCompression.minOutputTokens,
-                });
-            }
-            if (strategies.placeholderCompression.protectedTools !== undefined &&
-                !Array.isArray(strategies.placeholderCompression.protectedTools)) {
-                errors.push({
-                    key: "strategies.placeholderCompression.protectedTools",
-                    expected: "string[]",
-                    actual: typeof strategies.placeholderCompression.protectedTools,
-                });
-            }
-        }
-        // headTailTruncation
-        if (strategies.headTailTruncation) {
-            if (strategies.headTailTruncation.enabled !== undefined &&
-                typeof strategies.headTailTruncation.enabled !== "boolean") {
-                errors.push({
-                    key: "strategies.headTailTruncation.enabled",
-                    expected: "boolean",
-                    actual: typeof strategies.headTailTruncation.enabled,
-                });
-            }
-            if (strategies.headTailTruncation.delayTurns !== undefined &&
-                typeof strategies.headTailTruncation.delayTurns !== "number") {
-                errors.push({
-                    key: "strategies.headTailTruncation.delayTurns",
-                    expected: "number",
-                    actual: typeof strategies.headTailTruncation.delayTurns,
-                });
-            }
-            if (strategies.headTailTruncation.headRatio !== undefined &&
-                typeof strategies.headTailTruncation.headRatio !== "number") {
-                errors.push({
-                    key: "strategies.headTailTruncation.headRatio",
-                    expected: "number",
-                    actual: typeof strategies.headTailTruncation.headRatio,
-                });
-            }
-            if (strategies.headTailTruncation.tailRatio !== undefined &&
-                typeof strategies.headTailTruncation.tailRatio !== "number") {
-                errors.push({
-                    key: "strategies.headTailTruncation.tailRatio",
-                    expected: "number",
-                    actual: typeof strategies.headTailTruncation.tailRatio,
-                });
-            }
-            if (strategies.headTailTruncation.protectedTools !== undefined &&
-                !Array.isArray(strategies.headTailTruncation.protectedTools)) {
-                errors.push({
-                    key: "strategies.headTailTruncation.protectedTools",
-                    expected: "string[]",
-                    actual: typeof strategies.headTailTruncation.protectedTools,
-                });
-            }
-        }
-        // readConsolidation
-        if (strategies.readConsolidation) {
-            if (strategies.readConsolidation.enabled !== undefined &&
-                typeof strategies.readConsolidation.enabled !== "boolean") {
-                errors.push({
-                    key: "strategies.readConsolidation.enabled",
-                    expected: "boolean",
-                    actual: typeof strategies.readConsolidation.enabled,
-                });
-            }
-            if (strategies.readConsolidation.tools !== undefined &&
-                !Array.isArray(strategies.readConsolidation.tools)) {
-                errors.push({
-                    key: "strategies.readConsolidation.tools",
-                    expected: "string[]",
-                    actual: typeof strategies.readConsolidation.tools,
-                });
-            }
-        }
-    }
-    return errors;
-}
-// Show validation warnings for a config file
+// Show validation warnings for a config file using Zod schema
 function showConfigValidationWarnings(ctx, configPath, configData, isProject) {
-    const invalidKeys = getInvalidConfigKeys(configData);
-    const typeErrors = validateConfigTypes(configData);
-    if (invalidKeys.length === 0 && typeErrors.length === 0) {
+    const validationErrors = validateConfig(configData);
+    const unknownKeys = getUnknownKeys(configData);
+    if (validationErrors.length === 0 && unknownKeys.length === 0) {
         return;
     }
     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)` : "";
+    if (unknownKeys.length > 0) {
+        const keyList = unknownKeys.slice(0, 3).join(", ");
+        const suffix = unknownKeys.length > 3 ? ` (+${unknownKeys.length - 3} more)` : "";
         messages.push(`Unknown keys: ${keyList}${suffix}`);
     }
-    if (typeErrors.length > 0) {
-        for (const err of typeErrors.slice(0, 2)) {
-            messages.push(`${err.key}: expected ${err.expected}, got ${err.actual}`);
+    if (validationErrors.length > 0) {
+        for (const err of validationErrors.slice(0, 2)) {
+            messages.push(err);
         }
-        if (typeErrors.length > 2) {
-            messages.push(`(+${typeErrors.length - 2} more type errors)`);
+        if (validationErrors.length > 2) {
+            messages.push(`(+${validationErrors.length - 2} more validation errors)`);
         }
     }
     setTimeout(() => {
         try {
             ctx.client.tui.showToast({
                 body: {
-                    title: `DCP: Invalid ${configType}`,
+                    title: `ACP: Invalid ${configType}`,
                     message: `${configPath}\n${messages.join("\n")}`,
                     variant: "warning",
                     duration: 7000,
@@ -441,10 +60,11 @@ function showConfigValidationWarnings(ctx, configPath, configData, isProject) {
         catch { }
     }, 7000);
 }
-export const DEFAULT_CONFIG = {
+const defaultConfig = {
     enabled: true,
     debug: false,
     pruneNotification: "detailed",
+    autoPruneAfterTool: true,
     commands: {
         enabled: true,
         protectedTools: [...DEFAULT_PROTECTED_TOOLS],
@@ -453,11 +73,22 @@ export const DEFAULT_CONFIG = {
         enabled: false,
         turns: 4,
     },
-    protectedFilePatterns: [],
+    protectedFilePatterns: [
+        // Environment and secrets
+        "**/.env",
+        "**/.env.*",
+        "**/credentials.json",
+        "**/secrets.json",
+        "**/*.pem",
+        "**/*.key",
+        // Config files users likely want to keep visible
+        "**/package.json",
+        "**/tsconfig.json",
+        "**/pyproject.toml",
+        "**/Cargo.toml",
+    ],
     tools: {
         settings: {
-            nudgeEnabled: true,
-            nudgeFrequency: 5,
             protectedTools: [...DEFAULT_PROTECTED_TOOLS],
         },
         discard: {
@@ -474,39 +105,18 @@ export const DEFAULT_CONFIG = {
             protectedTools: [],
         },
         supersedeWrites: {
-            enabled: true,
-        },
-        purgeErrors: {
-            enabled: true,
-            turns: 2,
-            protectedTools: [],
-        },
-        pruneThinking: {
-            enabled: true,
-            delayTurns: 1,
-        },
-        placeholderCompression: {
             enabled: false,
-            delayTurns: 2,
-            minOutputTokens: 100,
-            protectedTools: [],
         },
-        headTailTruncation: {
+        purgeErrors: {
             enabled: true,
-            delayTurns: 2,
-            headRatio: 0.2,
-            tailRatio: 0.3,
+            turns: 4,
             protectedTools: [],
         },
-        readConsolidation: {
-            enabled: true,
-            tools: ["read", "glob", "grep", "webfetch", "bash"],
-        },
     },
 };
 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_PATH_JSONC = join(GLOBAL_CONFIG_DIR, "acp.jsonc");
+const GLOBAL_CONFIG_PATH_JSON = join(GLOBAL_CONFIG_DIR, "acp.json");
 function findOpencodeDir(startDir) {
     let current = startDir;
     while (current !== "/") {
@@ -522,7 +132,7 @@ function findOpencodeDir(startDir) {
     return null;
 }
 function getConfigPaths(ctx) {
-    // Global: ~/.config/opencode/dcp.jsonc|json
+    // Global: ~/.config/opencode/acp.jsonc|json
     let globalPath = null;
     if (existsSync(GLOBAL_CONFIG_PATH_JSONC)) {
         globalPath = GLOBAL_CONFIG_PATH_JSONC;
@@ -530,12 +140,12 @@ function getConfigPaths(ctx) {
     else if (existsSync(GLOBAL_CONFIG_PATH_JSON)) {
         globalPath = GLOBAL_CONFIG_PATH_JSON;
     }
-    // Custom config directory: $OPENCODE_CONFIG_DIR/dcp.jsonc|json
+    // Custom config directory: $OPENCODE_CONFIG_DIR/acp.jsonc|json
     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, "acp.jsonc");
+        const configJson = join(opencodeConfigDir, "acp.json");
         if (existsSync(configJsonc)) {
             configDirPath = configJsonc;
         }
@@ -543,13 +153,13 @@ function getConfigPaths(ctx) {
             configDirPath = configJson;
         }
     }
-    // Project: <project>/.opencode/dcp.jsonc|json
+    // Project: <project>/.opencode/acp.jsonc|json
     let projectPath = null;
     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, "acp.jsonc");
+            const projectJson = join(opencodeDir, "acp.json");
             if (existsSync(projectJsonc)) {
                 projectPath = projectJsonc;
             }
@@ -565,7 +175,7 @@ function createDefaultConfig() {
         mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true });
     }
     const configContent = `{
-  "$schema": "https://raw.githubusercontent.com/Opencode-DCP/opencode-dynamic-context-pruning/master/dcp.schema.json"
+  "$schema": "https://raw.githubusercontent.com/opencode-acp/opencode-acp/master/acp.schema.json"
 }
 `;
     writeFileSync(GLOBAL_CONFIG_PATH_JSONC, configContent, "utf-8");
@@ -616,39 +226,6 @@ function mergeStrategies(base, override) {
                 ]),
             ],
         },
-        pruneThinking: {
-            enabled: override.pruneThinking?.enabled ?? base.pruneThinking.enabled,
-            delayTurns: override.pruneThinking?.delayTurns ?? base.pruneThinking.delayTurns,
-        },
-        placeholderCompression: {
-            enabled: override.placeholderCompression?.enabled ?? base.placeholderCompression.enabled,
-            delayTurns: override.placeholderCompression?.delayTurns ??
-                base.placeholderCompression.delayTurns,
-            minOutputTokens: override.placeholderCompression?.minOutputTokens ??
-                base.placeholderCompression.minOutputTokens,
-            protectedTools: [
-                ...new Set([
-                    ...base.placeholderCompression.protectedTools,
-                    ...(override.placeholderCompression?.protectedTools ?? []),
-                ]),
-            ],
-        },
-        headTailTruncation: {
-            enabled: override.headTailTruncation?.enabled ?? base.headTailTruncation.enabled,
-            delayTurns: override.headTailTruncation?.delayTurns ?? base.headTailTruncation.delayTurns,
-            headRatio: override.headTailTruncation?.headRatio ?? base.headTailTruncation.headRatio,
-            tailRatio: override.headTailTruncation?.tailRatio ?? base.headTailTruncation.tailRatio,
-            protectedTools: [
-                ...new Set([
-                    ...base.headTailTruncation.protectedTools,
-                    ...(override.headTailTruncation?.protectedTools ?? []),
-                ]),
-            ],
-        },
-        readConsolidation: {
-            enabled: override.readConsolidation?.enabled ?? base.readConsolidation.enabled,
-            tools: override.readConsolidation?.tools ?? base.readConsolidation.tools,
-        },
     };
 }
 function mergeTools(base, override) {
@@ -656,8 +233,6 @@ function mergeTools(base, 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,
@@ -693,7 +268,6 @@ function deepCloneConfig(config) {
         protectedFilePatterns: [...config.protectedFilePatterns],
         tools: {
             settings: {
-                ...config.tools.settings,
                 protectedTools: [...config.tools.settings.protectedTools],
             },
             discard: { ...config.tools.discard },
@@ -711,26 +285,11 @@ function deepCloneConfig(config) {
                 ...config.strategies.purgeErrors,
                 protectedTools: [...config.strategies.purgeErrors.protectedTools],
             },
-            pruneThinking: {
-                ...config.strategies.pruneThinking,
-            },
-            placeholderCompression: {
-                ...config.strategies.placeholderCompression,
-                protectedTools: [...config.strategies.placeholderCompression.protectedTools],
-            },
-            headTailTruncation: {
-                ...config.strategies.headTailTruncation,
-                protectedTools: [...config.strategies.headTailTruncation.protectedTools],
-            },
-            readConsolidation: {
-                ...config.strategies.readConsolidation,
-                tools: [...config.strategies.readConsolidation.tools],
-            },
         },
     };
 }
 export function getConfig(ctx) {
-    let config = deepCloneConfig(DEFAULT_CONFIG);
+    let config = deepCloneConfig(defaultConfig);
     const configPaths = getConfigPaths(ctx);
     // Load and merge global config
     if (configPaths.global) {
@@ -740,7 +299,7 @@ export function getConfig(ctx) {
                 try {
                     ctx.client.tui.showToast({
                         body: {
-                            title: "DCP: Invalid config",
+                            title: "ACP: Invalid config",
                             message: `${configPaths.global}\n${result.parseError}\nUsing default values`,
                             variant: "warning",
                             duration: 7000,
@@ -757,6 +316,7 @@ export function getConfig(ctx) {
                 enabled: result.data.enabled ?? config.enabled,
                 debug: result.data.debug ?? config.debug,
                 pruneNotification: result.data.pruneNotification ?? config.pruneNotification,
+                autoPruneAfterTool: result.data.autoPruneAfterTool ?? config.autoPruneAfterTool,
                 commands: mergeCommands(config.commands, result.data.commands),
                 turnProtection: {
                     enabled: result.data.turnProtection?.enabled ?? config.turnProtection.enabled,
@@ -777,7 +337,7 @@ export function getConfig(ctx) {
         // No config exists, create default
         createDefaultConfig();
     }
-    // Load and merge $OPENCODE_CONFIG_DIR/dcp.jsonc|json (overrides global)
+    // Load and merge $OPENCODE_CONFIG_DIR/acp.jsonc|json (overrides global)
     if (configPaths.configDir) {
         const result = loadConfigFile(configPaths.configDir);
         if (result.parseError) {
@@ -785,7 +345,7 @@ export function getConfig(ctx) {
                 try {
                     ctx.client.tui.showToast({
                         body: {
-                            title: "DCP: Invalid configDir config",
+                            title: "ACP: Invalid configDir config",
                             message: `${configPaths.configDir}\n${result.parseError}\nUsing global/default values`,
                             variant: "warning",
                             duration: 7000,
@@ -802,6 +362,7 @@ export function getConfig(ctx) {
                 enabled: result.data.enabled ?? config.enabled,
                 debug: result.data.debug ?? config.debug,
                 pruneNotification: result.data.pruneNotification ?? config.pruneNotification,
+                autoPruneAfterTool: result.data.autoPruneAfterTool ?? config.autoPruneAfterTool,
                 commands: mergeCommands(config.commands, result.data.commands),
                 turnProtection: {
                     enabled: result.data.turnProtection?.enabled ?? config.turnProtection.enabled,
@@ -826,7 +387,7 @@ export function getConfig(ctx) {
                 try {
                     ctx.client.tui.showToast({
                         body: {
-                            title: "DCP: Invalid project config",
+                            title: "ACP: Invalid project config",
                             message: `${configPaths.project}\n${result.parseError}\nUsing global/default values`,
                             variant: "warning",
                             duration: 7000,
@@ -843,6 +404,7 @@ export function getConfig(ctx) {
                 enabled: result.data.enabled ?? config.enabled,
                 debug: result.data.debug ?? config.debug,
                 pruneNotification: result.data.pruneNotification ?? config.pruneNotification,
+                autoPruneAfterTool: result.data.autoPruneAfterTool ?? config.autoPruneAfterTool,
                 commands: mergeCommands(config.commands, result.data.commands),
                 turnProtection: {
                     enabled: result.data.turnProtection?.enabled ?? config.turnProtection.enabled,