feat(compaction): add dynamic context pruning as recovery stage

Implements DCP-style pruning strategies inspired by opencode-dynamic-context-pruning plugin:

- Deduplication: removes duplicate tool calls (same tool + args)
- Supersede writes: prunes write inputs when file subsequently read
- Purge errors: removes old error tool inputs after N turns

Integration:
- Added as Stage 2.5 in compaction pipeline (after truncation, before summarize)
- Configurable via experimental.dynamic_context_pruning
- Opt-in by default (experimental feature)
- Protected tools list prevents pruning critical tools

Configuration:
- Turn protection (default: 3 turns)
- Per-strategy enable/disable
- Aggressive/conservative modes for supersede writes
- Configurable error purge threshold (default: 5 turns)
- Toast notifications (off/minimal/detailed)

Testing:
- Added unit tests for deduplication signature creation
- Type check passes
- Schema regenerated

Closes #271

src/config/index.ts

@@ -18,4 +18,5 @@ export type {
   HookName,
   SisyphusAgentConfig,
   ExperimentalConfig,
+  DynamicContextPruningConfig,
 } from "./schema"

src/config/schema.ts

@@ -113,6 +113,42 @@ export const SisyphusAgentConfigSchema = z.object({
   replace_plan: z.boolean().optional(),
 })
 
+export const DynamicContextPruningConfigSchema = z.object({
+  /** Enable dynamic context pruning (default: false) */
+  enabled: z.boolean().default(false),
+  /** Notification level: off, minimal, or detailed (default: detailed) */
+  notification: z.enum(["off", "minimal", "detailed"]).default("detailed"),
+  /** Turn protection - prevent pruning recent tool outputs */
+  turn_protection: z.object({
+    enabled: z.boolean().default(true),
+    turns: z.number().min(1).max(10).default(3),
+  }).optional(),
+  /** Tools that should never be pruned */
+  protected_tools: z.array(z.string()).default([
+    "task", "todowrite", "todoread",
+    "lsp_rename", "lsp_code_action_resolve",
+    "session_read", "session_write", "session_search",
+  ]),
+  /** Pruning strategies configuration */
+  strategies: z.object({
+    /** Remove duplicate tool calls (same tool + same args) */
+    deduplication: z.object({
+      enabled: z.boolean().default(true),
+    }).optional(),
+    /** Prune write inputs when file subsequently read */
+    supersede_writes: z.object({
+      enabled: z.boolean().default(true),
+      /** Aggressive mode: prune any write if ANY subsequent read */
+      aggressive: z.boolean().default(false),
+    }).optional(),
+    /** Prune errored tool inputs after N turns */
+    purge_errors: z.object({
+      enabled: z.boolean().default(true),
+      turns: z.number().min(1).max(20).default(5),
+    }).optional(),
+  }).optional(),
+})
+
 export const ExperimentalConfigSchema = z.object({
   aggressive_truncation: z.boolean().optional(),
   auto_resume: z.boolean().optional(),
@@ -122,6 +158,8 @@ export const ExperimentalConfigSchema = z.object({
   preemptive_compaction_threshold: z.number().min(0.5).max(0.95).optional(),
   /** Truncate all tool outputs, not just whitelisted tools (default: true) */
   truncate_all_tool_outputs: z.boolean().default(true),
+  /** Dynamic context pruning configuration */
+  dynamic_context_pruning: DynamicContextPruningConfigSchema.optional(),
 })
 
 export const OhMyOpenCodeConfigSchema = z.object({
@@ -144,5 +182,6 @@ export type AgentName = z.infer<typeof AgentNameSchema>
 export type HookName = z.infer<typeof HookNameSchema>
 export type SisyphusAgentConfig = z.infer<typeof SisyphusAgentConfigSchema>
 export type ExperimentalConfig = z.infer<typeof ExperimentalConfigSchema>
+export type DynamicContextPruningConfig = z.infer<typeof DynamicContextPruningConfigSchema>
 
 export { McpNameSchema, type McpName } from "../mcp/types"