fix: critical bugs and error handling improvements

- Add custom error classes for DCP command handling (replaces magic strings)
- Validate purgeErrors.turns and turnProtection.turns >= 1 (prevents data loss)
- Replace silent error swallowing with console.error fallback in logger
- Add config validation warning for invalid turns values

Fixes:
- Magic string error control flow anti-pattern
- Potential immediate pruning of all errors with turns=0
- Silent error hiding in logger methods

Author: misterdas

lib/config.ts

@@ -243,6 +243,17 @@ export function validateConfigTypes(config: Record<string, any>): ValidationErro
                 actual: typeof config.turnProtection.turns,
             })
         }
+        // Warn if turns is 0 or negative
+        if (
+            typeof config.turnProtection.turns === "number" &&
+            config.turnProtection.turns < 1
+        ) {
+            errors.push({
+                key: "turnProtection.turns",
+                expected: "positive number (>= 1)",
+                actual: `${config.turnProtection.turns}`,
+            })
+        }
     }
 
     // Commands validator
@@ -497,6 +508,17 @@ export function validateConfigTypes(config: Record<string, any>): ValidationErro
                     actual: typeof strategies.purgeErrors.turns,
                 })
             }
+            // Warn if turns is 0 or negative - will be clamped to 1
+            if (
+                typeof strategies.purgeErrors.turns === "number" &&
+                strategies.purgeErrors.turns < 1
+            ) {
+                errors.push({
+                    key: "strategies.purgeErrors.turns",
+                    expected: "positive number (>= 1)",
+                    actual: `${strategies.purgeErrors.turns} (will be clamped to 1)`,
+                })
+            }
             if (
                 strategies.purgeErrors.protectedTools !== undefined &&
                 !Array.isArray(strategies.purgeErrors.protectedTools)

lib/errors.ts

@@ -0,0 +1,67 @@
+/**
+ * Custom error classes for DCP plugin.
+ * Used for control flow in command handling to avoid magic string comparisons.
+ */
+
+/**
+ * Base class for DCP command handling errors.
+ * These are thrown to signal that a command was handled and no further processing is needed.
+ */
+export class DCPCommandHandledError extends Error {
+    constructor(message: string = "DCP command handled") {
+        super(message)
+        this.name = "DCPCommandHandledError"
+    }
+}
+
+/**
+ * Specific error types for different command outcomes.
+ */
+export class DCPContextHandledError extends DCPCommandHandledError {
+    constructor() {
+        super("Context command handled")
+        this.name = "DCPContextHandledError"
+    }
+}
+
+export class DCPStatsHandledError extends DCPCommandHandledError {
+    constructor() {
+        super("Stats command handled")
+        this.name = "DCPStatsHandledError"
+    }
+}
+
+export class DCPSweepHandledError extends DCPCommandHandledError {
+    constructor() {
+        super("Sweep command handled")
+        this.name = "DCPSweepHandledError"
+    }
+}
+
+export class DCPManualHandledError extends DCPCommandHandledError {
+    constructor() {
+        super("Manual command handled")
+        this.name = "DCPManualHandledError"
+    }
+}
+
+export class DCPManualTriggerBlockedError extends DCPCommandHandledError {
+    constructor() {
+        super("Manual trigger blocked")
+        this.name = "DCPManualTriggerBlockedError"
+    }
+}
+
+export class DCPHelpHandledError extends DCPCommandHandledError {
+    constructor() {
+        super("Help command handled")
+        this.name = "DCPHelpHandledError"
+    }
+}
+
+/**
+ * Type guard to check if an error is a DCP command handled error.
+ */
+export function isDCPCommandHandledError(error: unknown): error is DCPCommandHandledError {
+    return error instanceof DCPCommandHandledError
+}

lib/hooks.ts

@@ -14,6 +14,14 @@ import { handleSweepCommand } from "./commands/sweep"
 import { handleManualToggleCommand, handleManualTriggerCommand } from "./commands/manual"
 import { ensureSessionInitialized } from "./state/state"
 import { getCurrentParams } from "./strategies/utils"
+import {
+    DCPContextHandledError,
+    DCPStatsHandledError,
+    DCPSweepHandledError,
+    DCPManualHandledError,
+    DCPManualTriggerBlockedError,
+    DCPHelpHandledError,
+} from "./errors"
 
 const INTERNAL_AGENT_SIGNATURES = [
     "You are a title generator",
@@ -172,12 +180,12 @@ export function createCommandExecuteHandler(
 
             if (subcommand === "context") {
                 await handleContextCommand(commandCtx)
-                throw new Error("__DCP_CONTEXT_HANDLED__")
+                throw new DCPContextHandledError()
             }
 
             if (subcommand === "stats") {
                 await handleStatsCommand(commandCtx)
-                throw new Error("__DCP_STATS_HANDLED__")
+                throw new DCPStatsHandledError()
             }
 
             if (subcommand === "sweep") {
@@ -186,12 +194,12 @@ export function createCommandExecuteHandler(
                     args: subArgs,
                     workingDirectory,
                 })
-                throw new Error("__DCP_SWEEP_HANDLED__")
+                throw new DCPSweepHandledError()
             }
 
             if (subcommand === "manual") {
                 await handleManualToggleCommand(commandCtx, subArgs[0]?.toLowerCase())
-                throw new Error("__DCP_MANUAL_HANDLED__")
+                throw new DCPManualHandledError()
             }
 
             if (
@@ -201,7 +209,7 @@ export function createCommandExecuteHandler(
                 const userFocus = subArgs.join(" ").trim()
                 const prompt = await handleManualTriggerCommand(commandCtx, subcommand, userFocus)
                 if (!prompt) {
-                    throw new Error("__DCP_MANUAL_TRIGGER_BLOCKED__")
+                    throw new DCPManualTriggerBlockedError()
                 }
 
                 state.pendingManualTrigger = {
@@ -218,7 +226,7 @@ export function createCommandExecuteHandler(
             }
 
             await handleHelpCommand(commandCtx)
-            throw new Error("__DCP_HELP_HANDLED__")
+            throw new DCPHelpHandledError()
         }
     }
 }

lib/logger.ts

@@ -85,7 +85,10 @@ export class Logger {
 
             const logFile = join(dailyLogDir, `${new Date().toISOString().split("T")[0]}.log`)
             await writeFile(logFile, logLine, { flag: "a" })
-        } catch (error) {}
+        } catch (error) {
+            // Fallback to console if file logging fails
+            console.error("[DCP Logger] Failed to write log:", error)
+        }
     }
 
     info(message: string, data?: any) {
@@ -206,6 +209,8 @@ export class Logger {
             const timestamp = new Date().toISOString().replace(/[:.]/g, "-")
             const contextFile = join(contextDir, `${timestamp}.json`)
             await writeFile(contextFile, JSON.stringify(minimized, null, 2))
-        } catch (error) {}
+        } catch (error) {
+            console.error("[DCP Logger] Failed to save context:", error)
+        }
     }
 }

lib/strategies/purge-errors.ts

@@ -39,7 +39,8 @@ export const purgeErrors = (
     }
 
     const protectedTools = config.strategies.purgeErrors.protectedTools
-    const turnThreshold = config.strategies.purgeErrors.turns
+    // Ensure turnThreshold is at least 1 to prevent immediate pruning of all errors
+    const turnThreshold = Math.max(1, config.strategies.purgeErrors.turns)
 
     const newPruneIds: string[] = []