@bd7pil/opencode-deep-memory 0.3.5 → 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
@@ -256,6 +256,10 @@ var PluginState = class {
   _pendingResumes = /* @__PURE__ */ new Map();
   _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);
   }
@@ -341,6 +345,65 @@ var PluginState = class {
     this._lastUserText.delete(sessionID);
     return text;
   }
+  /**
+   * Merge stats into the pending notification.
+   * Called from messages.transform (compression) and system.transform (injection).
+   * Creates a new PendingNotify on first call per turn.
+   */
+  mergeNotify(patch) {
+    if (!this._pendingNotify) {
+      this._pendingNotify = { ...patch, setAt: Date.now() };
+      return;
+    }
+    if (patch.compression) {
+      this._pendingNotify.compression = patch.compression;
+    }
+    if (patch.injection) {
+      this._pendingNotify.injection = patch.injection;
+    }
+    if (patch.messageCount !== void 0) {
+      this._pendingNotify.messageCount = patch.messageCount;
+    }
+    if (patch.protectedHead !== void 0) {
+      this._pendingNotify.protectedHead = patch.protectedHead;
+    }
+    if (patch.protectedTail !== void 0) {
+      this._pendingNotify.protectedTail = patch.protectedTail;
+    }
+  }
+  consumePendingNotify() {
+    const n = this._pendingNotify;
+    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();
@@ -777,7 +840,8 @@ async function composeSystemPayload(opts) {
       stable: `<deep-memory-stable>
 <tool-hint>${TOOL_HINT}</tool-hint>
 </deep-memory-stable>`,
-      volatile: ""
+      volatile: "",
+      stats: { searchEntries: 0, repoMapEntries: 0, hasCheckpoint: false }
     };
   }
   const staticBudget = Math.floor(budget.memorySummary * 0.4);
@@ -794,6 +858,7 @@ ${staticMemory || "(empty)"}
 </constraints>
 </deep-memory-stable>`;
   let volatileContent = "";
+  let searchEntries = 0;
   if (userQuery && searchService && searchBudget > 0) {
     try {
       const results = await searchService.search(userQuery, { scope: "all", limit: 20, applyDecay: true });
@@ -808,12 +873,14 @@ ${staticMemory || "(empty)"}
           })),
           { budget: searchBudget }
         );
+        searchEntries = allocated.length;
         volatileContent = allocated.map((a) => a.rendered).join("\n");
       }
     } catch {
     }
   }
   let checkpointContent = "";
+  let hasCheckpoint = false;
   if (budget.checkpointSummary > 0) {
     const checkpointPath = memoryFilePath("project", "checkpoint", projectPath);
     checkpointContent = budgetedRead(checkpointPath, budget.checkpointSummary, [
@@ -823,6 +890,7 @@ ${staticMemory || "(empty)"}
       "Gotchas",
       "File Changes"
     ]);
+    hasCheckpoint = !!checkpointContent;
   }
   let volatile = `<deep-memory-volatile>
 <relevant>
@@ -834,9 +902,11 @@ ${volatileContent || "(none)"}
 ${checkpointContent}
 </last-checkpoint>`;
   }
+  let repoMapSymbols = 0;
   if (tracker && budget.repomap > 0) {
     const repomapEntries = tracker.getTopSymbols(budget.repomap);
     if (repomapEntries.length > 0) {
+      repoMapSymbols = repomapEntries.length;
       volatile += "\n" + formatRepoMap(repomapEntries);
     }
   }
@@ -849,7 +919,7 @@ ${checkpointContent}
     stableSize: stable.length,
     volatileSize: volatile.length
   });
-  return { stable, volatile };
+  return { stable, volatile, stats: { searchEntries, repoMapEntries: repoMapSymbols, hasCheckpoint } };
 }
 
 // src/hooks/system-transform.ts
@@ -870,7 +940,7 @@ function createSystemTransformHandler(state, projectPath, searchService, logger,
       }
     }
     const userQuery = state.consumeLastUserText(sessionID);
-    const { stable, volatile } = await composeSystemPayload({
+    const { stable, volatile, stats: payloadStats } = await composeSystemPayload({
       state,
       sessionID,
       projectPath,
@@ -896,6 +966,17 @@ function createSystemTransformHandler(state, projectPath, searchService, logger,
       stableSize: stable.length,
       volatileSize: volatile.length
     });
+    state.mergeNotify({
+      injection: {
+        stableSize: stable.length,
+        volatileSize: volatile.length,
+        tier,
+        mode,
+        searchEntries: payloadStats.searchEntries,
+        repoMapEntries: payloadStats.repoMapEntries,
+        hasCheckpoint: payloadStats.hasCheckpoint
+      }
+    });
   };
 }
 
@@ -2153,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) {
@@ -14739,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);
@@ -14752,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";
@@ -14910,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]) {
@@ -15081,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;
@@ -15166,7 +15774,7 @@ function repairOrphanedToolCalls(messages) {
     }
   }
 }
-function createMessagesTransformHandler(_state, logger) {
+function createMessagesTransformHandler(state, logger) {
   return async (_input, output) => {
     const messages = output.messages;
     if (messages.length <= KEEP_RECENT) return;
@@ -15239,6 +15847,149 @@ function createMessagesTransformHandler(_state, logger) {
     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,
+        protectedHead: PROTECTED_HEAD,
+        protectedTail: KEEP_RECENT
+      });
+    }
+  };
+}
+
+// src/hooks/notify.ts
+var COOLDOWN_MS = 5e3;
+function formatK(n) {
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1).replace(/\.0$/, "")}K`;
+  return String(n);
+}
+function totalStripped(c) {
+  return c.reasoning_cleared + c.metadata_stripped + c.system_neutralized + c.tool_errors_truncated + c.thinking_stripped;
+}
+function renderProgressBar(total, processed, width = 40) {
+  if (total === 0) return `\u2502${"\u2591".repeat(width)}\u2502`;
+  const filled = Math.round(processed / total * width);
+  const bar = "\u2588".repeat(Math.min(filled, width)) + "\u2591".repeat(Math.max(0, width - filled));
+  return `\u2502${bar}\u2502`;
+}
+function formatCompressionBlock(c, msgCount, head, tail) {
+  const lines = [];
+  if (msgCount && msgCount > 0) {
+    const protectedZones = (head ?? 0) + (tail ?? 0);
+    const scannable = Math.max(0, msgCount - protectedZones);
+    const affected = Math.min(scannable, totalStripped(c));
+    lines.push(renderProgressBar(scannable, affected));
+  }
+  const parts = [];
+  if (c.reasoning_cleared > 0) parts.push(`reasoning -${formatK(c.reasoning_cleared)}`);
+  if (c.metadata_stripped > 0) parts.push(`metadata -${formatK(c.metadata_stripped)}`);
+  if (c.tool_errors_truncated > 0) parts.push(`tool_err -${formatK(c.tool_errors_truncated)}`);
+  if (c.thinking_stripped > 0) parts.push(`thinking -${formatK(c.thinking_stripped)}`);
+  if (c.system_neutralized > 0) parts.push(`sys_inject -${formatK(c.system_neutralized)}`);
+  if (parts.length > 0) lines.push(`  ${parts.join(" | ")}`);
+  return lines.join("\n");
+}
+function formatInjectionBlock(i) {
+  const cacheStatus = i.stableSize > 0 ? "\u2713" : "\u2014";
+  const lines = [
+    `  m[0] stable ${formatK(i.stableSize)}B ${cacheStatus}  m[1] volatile ${formatK(i.volatileSize)}B`,
+    `  tier=${i.tier} | mode=${i.mode}`
+  ];
+  const details = [];
+  if (i.repoMapEntries > 0) details.push(`repo-map: ${i.repoMapEntries} symbols`);
+  if (i.searchEntries > 0) details.push(`memory: ${i.searchEntries} entries`);
+  if (i.hasCheckpoint) details.push(`checkpoint \u2713`);
+  if (details.length > 0) lines.push(`  ${details.join(" | ")}`);
+  return lines.join("\n");
+}
+function chooseLevel(n) {
+  if (!n.compression && n.injection) return "minimal";
+  if (!n.compression) return "minimal";
+  const hasRichContext = n.injection && (n.injection.repoMapEntries > 0 || n.injection.searchEntries > 0 || n.injection.hasCheckpoint);
+  if (hasRichContext && n.messageCount && n.messageCount > 20) return "extended";
+  return "detailed";
+}
+function formatNotify(n) {
+  const level = chooseLevel(n);
+  if (level === "minimal") {
+    const parts = ["\u25A3 deep-memory"];
+    if (n.compression) parts.push(`-${formatK(totalStripped(n.compression))} stripped`);
+    if (n.injection) parts.push(`+${formatK(n.injection.stableSize + n.injection.volatileSize)}B injected`);
+    return parts.join(" | ");
+  }
+  if (level === "extended") {
+    const sections2 = [];
+    if (n.compression) {
+      sections2.push("\u2500 Compression \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      if (n.messageCount) {
+        const head = n.protectedHead ?? 0;
+        const tail = n.protectedTail ?? 0;
+        sections2.push(`  messages: ${n.messageCount} (protected: head=${head} tail=${tail})`);
+      }
+      sections2.push(formatCompressionBlock(n.compression, n.messageCount, n.protectedHead, n.protectedTail));
+    }
+    if (n.injection) {
+      sections2.push("\u2500 Injection \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      sections2.push(formatInjectionBlock(n.injection));
+      const budgetUsed = n.injection.stableSize + n.injection.volatileSize;
+      const maxBudget = 4e3;
+      const pct = Math.round(budgetUsed / maxBudget * 100);
+      sections2.push(`  budget: ${formatK(budgetUsed)}B / ${formatK(maxBudget)}B (${pct}%)`);
+    }
+    return ["\u25A3 deep-memory", ...sections2].join("\n");
+  }
+  const sections = [];
+  if (n.compression) {
+    sections.push("\u2500 Compression \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    sections.push(formatCompressionBlock(n.compression, n.messageCount, n.protectedHead, n.protectedTail));
+  }
+  if (n.injection) {
+    sections.push("\u2500 Injection \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    sections.push(formatInjectionBlock(n.injection));
+  }
+  return ["\u25A3 deep-memory", ...sections].join("\n");
+}
+function createNotifyHandler(client, logger) {
+  let lastNotifyAt = 0;
+  return async (sessionID, notify) => {
+    const hasCompression = notify.compression && totalStripped(notify.compression) > 0;
+    const hasInjection = !!notify.injection;
+    if (!hasCompression && !hasInjection) return;
+    if (notify.setAt - lastNotifyAt < COOLDOWN_MS) return;
+    lastNotifyAt = Date.now();
+    const message = formatNotify(notify);
+    const title = hasCompression ? "deep-memory | compressed" : "deep-memory | injected";
+    try {
+      await client.tui.showToast({
+        body: {
+          title,
+          message,
+          variant: "info",
+          duration: 5e3
+        }
+      });
+      logger?.debug("notify: sent", { level: chooseLevel(notify) });
+    } catch (err) {
+      logger?.debug("notify: failed (non-fatal)", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
   };
 }
 
@@ -15595,8 +16346,12 @@ var deepMemoryPlugin = async (input) => {
     });
   });
   const memoryTools = createMemoryTools(searchService, { projectPath });
+  const notify = createNotifyHandler(input.client, logger.for("notify"));
   const hooks = {
-    "chat.params": createChatParamsHandler(state, logger.for("chat-params")),
+    "chat.params": createChatParamsHandler(
+      state,
+      logger.for("chat-params")
+    ),
     "chat.message": createChatMessageHandler({
       projectPath,
       state,
@@ -15666,6 +16421,18 @@ var deepMemoryPlugin = async (input) => {
           } else {
             logger.debug("event session.idle (no pending enrichment)");
           }
+          if (idleSessionID) {
+            const pending = state.consumePendingNotify();
+            if (pending) {
+              try {
+                await notify(idleSessionID, pending);
+              } catch (err) {
+                logger.debug("idle notify failed (non-fatal)", {
+                  error: err instanceof Error ? err.message : String(err)
+                });
+              }
+            }
+          }
           return;
         }
         if (event.type === "session.compacted") {
@@ -15711,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;