feat(preemptive-compaction): add smart multi-phase compaction with DCP and truncation

- Add DCP (Dynamic Context Pruning) as first phase before summarization
- Add truncation phase to remove large tool outputs before expensive summarization
- Protect recent N messages from truncation (configurable via truncation_protection_messages)
- Add compaction logging for debugging and monitoring
- Only fall back to full summarization if DCP + truncation don't free enough tokens

This reduces API costs by avoiding unnecessary summarization calls when simpler
strategies (pruning duplicates, truncating large outputs) are sufficient.

Author: harshav167

assets/oh-my-opencode.schema.json

@@ -1516,6 +1516,11 @@
         },
         "dcp_for_compaction": {
           "type": "boolean"
+        },
+        "truncation_protection_messages": {
+          "type": "number",
+          "minimum": 1,
+          "maximum": 10
         }
       }
     },

src/config/schema.ts

@@ -183,6 +183,8 @@ export const ExperimentalConfigSchema = z.object({
   dynamic_context_pruning: DynamicContextPruningConfigSchema.optional(),
   /** Enable DCP (Dynamic Context Pruning) for compaction - runs first when token limit exceeded (default: false) */
   dcp_for_compaction: z.boolean().optional(),
+  /** Number of recent messages to protect from truncation (default: 3) */
+  truncation_protection_messages: z.number().min(1).max(10).optional(),
 })
 
 export const SkillSourceSchema = z.union([

src/hooks/anthropic-context-window-limit-recovery/executor.ts

@@ -368,12 +368,14 @@ export async function executeCompact(
         targetRatio: TRUNCATE_CONFIG.targetTokenRatio,
       });
 
+      // In error recovery (over 100%), bypass message protection to truncate aggressively
       const aggressiveResult = truncateUntilTargetTokens(
         sessionID,
         errorData.currentTokens,
         errorData.maxTokens,
         TRUNCATE_CONFIG.targetTokenRatio,
         TRUNCATE_CONFIG.charsPerToken,
+        0,
       );
 
       if (aggressiveResult.truncatedCount > 0) {

src/hooks/anthropic-context-window-limit-recovery/storage.ts

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs"
+import { existsSync, readdirSync, readFileSync, writeFileSync, statSync } from "node:fs"
 import { join } from "node:path"
 import { getOpenCodeStorageDir } from "../../shared/data-path"
 
@@ -71,11 +71,44 @@ function getMessageIds(sessionID: string): string[] {
   return messageIds
 }
 
-export function findToolResultsBySize(sessionID: string): ToolResultInfo[] {
+export function findToolResultsBySize(
+  sessionID: string,
+  protectedMessageCount: number = 0
+): ToolResultInfo[] {
   const messageIds = getMessageIds(sessionID)
   const results: ToolResultInfo[] = []
 
+  // Protect the last N messages from truncation
+  // Message IDs are typically ordered, but we sort by the message file's mtime to be safe
+  const protectedMessageIds = new Set<string>()
+  if (protectedMessageCount > 0 && messageIds.length > 0) {
+    const messageDir = getMessageDirForSession(sessionID)
+    if (messageDir) {
+      const messageTimestamps: Array<{ id: string; mtime: number }> = []
+      for (const msgId of messageIds) {
+        try {
+          const msgPath = join(messageDir, `${msgId}.json`)
+          if (existsSync(msgPath)) {
+            const stat = statSync(msgPath)
+            messageTimestamps.push({ id: msgId, mtime: stat.mtimeMs })
+          }
+        } catch {
+          continue
+        }
+      }
+      // Sort by mtime descending (newest first)
+      messageTimestamps.sort((a, b) => b.mtime - a.mtime)
+      // Protect the most recent N messages
+      for (let i = 0; i < Math.min(protectedMessageCount, messageTimestamps.length); i++) {
+        protectedMessageIds.add(messageTimestamps[i].id)
+      }
+    }
+  }
+
   for (const messageID of messageIds) {
+    // Skip protected messages
+    if (protectedMessageIds.has(messageID)) continue
+
     const partDir = join(PART_STORAGE, messageID)
     if (!existsSync(partDir)) continue
 
@@ -104,6 +137,20 @@ export function findToolResultsBySize(sessionID: string): ToolResultInfo[] {
   return results.sort((a, b) => b.outputSize - a.outputSize)
 }
 
+function getMessageDirForSession(sessionID: string): string | null {
+  if (!existsSync(MESSAGE_STORAGE)) return null
+
+  const directPath = join(MESSAGE_STORAGE, sessionID)
+  if (existsSync(directPath)) return directPath
+
+  for (const dir of readdirSync(MESSAGE_STORAGE)) {
+    const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
+    if (existsSync(sessionPath)) return sessionPath
+  }
+
+  return null
+}
+
 export function findLargestToolResult(sessionID: string): ToolResultInfo | null {
   const results = findToolResultsBySize(sessionID)
   return results.length > 0 ? results[0] : null
@@ -186,7 +233,8 @@ export function truncateUntilTargetTokens(
   currentTokens: number,
   maxTokens: number,
   targetRatio: number = 0.8,
-  charsPerToken: number = 4
+  charsPerToken: number = 4,
+  protectedMessageCount: number = 3
 ): AggressiveTruncateResult {
   const targetTokens = Math.floor(maxTokens * targetRatio)
   const tokensToReduce = currentTokens - targetTokens
@@ -203,7 +251,7 @@ export function truncateUntilTargetTokens(
     }
   }
 
-  const results = findToolResultsBySize(sessionID)
+  const results = findToolResultsBySize(sessionID, protectedMessageCount)
 
   if (results.length === 0) {
     return {

src/hooks/preemptive-compaction/compaction-logger.ts

@@ -0,0 +1,97 @@
+import * as fs from "node:fs"
+import * as path from "node:path"
+import { getOpenCodeStorageDir } from "../../shared/data-path"
+
+const COMPACTION_LOG_FILE = path.join(getOpenCodeStorageDir(), "compaction.log")
+
+export interface CompactionLogEntry {
+  timestamp: string
+  sessionID: string
+  phase: "triggered" | "dcp" | "truncation" | "decision" | "summarized" | "skipped"
+  data: Record<string, unknown>
+}
+
+function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`
+}
+
+function formatTokens(tokens: number): string {
+  if (tokens < 1000) return `${tokens}`
+  return `${(tokens / 1000).toFixed(1)}k`
+}
+
+export function logCompaction(entry: CompactionLogEntry): void {
+  try {
+    const { timestamp, sessionID, phase, data } = entry
+    const shortSessionID = sessionID.slice(0, 8)
+    
+    let line = `[${timestamp}] [${shortSessionID}] `
+    
+    switch (phase) {
+      case "triggered":
+        line += `📊 COMPACTION TRIGGERED\n`
+        line += `   ├─ Tokens: ${formatTokens(data.totalUsed as number)} / ${formatTokens(data.contextLimit as number)}\n`
+        line += `   ├─ Usage: ${((data.usageRatio as number) * 100).toFixed(1)}%\n`
+        line += `   └─ Threshold: ${((data.threshold as number) * 100).toFixed(0)}%\n`
+        break
+        
+      case "dcp":
+        line += `🧹 DCP COMPLETED\n`
+        line += `   ├─ Items Pruned: ${data.itemsPruned}\n`
+        line += `   ├─ Tokens Saved: ${formatTokens(data.tokensSaved as number)}\n`
+        if (data.strategies) {
+          const s = data.strategies as { deduplication: number; supersedeWrites: number; purgeErrors: number }
+          line += `   └─ Breakdown: dedup=${s.deduplication}, supersede=${s.supersedeWrites}, purge=${s.purgeErrors}\n`
+        }
+        break
+        
+      case "truncation":
+        line += `✂️  TRUNCATION COMPLETED\n`
+        line += `   ├─ Outputs Truncated: ${data.truncatedCount}\n`
+        line += `   ├─ Bytes Removed: ${formatBytes(data.bytesRemoved as number)}\n`
+        line += `   ├─ Tokens Saved: ${formatTokens(data.tokensSaved as number)}\n`
+        if (data.tools && (data.tools as string[]).length > 0) {
+          line += `   └─ Tools: ${(data.tools as string[]).join(", ")}\n`
+        }
+        break
+        
+      case "decision":
+        line += `📈 POST-PRUNING STATUS\n`
+        line += `   ├─ Original: ${formatTokens(data.originalTokens as number)}\n`
+        line += `   ├─ Saved: ${formatTokens(data.tokensSaved as number)}\n`
+        line += `   ├─ Current: ${formatTokens(data.currentTokens as number)}\n`
+        line += `   ├─ New Usage: ${((data.newUsageRatio as number) * 100).toFixed(1)}%\n`
+        line += `   └─ Decision: ${data.needsSummarize ? "⚠️ NEEDS SUMMARIZE" : "✅ SKIP SUMMARIZE"}\n`
+        break
+        
+      case "skipped":
+        line += `✅ COMPACTION SKIPPED - Pruning was sufficient\n`
+        line += `   └─ Final Usage: ${((data.finalUsageRatio as number) * 100).toFixed(1)}%\n`
+        break
+        
+      case "summarized":
+        line += `📝 SUMMARIZATION COMPLETED\n`
+        line += `   └─ Session compacted and resumed\n`
+        break
+    }
+    
+    line += "\n"
+    fs.appendFileSync(COMPACTION_LOG_FILE, line)
+  } catch {
+    // Silent fail - logging should never break the main flow
+  }
+}
+
+export function getCompactionLogPath(): string {
+  return COMPACTION_LOG_FILE
+}
+
+export function clearCompactionLog(): void {
+  try {
+    fs.writeFileSync(COMPACTION_LOG_FILE, "")
+  } catch {
+    // Silent fail
+  }
+}