@bd7pil/opencode-deep-memory 0.3.6 → 0.4.0

package/dist/index.js

@@ -132,9 +132,9 @@ function checkpointRawPath(projectPath, _sessionID, _legacyDataRoot) {
   return path2.join(projectMemoryDir(projectPath), "checkpoint.raw.json");
 }
 function hashProject(absProjectPath) {
-  const { createHash: createHash2 } = __require("crypto");
+  const { createHash: createHash4 } = __require("crypto");
   const normalized = path2.resolve(absProjectPath);
-  return createHash2("sha256").update(normalized).digest("hex").slice(0, 16);
+  return createHash4("sha256").update(normalized).digest("hex").slice(0, 16);
 }
 
 // src/shared/tokens.ts
@@ -257,6 +257,9 @@ var PluginState = class {
   _pendingEnrichments = /* @__PURE__ */ new Set();
   _lastUserText = /* @__PURE__ */ new Map();
   _pendingNotify = null;
+  _toolSignatures = /* @__PURE__ */ new Map();
+  _ccrCache = /* @__PURE__ */ new Map();
+  _lastInputTokens = 0;
   agentOf(sessionID) {
     return this._agents.get(sessionID);
   }
@@ -373,6 +376,34 @@ var PluginState = class {
     this._pendingNotify = null;
     return n;
   }
+  recordToolSignature(callID, signature) {
+    this._toolSignatures.set(callID, signature);
+  }
+  isDuplicateTool(signature) {
+    for (const existing of this._toolSignatures.values()) {
+      if (existing === signature) return true;
+    }
+    return false;
+  }
+  getToolSignature(callID) {
+    return this._toolSignatures.get(callID);
+  }
+  ccStore(hash2, entry) {
+    if (this._ccrCache.size > 200) {
+      const oldest = [...this._ccrCache.entries()].sort((a, b) => a[1].createdAt - b[1].createdAt).slice(0, 50);
+      for (const [k] of oldest) this._ccrCache.delete(k);
+    }
+    this._ccrCache.set(hash2, entry);
+  }
+  ccrGet(hash2) {
+    return this._ccrCache.get(hash2);
+  }
+  recordInputTokens(tokens) {
+    this._lastInputTokens = tokens;
+  }
+  lastInputTokens() {
+    return this._lastInputTokens;
+  }
 };
 function createPluginState() {
   return new PluginState();
@@ -2203,6 +2234,9 @@ var SearchService = class {
   }
 };
 
+// src/tools/index.ts
+import { tool as tool4 } from "@opencode-ai/plugin";
+
 // src/tools/memory-search.ts
 import { tool } from "@opencode-ai/plugin";
 function createMemorySearchTool(service) {
@@ -14789,6 +14823,35 @@ ${part.thinking || part.text || "[empty]"}
   return output;
 }
 
+// src/compress/ccr.ts
+import { createHash as createHash2 } from "crypto";
+var CCR_TTL_MS = 5 * 60 * 1e3;
+function ccrStore(state, original, compressed, toolName, callID) {
+  const hash2 = sha256(original).slice(0, 24);
+  state.ccStore(hash2, {
+    hash: hash2,
+    original,
+    compressed,
+    createdAt: Date.now(),
+    toolName,
+    callID
+  });
+  return hash2;
+}
+function ccrRetrieve(state, hash2) {
+  const entry = state.ccrGet(hash2);
+  if (!entry) return void 0;
+  if (Date.now() - entry.createdAt > CCR_TTL_MS) return void 0;
+  return entry.original;
+}
+function ccrInjectMarker(compressed, hash2) {
+  return `${compressed}
+[ccr:${hash2}]`;
+}
+function sha256(data) {
+  return createHash2("sha256").update(data).digest("hex");
+}
+
 // src/tools/index.ts
 function createMemoryTools(service, opts) {
   const search = createMemorySearchTool(service);
@@ -14802,6 +14865,19 @@ function createMemoryTools(service, opts) {
     memory_expand: expand
   };
 }
+function createDeepExpandTool(state) {
+  return tool4({
+    description: "Retrieve original content that was previously compressed. Use hash from [ccr:...] markers.",
+    args: {
+      hash: tool4.schema.string().describe("The hash from the [ccr:HASH] marker")
+    },
+    execute: async (args) => {
+      const original = ccrRetrieve(state, args.hash);
+      if (original) return { title: "Expanded content", output: original };
+      return { title: "Not found", output: "Content expired or hash not found." };
+    }
+  });
+}
 
 // src/extract/capture.ts
 import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
@@ -14960,17 +15036,17 @@ function extractFileChanges(messages) {
   for (const msg of messages) {
     for (const part of msg.parts) {
       if (part.type !== "tool" || !part.tool) continue;
-      const tool4 = part.tool.toLowerCase();
-      if (tool4 === "write" || tool4 === "edit") {
+      const tool5 = part.tool.toLowerCase();
+      if (tool5 === "write" || tool5 === "edit") {
         const filePath = part.args?.filePath || part.args?.path || "";
         if (filePath) {
-          const key = `${filePath}:${tool4}`;
+          const key = `${filePath}:${tool5}`;
           if (!seen.has(key)) {
             seen.add(key);
-            changes.push({ path: filePath, operation: tool4 });
+            changes.push({ path: filePath, operation: tool5 });
           }
         }
-      } else if (tool4 === "bash" || tool4 === "execute") {
+      } else if (tool5 === "bash" || tool5 === "execute") {
         const cmd = part.args?.command || "";
         const match = BASH_FILE_OP_RE.exec(cmd);
         if (match?.[1]) {
@@ -15131,6 +15207,488 @@ function createCompactingHandler(args) {
   };
 }
 
+// src/compress/pressure.ts
+var DEFAULT_MAX_CONTEXT = 128e3;
+var THRESHOLDS = {
+  low: 0.5,
+  medium: 0.7,
+  high: 0.85,
+  critical: 0.95
+};
+var MODEL_CONTEXT_LIMITS = {
+  "deepseek-chat": 64e3,
+  "deepseek-reasoner": 64e3,
+  "mimo-v2.5-pro": 128e3,
+  "mimo-v2.5": 128e3,
+  "claude-sonnet-4-20250514": 2e5,
+  "gpt-4o": 128e3
+};
+function estimateTokens2(text) {
+  let cjk = 0;
+  let other = 0;
+  for (const ch of text) {
+    if (/[\u4e00-\u9fff\u3400-\u4dbf\u3000-\u303f\uff00-\uffef\u3040-\u309f\u30a0-\u30ff]/.test(ch)) {
+      cjk++;
+    } else {
+      other++;
+    }
+  }
+  return Math.ceil(cjk * 0.7 + other / 3.8);
+}
+function extractTokensFromMessages(messages) {
+  let total = 0;
+  for (const msg of messages) {
+    for (const part of msg.parts) {
+      if (typeof part !== "object" || part === null) continue;
+      const p = part;
+      if (p["type"] === "text" && typeof p["text"] === "string") {
+        total += estimateTokens2(p["text"]);
+      } else if (p["type"] === "tool") {
+        const state = p["state"];
+        if (state?.["output"] && typeof state["output"] === "string") {
+          total += estimateTokens2(state["output"]);
+        }
+        if (state?.["error"] && typeof state["error"] === "string") {
+          total += estimateTokens2(state["error"]);
+        }
+      } else if (p["type"] === "reasoning" || p["type"] === "thinking") {
+        if (typeof p["text"] === "string") {
+          total += estimateTokens2(p["text"]);
+        }
+      }
+    }
+  }
+  return total;
+}
+function extractInputTokensFromMessages(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    for (const part of msg.parts) {
+      if (typeof part !== "object" || part === null) continue;
+      const p = part;
+      if (p["type"] === "step-finish") {
+        const tokens = p.tokens;
+        if (tokens?.input && tokens.input > 0) {
+          return tokens.input;
+        }
+      }
+    }
+  }
+  return 0;
+}
+function detectPressure(messages, modelId) {
+  const maxContext = (modelId ? MODEL_CONTEXT_LIMITS[modelId] : void 0) ?? DEFAULT_MAX_CONTEXT;
+  const inputTokens = extractInputTokensFromMessages(messages);
+  const estimated = inputTokens > 0 ? inputTokens : extractTokensFromMessages(messages);
+  const ratio = Math.min(estimated / maxContext, 1);
+  let level;
+  if (ratio >= THRESHOLDS.critical) level = "critical";
+  else if (ratio >= THRESHOLDS.high) level = "high";
+  else if (ratio >= THRESHOLDS.medium) level = "medium";
+  else level = "low";
+  return { level, ratio, estimatedTokens: estimated };
+}
+
+// src/compress/dedup.ts
+var PROTECTED_TOOLS = /* @__PURE__ */ new Set(["question", "edit", "write", "todowrite", "todoread", "memory_store", "memory_search", "memory_forget"]);
+function createToolSignature(tool5, args) {
+  if (!args) return tool5;
+  const sorted = Object.keys(args).sort().map((k) => `${k}:${JSON.stringify(args[k])}`).join(",");
+  return `${tool5}::${sorted}`;
+}
+function deduplicateToolOutputs(messages, state) {
+  let deduped = 0;
+  const seen = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    for (const part of msg.parts) {
+      if (typeof part !== "object" || part === null) continue;
+      const p = part;
+      if (p["type"] !== "tool") continue;
+      const toolName = p["tool"];
+      const callID = p["callID"];
+      if (!toolName || !callID) continue;
+      if (PROTECTED_TOOLS.has(toolName)) continue;
+      const status = p["state"]?.["status"];
+      if (status !== "completed") continue;
+      const toolState = p["state"];
+      const input = toolState["input"];
+      const signature = createToolSignature(toolName, input);
+      const existing = seen.get(signature);
+      if (existing && existing !== callID) {
+        toolState["output"] = "[superseded by duplicate call]";
+        state.recordToolSignature(callID, signature);
+        deduped++;
+      } else {
+        seen.set(signature, callID);
+        state.recordToolSignature(callID, signature);
+      }
+    }
+  }
+  return deduped;
+}
+
+// src/compress/error-purge.ts
+var ERROR_PURGE_TURN_THRESHOLD = 4;
+function purgeOldErrors(messages) {
+  let purged = 0;
+  const totalMessages = messages.length;
+  for (let i = 0; i < totalMessages; i++) {
+    const msg = messages[i];
+    for (const part of msg.parts) {
+      if (typeof part !== "object" || part === null) continue;
+      const p = part;
+      if (p["type"] !== "tool") continue;
+      const toolState = p["state"];
+      if (toolState?.["status"] !== "error") continue;
+      const age = totalMessages - i;
+      if (age < ERROR_PURGE_TURN_THRESHOLD) continue;
+      if (typeof toolState["input"] === "object" && toolState["input"] !== null) {
+        const input = toolState["input"];
+        for (const key of Object.keys(input)) {
+          if (key === "command" || key === "query" || key === "path" || key === "filePath") continue;
+          input[key] = "[purged]";
+        }
+      }
+      purged++;
+    }
+  }
+  return purged;
+}
+
+// src/compress/tool-compress.ts
+var TOOL_COMPRESS_STRATEGIES = {
+  read: compressFileRead,
+  bash: compressBash,
+  grep: compressSearchResults,
+  glob: compressGlob,
+  ripgrep: compressSearchResults,
+  rg: compressSearchResults,
+  find: compressGlob,
+  search: compressSearchResults,
+  grep_app_searchGitHub: compressSearchResults,
+  searxng_searxng_web_search: compressSearchResults,
+  websearch_web_search_exa: compressSearchResults,
+  tavily_tavily_search: compressSearchResults
+};
+var DEFAULT_HEAD_LINES = 50;
+var DEFAULT_TAIL_LINES = 20;
+var MAX_LINE_LENGTH = 500;
+function compressToolOutput(toolName, output) {
+  if (!output || output.length < 500) return output;
+  const strategy = TOOL_COMPRESS_STRATEGIES[toolName];
+  if (strategy) return strategy(output);
+  return compressGeneric(output);
+}
+function compressFileRead(output) {
+  const lines = output.split("\n");
+  if (lines.length <= 100) return output;
+  const head = lines.slice(0, DEFAULT_HEAD_LINES);
+  const tail = lines.slice(-DEFAULT_TAIL_LINES);
+  const keyLines = extractKeyLines(lines.slice(DEFAULT_HEAD_LINES, -DEFAULT_TAIL_LINES));
+  const parts = [...head, "...[truncated]", ...keyLines.slice(0, 10), "...[truncated]", ...tail];
+  return parts.join("\n");
+}
+function compressBash(output) {
+  const lines = output.split("\n");
+  if (lines.length <= 50) return output;
+  const errorLines = lines.filter((l) => /error|fail|exception|fatal|panic/i.test(l)).slice(0, 5);
+  const tail = lines.slice(-30);
+  return [...errorLines, ...tail].join("\n");
+}
+function compressSearchResults(output) {
+  const lines = output.split("\n");
+  if (lines.length <= 30) return output;
+  const grouped = groupByFile(lines);
+  const result = [];
+  let count = 0;
+  for (const [file2, matches] of grouped) {
+    if (count >= 20) break;
+    result.push(`--- ${file2} ---`);
+    const kept = matches.slice(0, 5);
+    for (const m of kept) {
+      result.push(truncateLine(m, MAX_LINE_LENGTH));
+      count++;
+    }
+    if (matches.length > 5) result.push(`  ...[${matches.length - 5} more matches]`);
+  }
+  if (count >= 20 && lines.length > 30) {
+    result.push(`
+...[${lines.length - count} more lines truncated]`);
+  }
+  return result.join("\n");
+}
+function compressGlob(output) {
+  const lines = output.split("\n").filter((l) => l.trim());
+  if (lines.length <= 30) return output;
+  const head = lines.slice(0, 30);
+  return [...head, `
+...[${lines.length - 30} more files]`].join("\n");
+}
+function compressGeneric(output) {
+  const lines = output.split("\n");
+  if (lines.length <= 50) {
+    if (output.length <= 2e3) return output;
+    return output.slice(0, 1500) + "\n...[truncated]" + output.slice(-500);
+  }
+  const head = lines.slice(0, 30);
+  const tail = lines.slice(-15);
+  const errorLines = lines.filter((l) => /error|fail|exception|fatal/i.test(l)).slice(0, 5);
+  return [...head, "...[truncated]", ...errorLines, "...[truncated]", ...tail].join("\n");
+}
+function extractKeyLines(lines) {
+  return lines.filter(
+    (l) => /\b(function |class |def |import |export |interface |type |const |let |var |return |throw |Error|Exception)\b/.test(l) || /error|warn|fail|exception/i.test(l)
+  );
+}
+function groupByFile(lines) {
+  const groups = /* @__PURE__ */ new Map();
+  let currentFile = "unknown";
+  for (const line of lines) {
+    const fileMatch = line.match(/^(\/[^\s:]+):/);
+    if (fileMatch) {
+      currentFile = fileMatch[1];
+    }
+    if (!groups.has(currentFile)) groups.set(currentFile, []);
+    groups.get(currentFile).push(line);
+  }
+  return groups;
+}
+function truncateLine(line, maxLen) {
+  if (line.length <= maxLen) return line;
+  return line.slice(0, maxLen - 15) + "...[truncated]";
+}
+
+// src/compress/json-crush.ts
+import { createHash as createHash3 } from "crypto";
+function crushJsonArray(content, maxItems = 15) {
+  try {
+    const parsed = JSON.parse(content);
+    if (!Array.isArray(parsed)) return content;
+    if (parsed.length <= maxItems) return content;
+    const firstFraction = 0.3;
+    const lastFraction = 0.15;
+    const firstCount = Math.max(1, Math.floor(maxItems * firstFraction));
+    const lastCount = Math.max(1, Math.floor(maxItems * lastFraction));
+    const midCount = maxItems - firstCount - lastCount;
+    const first = parsed.slice(0, firstCount);
+    const last = parsed.slice(-lastCount);
+    const mid = deduplicateMiddle(parsed.slice(firstCount, -lastCount), midCount);
+    const result = [...first, ...mid, ...last];
+    const dropped = parsed.length - result.length;
+    if (dropped > 0) {
+      const hash2 = sha2562(content).slice(0, 12);
+      result.push({ _ccr_dropped: `[${dropped} items offloaded, hash=${hash2}]` });
+    }
+    return JSON.stringify(result, null, 2);
+  } catch {
+    return content;
+  }
+}
+function deduplicateMiddle(items, maxCount) {
+  if (items.length <= maxCount) return items;
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const item of items) {
+    const key = typeof item === "object" ? JSON.stringify(item) : String(item);
+    if (!seen.has(key)) {
+      seen.add(key);
+      unique.push(item);
+      if (unique.length >= maxCount) break;
+    }
+  }
+  return unique;
+}
+function sha2562(data) {
+  return createHash3("sha256").update(data).digest("hex");
+}
+
+// src/compress/message-prune.ts
+var PRUNE_THRESHOLD = 8;
+function pruneOldMessages(messages) {
+  let pruned = 0;
+  const protectedTail = messages.length - PRUNE_THRESHOLD;
+  for (let i = 3; i < protectedTail; i++) {
+    const msg = messages[i];
+    if (msg.info.role !== "assistant") continue;
+    for (const part of msg.parts) {
+      if (typeof part !== "object" || part === null) continue;
+      const p = part;
+      if (p["type"] !== "text" || typeof p["text"] !== "string") continue;
+      const text = p["text"];
+      if (text.length < 500) continue;
+      if (text === "[cleared]" || text === "[stripped]" || text.startsWith("[compressed")) continue;
+      const keyInfo = extractKeyInfo(text);
+      if (keyInfo.length < text.length * 0.6) {
+        p["text"] = keyInfo + "\n[compressed from " + text.length + " chars]";
+        pruned++;
+      }
+    }
+  }
+  return pruned;
+}
+function extractKeyInfo(text) {
+  const lines = text.split("\n");
+  const keyLines = [];
+  let inCodeBlock = false;
+  for (const line of lines) {
+    if (line.trim().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      if (inCodeBlock) keyLines.push(line);
+      continue;
+    }
+    if (inCodeBlock) {
+      if (keyLines.length < 30 && line.trim()) keyLines.push(line);
+      continue;
+    }
+    if (/^#{1,3}\s/.test(line) || /error|fail|warning|important|critical|decision|constraint/i.test(line) || /^\s*[-*]\s/.test(line) || /^\s*\d+\.\s/.test(line)) {
+      keyLines.push(line);
+    }
+  }
+  if (keyLines.length < 3) {
+    return lines.slice(0, 5).join("\n");
+  }
+  return keyLines.join("\n");
+}
+
+// src/compress/nudge.ts
+var NUDGE_COOLDOWN = 5;
+function shouldInjectNudge(level, messageCount, lastNudgeAt) {
+  if (level !== "high" && level !== "critical") return false;
+  if (messageCount - lastNudgeAt < NUDGE_COOLDOWN) return false;
+  return true;
+}
+function buildNudgeText(level) {
+  if (level === "critical") {
+    return '\n<dm-nudge level="critical">Context is nearly full. Use deep_compress tool to compress old messages before the conversation becomes unusable.</dm-nudge>';
+  }
+  return '\n<dm-nudge level="high">Context is getting large. Consider compressing old tool outputs and messages to free space.</dm-nudge>';
+}
+
+// src/compress/detector.ts
+function detectContentType(content) {
+  const trimmed = content.trimStart();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      JSON.parse(content);
+      return "json";
+    } catch {
+    }
+  }
+  if (/^diff --git |^@@ -\d+,\d+ \+\d+,\d+ @@|^[+-]{3} \//m.test(content)) return "diff";
+  if (/Traceback \(most recent call last\)|at \S+\.\S+\(|Error: |Exception: |TypeError: |ReferenceError: /m.test(content)) return "error-trace";
+  if (/<[a-z][\s\S]*>/i.test(content) && /<(html|div|span|body|head|script|style)[\s>]/i.test(content)) return "html";
+  const lines = content.split("\n");
+  const logLineCount = lines.filter((l) => /^\d{4}-\d{2}-\d{2}|^\[\d{4}|ERROR|WARN|INFO|DEBUG|FATAL|TRACE/.test(l)).length;
+  if (lines.length > 5 && logLineCount / lines.length > 0.3) return "log";
+  const codePatterns = /\b(function |class |def |import |from .+ import|const |let |var |export |interface |type |struct |fn |func |pub |private |protected )\b/;
+  const codeLines = lines.filter((l) => codePatterns.test(l)).length;
+  if (lines.length > 10 && codeLines / lines.length > 0.15) return "code";
+  return "text";
+}
+
+// src/compress/index.ts
+function runCompressionPipeline(ctx) {
+  const { messages, state, logger } = ctx;
+  const pressure = detectPressure(messages, ctx.modelId);
+  state.recordInputTokens(pressure.estimatedTokens);
+  const stats = {
+    toolDedup: 0,
+    errorPurge: 0,
+    toolOutputCompressed: 0,
+    jsonCrushed: 0,
+    messagePruned: 0,
+    ccrStored: 0,
+    nudgeInjected: false,
+    pressureLevel: pressure.level,
+    estimatedTokens: pressure.estimatedTokens
+  };
+  if (pressure.level === "low") {
+    logger?.debug("compress: low pressure, skipping", { ratio: pressure.ratio.toFixed(2) });
+    return { stats };
+  }
+  logger?.debug("compress: pipeline running", {
+    level: pressure.level,
+    ratio: pressure.ratio.toFixed(2),
+    tokens: pressure.estimatedTokens
+  });
+  if (pressure.level === "medium" || pressure.level === "high" || pressure.level === "critical") {
+    stats.toolDedup = deduplicateToolOutputs(messages, state);
+    stats.errorPurge = purgeOldErrors(messages);
+    stats.toolOutputCompressed = compressOldToolOutputs(messages, state);
+  }
+  if (pressure.level === "high" || pressure.level === "critical") {
+    stats.jsonCrushed = crushJsonToolOutputs(messages, state);
+    stats.messagePruned = pruneOldMessages(messages);
+  }
+  if (shouldInjectNudge(pressure.level, messages.length, 0)) {
+    const lastMsg = messages[messages.length - 1];
+    if (lastMsg) {
+      const textParts = lastMsg.parts.filter(
+        (p) => typeof p === "object" && p !== null && p.type === "text"
+      );
+      const lastTextPart = textParts[textParts.length - 1];
+      if (lastTextPart && typeof lastTextPart.text === "string") {
+        lastTextPart.text += buildNudgeText(pressure.level);
+        stats.nudgeInjected = true;
+      }
+    }
+  }
+  if (stats.toolDedup > 0 || stats.errorPurge > 0 || stats.toolOutputCompressed > 0 || stats.jsonCrushed > 0 || stats.messagePruned > 0 || stats.nudgeInjected) {
+    logger?.debug("compress: pipeline complete", { ...stats });
+  }
+  return { stats };
+}
+function compressOldToolOutputs(messages, state) {
+  let compressed = 0;
+  const protectedTail = messages.length - 8;
+  for (let i = 3; i < protectedTail; i++) {
+    const msg = messages[i];
+    for (const part of msg.parts) {
+      if (typeof part !== "object" || part === null) continue;
+      const p = part;
+      if (p.type !== "tool") continue;
+      if (p.state?.status !== "completed") continue;
+      if (!p.state.output) continue;
+      if (p.state.output === "[superseded by duplicate call]") continue;
+      if (p.state.output.startsWith("[compressed")) continue;
+      const toolName = p.tool || "unknown";
+      const output = p.state.output;
+      const result = compressToolOutput(toolName, output);
+      if (result.length < output.length * 0.7) {
+        const hash2 = ccrStore(state, output, result, toolName, p.callID);
+        p.state.output = ccrInjectMarker(result, hash2);
+        compressed++;
+      }
+    }
+  }
+  return compressed;
+}
+function crushJsonToolOutputs(messages, state) {
+  let crushed = 0;
+  const protectedTail = messages.length - 8;
+  for (let i = 3; i < protectedTail; i++) {
+    const msg = messages[i];
+    for (const part of msg.parts) {
+      if (typeof part !== "object" || part === null) continue;
+      const p = part;
+      if (p.type !== "tool") continue;
+      if (p.state?.status !== "completed") continue;
+      if (!p.state.output) continue;
+      if (p.state.output.startsWith("[compressed")) continue;
+      if (p.state.output.startsWith("[superseded")) continue;
+      if (detectContentType(p.state.output) !== "json") continue;
+      const original = p.state.output;
+      const crushed_output = crushJsonArray(original);
+      if (crushed_output.length < original.length * 0.7) {
+        const hash2 = ccrStore(state, original, crushed_output, p.tool, p.callID);
+        p.state.output = ccrInjectMarker(crushed_output, hash2);
+        crushed++;
+      }
+    }
+  }
+  return crushed;
+}
+
 // src/hooks/messages-transform.ts
 var KEEP_RECENT = 8;
 var PROTECTED_HEAD = 3;
@@ -15288,6 +15846,23 @@ function createMessagesTransformHandler(state, logger) {
     repairOrphanedToolCalls(messages);
     if (Object.values(stats).some((v) => v > 0)) {
       logger?.debug("messages.transform: stripped", stats);
+    }
+    const pipelineResult = runCompressionPipeline({
+      messages: output.messages,
+      state,
+      logger
+    });
+    const ds = pipelineResult.stats;
+    if (ds.toolDedup > 0 || ds.errorPurge > 0 || ds.toolOutputCompressed > 0 || ds.jsonCrushed > 0 || ds.messagePruned > 0 || ds.nudgeInjected) {
+      logger?.debug("messages.transform: deep compression", { ...ds });
+      state.mergeNotify({
+        compression: stats,
+        deepCompression: ds,
+        messageCount: messages.length,
+        protectedHead: PROTECTED_HEAD,
+        protectedTail: KEEP_RECENT
+      });
+    } else if (Object.values(stats).some((v) => v > 0)) {
       state.mergeNotify({
         compression: stats,
         messageCount: messages.length,
@@ -15903,7 +16478,7 @@ var deepMemoryPlugin = async (input) => {
         });
       }
     },
-    tool: memoryTools,
+    tool: { ...memoryTools, deep_expand: createDeepExpandTool(state) },
     "tool.execute.after": async (input2, output) => {
       if (input2.tool !== "read") return;
       const filePath = input2.args?.path ?? input2.args?.filePath;