@bd7pil/opencode-deep-memory 0.8.7 → 0.9.0

package/dist/index.js

@@ -1,19 +1,14 @@
 /* opencode-deep-memory — zero runtime dependencies */
-var __defProp = Object.defineProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+import {
+  __export,
+  ccrInjectMarker,
+  ccrRetrieve,
+  ccrStore
+} from "./chunk-FUQATBWM.js";
 
 // src/index.ts
-import { appendFile, mkdir as mkdir4 } from "fs/promises";
-import path11 from "path";
+import { appendFile, mkdir as mkdir3 } from "fs/promises";
+import path8 from "path";
 
 // src/shared/log.ts
 import fs from "fs";
@@ -122,20 +117,12 @@ function memoryFilePath(scope, type, projectPath, sessionID, _legacyDataRoot) {
   const file2 = type === "memory" ? "MEMORY.md" : type === "notes" ? "notes.md" : "checkpoint.md";
   return path2.join(dir, file2);
 }
-function scheduleFilePath(projectPath, _legacyDataRoot) {
-  return path2.join(projectMemoryDir(projectPath), ".schedule.json");
-}
 function indexStateFilePath(projectPath, _legacyDataRoot) {
   return path2.join(projectMemoryDir(projectPath), ".index-state.json");
 }
 function checkpointRawPath(projectPath, _sessionID, _legacyDataRoot) {
   return path2.join(projectMemoryDir(projectPath), "checkpoint.raw.json");
 }
-function hashProject(absProjectPath) {
-  const { createHash: createHash4 } = __require("crypto");
-  const normalized = path2.resolve(absProjectPath);
-  return createHash4("sha256").update(normalized).digest("hex").slice(0, 16);
-}
 
 // src/shared/tokens.ts
 var CHARS_PER_TOKEN = 4;
@@ -247,6 +234,61 @@ function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
+// src/shared/migrate.ts
+import fs3 from "fs";
+import nodePath from "path";
+var MIGRATED_MARKER = ".migrated-v4";
+async function migrateV3toV4(projectPath, logger) {
+  const dir = scopeDir("project", projectPath);
+  const marker = nodePath.join(dir, MIGRATED_MARKER);
+  if (fs3.existsSync(marker)) return;
+  fs3.mkdirSync(dir, { recursive: true });
+  const deleted = [];
+  const archived = [];
+  const filesToDelete = [
+    "checkpoint.raw.json",
+    "notes.md",
+    ".schedule.json"
+  ];
+  for (const fname of filesToDelete) {
+    const fpath = nodePath.join(dir, fname);
+    try {
+      fs3.unlinkSync(fpath);
+      deleted.push(fname);
+    } catch {
+    }
+  }
+  const archiveDir = nodePath.join(dir, "archive");
+  const distillFiles = fs3.existsSync(dir) ? fs3.readdirSync(dir).filter((f) => f.startsWith("distill-") && f.endsWith(".md")) : [];
+  if (distillFiles.length > 0) {
+    fs3.mkdirSync(archiveDir, { recursive: true });
+    for (const fname of distillFiles) {
+      const src = nodePath.join(dir, fname);
+      const dst = nodePath.join(archiveDir, fname);
+      fs3.renameSync(src, dst);
+      archived.push(fname);
+    }
+  }
+  const memoryPath = nodePath.join(dir, "MEMORY.md");
+  if (fs3.existsSync(memoryPath)) {
+    const content = fs3.readFileSync(memoryPath, "utf8");
+    const lines = content.split("\n");
+    if (lines.length > 200) {
+      const archivePath = nodePath.join(dir, "MEMORY-archive.md");
+      const overflow = lines.slice(200).join("\n");
+      fs3.writeFileSync(memoryPath, lines.slice(0, 200).join("\n"), "utf8");
+      fs3.appendFileSync(archivePath, `
+${overflow}
+`, "utf8");
+      archived.push("MEMORY.md (trimmed to 200 lines, overflow to MEMORY-archive.md)");
+    }
+  }
+  fs3.writeFileSync(marker, (/* @__PURE__ */ new Date()).toISOString(), "utf8");
+  if (deleted.length > 0 || archived.length > 0) {
+    logger?.info("V3\u2192V4 migration complete", { deleted, archived });
+  }
+}
+
 // src/hooks/shared-state.ts
 var PluginState = class {
   _agents = /* @__PURE__ */ new Map();
@@ -254,7 +296,6 @@ var PluginState = class {
   _projectModel;
   _fallbackModel;
   _pendingResumes = /* @__PURE__ */ new Map();
-  _pendingEnrichments = /* @__PURE__ */ new Set();
   _lastUserText = /* @__PURE__ */ new Map();
   _pendingNotify = null;
   _toolSignatures = /* @__PURE__ */ new Map();
@@ -265,6 +306,9 @@ var PluginState = class {
   _lastCCRCleanup = 0;
   _modelContextWindow = 0;
   _recentEdits = /* @__PURE__ */ new Set();
+  _memoryCache;
+  _pendingCompression;
+  _greetedSessions = /* @__PURE__ */ new Set();
   agentOf(sessionID) {
     return this._agents.get(sessionID);
   }
@@ -323,27 +367,6 @@ var PluginState = class {
   hasPendingResume(sessionID) {
     return this._pendingResumes.has(sessionID);
   }
-  /**
-   * Mark a sessionID as having a pending enrichment.
-   * Called by the compacting hook after writing checkpoint.md.
-   */
-  setPendingEnrichment(sessionID) {
-    this._pendingEnrichments.add(sessionID);
-  }
-  /**
-   * Consume (read + delete) the pending enrichment flag.
-   * Returns true if the flag was set, false if not.
-   * Idempotent: second call returns false.
-   */
-  consumePendingEnrichment(sessionID) {
-    const had = this._pendingEnrichments.has(sessionID);
-    this._pendingEnrichments.delete(sessionID);
-    return had;
-  }
-  /** Check whether a pending enrichment flag exists for a sessionID. */
-  hasPendingEnrichment(sessionID) {
-    return this._pendingEnrichments.has(sessionID);
-  }
   recordLastUserText(sessionID, text) {
     this._lastUserText.set(sessionID, text.slice(0, 500));
   }
@@ -442,6 +465,35 @@ var PluginState = class {
   getRecentEdits() {
     return Array.from(this._recentEdits);
   }
+  /** D5: mtime-based MEMORY.md cache for byte-stable system prompts. */
+  setMemoryCache(content, mtime) {
+    this._memoryCache = { content, mtime };
+  }
+  getMemoryCache() {
+    return this._memoryCache;
+  }
+  isMemoryCacheFresh(currentMtime) {
+    return this._memoryCache?.mtime === currentMtime;
+  }
+  clearMemoryCache() {
+    this._memoryCache = void 0;
+  }
+  requestCompression(keepRecent) {
+    this._pendingCompression = { keepRecent, requestedAt: Date.now() };
+  }
+  consumeCompressionRequest() {
+    if (!this._pendingCompression) return void 0;
+    const req = this._pendingCompression;
+    this._pendingCompression = void 0;
+    return { keepRecent: req.keepRecent };
+  }
+  /** A: Session-start greeting — only inject memory whisper once per session. */
+  hasGreetedSession(sessionID) {
+    return this._greetedSessions.has(sessionID);
+  }
+  markGreetedSession(sessionID) {
+    this._greetedSessions.add(sessionID);
+  }
 };
 function createPluginState() {
   return new PluginState();
@@ -463,1118 +515,116 @@ function createChatParamsHandler(state, logger) {
   };
 }
 
-// src/hooks/chat-message.ts
-import path4 from "path";
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { createHash } from "crypto";
-var MAX_NOTE_LENGTH = 500;
-var KEYWORDS = [
-  "remember",
-  "don't forget",
-  "note:",
-  "important:",
-  "constraint:",
-  "must not",
-  "never do",
-  "\u8BB0\u4F4F",
-  "\u522B\u5FD8",
-  "\u6CE8\u610F\uFF1A",
-  "\u91CD\u8981\uFF1A",
-  "\u7EA6\u675F\uFF1A",
-  "\u7EDD\u4E0D\u80FD",
-  "\u5FC5\u987B"
-];
-function matchesKeyword(text) {
-  const lower = text.toLowerCase();
-  return KEYWORDS.some((kw) => lower.includes(kw));
-}
-function truncate(text, max) {
-  if (text.length <= max) return text;
-  return text.slice(0, max) + " [truncated]";
-}
-function deduplicateEntries(content) {
-  const seenHashes = /* @__PURE__ */ new Set();
-  const blocks = content.split(/\n(?=## )/);
-  const kept = [];
-  for (const block of blocks) {
-    const match = block.match(/\[([a-f0-9]{8})\]/);
-    if (match) {
-      const hash2 = match[1];
-      if (seenHashes.has(hash2)) continue;
-      seenHashes.add(hash2);
-    }
-    kept.push(block);
-  }
-  return kept.join("\n");
-}
-function createChatMessageHandler(config2) {
-  const { projectPath, state, logger } = config2;
-  return async (input, output) => {
-    if (output.message.role !== "user") return;
-    if (input.agent) return;
-    const textParts = output.parts.filter(
-      (p) => p.type === "text"
-    );
-    if (textParts.length === 0) return;
-    const fullText = textParts.map((p) => p.text).join("");
-    state.recordLastUserText(input.sessionID, fullText);
-    if (!matchesKeyword(fullText)) return;
-    const truncated = truncate(fullText, MAX_NOTE_LENGTH);
-    const contentHash = createHash("md5").update(truncated).digest("hex").slice(0, 8);
-    const notesFile = memoryFilePath("project", "notes", projectPath);
-    const sid8 = input.sessionID.slice(0, 8);
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    try {
-      await mkdir(path4.dirname(notesFile), { recursive: true });
-      const release = await acquireLock(notesFile);
-      try {
-        let content = await readFile(notesFile, "utf8").catch(() => "");
-        if (content.includes(`[${contentHash}]`)) {
-          logger?.debug("notes: skipped duplicate", { hash: contentHash });
-          return;
-        }
-        const entry = `
-## ${timestamp} (session ${sid8}) [${contentHash}]
-${truncated}
-`;
-        content = deduplicateEntries(content + entry);
-        await writeFile(notesFile, content, "utf8");
-      } finally {
-        release();
-      }
-      logger?.debug("notes: captured keyword match", {
-        sessionID: input.sessionID,
-        hash: contentHash
-      });
-    } catch (err) {
-      logger?.warn("notes: failed to write notes.md", {
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  };
-}
-
-// src/inject/agent-budget.ts
-function classifyAgent(agent) {
-  if (agent === void 0) return "main";
-  const lower = agent.toLowerCase();
-  const mainAgents = ["build", "sisyphus", "open-craft", "opencode"];
-  if (mainAgents.includes(lower)) return "main";
-  const deepAgents = ["oracle", "metis", "momus"];
-  if (deepAgents.includes(lower)) return "deep-reasoning";
-  const toolAgents = [
-    "explore",
-    "librarian",
-    "quick",
-    "task",
-    "sisyphus-junior",
-    "general"
-  ];
-  if (toolAgents.includes(lower)) return "tool-subagent";
-  return "main";
-}
-var BUDGET_TABLE = {
-  main: {
-    normal: { total: 800, toolPrompt: 80, memorySummary: 400, checkpointSummary: 220, repomap: 100 },
-    "post-compaction": { total: 3e3, toolPrompt: 80, memorySummary: 1200, checkpointSummary: 1420, repomap: 300 },
-    "post-resume": { total: 3e3, toolPrompt: 80, memorySummary: 1200, checkpointSummary: 1420, repomap: 300 }
-  },
-  "deep-reasoning": {
-    normal: { total: 400, toolPrompt: 80, memorySummary: 240, checkpointSummary: 80, repomap: 0 },
-    "post-compaction": { total: 800, toolPrompt: 80, memorySummary: 500, checkpointSummary: 220, repomap: 0 },
-    "post-resume": { total: 400, toolPrompt: 80, memorySummary: 240, checkpointSummary: 80, repomap: 0 }
-  },
-  "tool-subagent": {
-    normal: { total: 80, toolPrompt: 80, memorySummary: 0, checkpointSummary: 0, repomap: 0 },
-    "post-compaction": { total: 80, toolPrompt: 80, memorySummary: 0, checkpointSummary: 0, repomap: 0 },
-    "post-resume": { total: 80, toolPrompt: 80, memorySummary: 0, checkpointSummary: 0, repomap: 0 }
-  }
-};
-function budgetFor(tier, mode) {
-  return BUDGET_TABLE[tier][mode];
-}
-
-// src/inject/budgeted-read.ts
-import fs3 from "fs";
-function parseMarkdownSections(content) {
-  if (!content) return [];
-  const sections = [];
-  const lines = content.split("\n");
-  let currentHeading = "";
-  let currentBody = [];
-  for (const line of lines) {
-    if (line.startsWith("## ")) {
-      if (currentHeading || currentBody.length > 0) {
-        sections.push({
-          heading: currentHeading,
-          body: currentBody.join("\n")
-        });
-      }
-      currentHeading = line;
-      currentBody = [];
-    } else {
-      currentBody.push(line);
-    }
-  }
-  if (currentHeading || currentBody.length > 0) {
-    sections.push({
-      heading: currentHeading,
-      body: currentBody.join("\n")
-    });
-  }
-  return sections;
-}
-function sortByPriority(sections, priority) {
-  const priorityLower = priority.map((p) => p.toLowerCase());
-  function priorityIndex(section) {
-    const headingLower = section.heading.toLowerCase();
-    for (let i = 0; i < priorityLower.length; i++) {
-      if (headingLower.includes(priorityLower[i])) {
-        return i;
-      }
-    }
-    return priorityLower.length;
-  }
-  return [...sections].sort((a, b) => {
-    const ai = priorityIndex(a);
-    const bi = priorityIndex(b);
-    if (ai !== bi) return ai - bi;
-    return 0;
-  });
-}
-function budgetedRead(filePath, budgetTokens, sectionPriority) {
-  if (budgetTokens <= 0) return "";
-  let content;
+// src/inject/system-payload.ts
+import fs4 from "fs";
+var TOOL_HINT = 'Memory tools available: memory_search, memory_store, memory_forget.\nGuidelines:\n  (1) BEFORE making ANY technical decision, search: memory_search(query="decision OR decided OR chose", scope="project")\n  (2) BEFORE fixing an error, search for known pitfalls: memory_search(query="gotcha OR error OR bug", scope="project")\n  (3) AFTER fixing an error, store it: memory_store(type="gotcha", content="[error]: ... \u2192 [fix]: ...", scope="project")\n  (4) WHEN user states a constraint/rule, store it: memory_store(type="constraint", content="...", scope="project")\n  (5) WHEN a technical decision is made, store it: memory_store(type="decision", content="[decision]: ... \u2192 [reason]: ...", scope="project")';
+async function composeSystemPayload(opts) {
+  const { state, projectPath, logger } = opts;
+  const memoryPath = memoryFilePath("project", "memory", projectPath);
+  let memoryContent = "";
+  let cacheHit = true;
   try {
-    content = fs3.readFileSync(filePath, "utf8");
-  } catch {
-    const logger = createLogger();
-    logger.debug(`budgetedRead: file not found or unreadable: ${filePath}`);
-    return "";
-  }
-  if (!content.trim()) return "";
-  const sections = parseMarkdownSections(content);
-  if (sections.length === 0) return "";
-  const sorted = sortByPriority(sections, sectionPriority);
-  let output = "";
-  let remaining = budgetTokens;
-  for (const section of sorted) {
-    const sectionText = (section.heading ? section.heading + "\n" : "") + section.body + "\n";
-    const sectionTokens = estimateTokens(sectionText);
-    if (sectionTokens <= remaining) {
-      output += sectionText + "\n";
-      remaining -= sectionTokens;
+    const stat = fs4.statSync(memoryPath);
+    const mtime = stat.mtimeMs;
+    if (state.isMemoryCacheFresh(mtime)) {
+      memoryContent = state.getMemoryCache()?.content ?? "";
+      cacheHit = true;
     } else {
-      const headingPart = section.heading ? section.heading + "\n" : "";
-      const availableForBody = remaining - estimateTokens(headingPart);
-      if (availableForBody > 0) {
-        const truncatedBody = truncateToTokenBudget(section.body, availableForBody);
-        output += headingPart + truncatedBody + "\n\n";
-      }
-      break;
+      memoryContent = fs4.readFileSync(memoryPath, "utf8");
+      state.setMemoryCache(memoryContent, mtime);
+      cacheHit = false;
     }
+  } catch {
+    state.clearMemoryCache();
+    cacheHit = false;
+  }
+  const memorySize = memoryContent.length;
+  let payload = `<deep-memory-stable>
+<tool-hint>
+${TOOL_HINT}
+</tool-hint>`;
+  if (memoryContent.trim().length > 0) {
+    payload += `
+<constraints>
+${memoryContent}
+</constraints>`;
   }
-  return output.trimEnd();
-}
-
-// src/inject/importance.ts
-var BASE_IMPORTANCE = {
-  constraint: 80,
-  decision: 70,
-  gotcha: 60,
-  fact: 50,
-  note: 30
-};
-var COMMON_WORDS = [
-  "test",
-  "util",
-  "helper",
-  "config",
-  "index",
-  "main",
-  "init",
-  "setup"
-];
-function computeImportance(factors) {
-  let score = BASE_IMPORTANCE[factors.type] ?? 40;
-  score += Math.min(20, factors.notesOccurrences * 5);
-  score += Math.min(15, factors.searchHits * 5);
-  if (factors.ageDays < 7) score += 10;
-  else if (factors.ageDays < 30) score += 5;
-  const content = factors.content ?? "";
-  const heading = factors.heading ?? "";
-  if (content.startsWith("_") || heading.startsWith("_")) {
-    score *= 0.3;
-  }
-  if (content.length >= 50) {
-    score *= 1.3;
-  }
-  const headingLower = heading.toLowerCase();
-  if (COMMON_WORDS.some((w) => headingLower.includes(w))) {
-    score *= 0.5;
-  }
-  return Math.max(1, Math.min(100, Math.round(score)));
-}
-
-// src/inject/tier-renderer.ts
-var TIER_MAX_TOKENS = {
-  1: 200,
-  2: 60,
-  3: 25,
-  4: 15,
-  5: 0
-};
-function renderTier(content, type, heading, tier) {
-  if (tier === 5) return "";
-  const maxTokens = TIER_MAX_TOKENS[tier];
-  const contentTokens = Math.ceil(content.length / 4);
-  if (tier === 1) {
-    return contentTokens <= maxTokens ? `- [${heading}] ${content}` : `- [${heading}] ${content.slice(0, maxTokens * 4)}... [truncated]`;
-  }
-  if (tier === 2) {
-    const firstSentence = content.split(/[.。!！?？\n]/)[0] ?? content.slice(0, 200);
-    return `- [${type}] ${firstSentence.slice(0, 200)}`;
-  }
-  if (tier === 3) {
-    const words = content.split(/\s+/).slice(0, 10).join(" ");
-    return `- [${type}] ${words.slice(0, 80)}`;
-  }
-  return `- [${type}]`;
-}
-
-// src/inject/budget-allocator.ts
-var TIER_COST = { 1: 200, 2: 60, 3: 25, 4: 15 };
-function allocateAndRender(results, opts) {
-  if (results.length === 0) return [];
-  const sortedScores = results.map((r) => r.score).sort((a, b) => b - a);
-  const top20 = sortedScores[Math.floor(sortedScores.length * 0.2)] ?? 0;
-  const top50 = sortedScores[Math.floor(sortedScores.length * 0.5)] ?? 0;
-  const withImportance = results.map((r) => {
-    const type = opts.typeOf?.(r) ?? inferType(r.heading);
-    const ageDays = opts.ageDays?.(r) ?? 0;
-    const base = computeImportance({
-      type,
-      ageDays,
-      notesOccurrences: 0,
-      searchHits: 0
-    });
-    let boost = 0;
-    if (r.score >= top20) boost = 30;
-    else if (r.score >= top50) boost = 15;
-    return { result: r, type, fusedImportance: base + boost };
-  });
-  withImportance.sort((a, b) => b.fusedImportance - a.fusedImportance);
-  const maxAtP4 = Math.floor(opts.budget / TIER_COST[4]);
-  const selected = withImportance.slice(0, maxAtP4);
-  let remaining = opts.budget - selected.length * TIER_COST[4];
-  const allocations = selected.map((item) => {
-    const rendered = renderTier(item.result.snippet, item.type, item.result.heading, 4);
-    return {
-      content: item.result.snippet,
-      type: item.type,
-      heading: item.result.heading,
-      tier: 4,
-      rendered,
-      tokens: TIER_COST[4]
-    };
-  });
-  for (let i = 0; i < allocations.length; i++) {
-    const alloc = allocations[i];
-    if (remaining >= TIER_COST[3] - TIER_COST[4] && alloc.tier === 4) {
-      alloc.tier = 3;
-      alloc.rendered = renderTier(alloc.content, alloc.type, alloc.heading, 3);
-      alloc.tokens = TIER_COST[3];
-      remaining -= TIER_COST[3] - TIER_COST[4];
-    }
-    if (remaining >= TIER_COST[2] - TIER_COST[3] && alloc.tier === 3) {
-      alloc.tier = 2;
-      alloc.rendered = renderTier(alloc.content, alloc.type, alloc.heading, 2);
-      alloc.tokens = TIER_COST[2];
-      remaining -= TIER_COST[2] - TIER_COST[3];
-    }
-    if (remaining >= TIER_COST[1] - TIER_COST[2] && alloc.tier === 2) {
-      alloc.tier = 1;
-      alloc.rendered = renderTier(alloc.content, alloc.type, alloc.heading, 1);
-      alloc.tokens = TIER_COST[1];
-      remaining -= TIER_COST[1] - TIER_COST[2];
-    }
-  }
-  return allocations;
-}
-function inferType(heading) {
-  const h = heading.toLowerCase();
-  if (h.includes("constraint") || h.includes("rule")) return "constraint";
-  if (h.includes("decision")) return "decision";
-  if (h.includes("gotcha") || h.includes("error")) return "gotcha";
-  if (h.includes("fact")) return "fact";
-  return "note";
+  payload += `
+</deep-memory-stable>`;
+  logger?.debug("composeSystemPayload V4", { cacheHit, memorySize });
+  return { payload, cacheHit, memorySize };
 }
 
-// src/inject/dedup.ts
-function dedupByJaccard(items, getText, threshold = 0.85) {
-  if (items.length === 0) return [];
-  const tokenSets = items.map((item) => new Set(tokenize(getText(item))));
-  const inverted = /* @__PURE__ */ new Map();
-  for (let i = 0; i < tokenSets.length; i++) {
-    for (const token of tokenSets[i]) {
-      let list = inverted.get(token);
-      if (!list) {
-        list = [];
-        inverted.set(token, list);
-      }
-      list.push(i);
-    }
-  }
-  const isDuplicate = /* @__PURE__ */ new Set();
-  const compared = /* @__PURE__ */ new Set();
-  for (const indices of inverted.values()) {
-    for (let a = 0; a < indices.length; a++) {
-      const i = indices[a];
-      if (isDuplicate.has(i)) continue;
-      for (let b = a + 1; b < indices.length; b++) {
-        const j = indices[b];
-        if (isDuplicate.has(j)) continue;
-        const key = i < j ? `${i}-${j}` : `${j}-${i}`;
-        if (compared.has(key)) continue;
-        compared.add(key);
-        if (jaccardSimilarity(tokenSets[i], tokenSets[j]) > threshold) {
-          isDuplicate.add(j);
-        }
-      }
-    }
-  }
-  return items.filter((_, i) => !isDuplicate.has(i));
-}
-function tokenize(text) {
-  return text.toLowerCase().split(/[\s\p{P}]+/u).filter((t) => t.length > 0);
-}
-function jaccardSimilarity(a, b) {
-  let intersection2 = 0;
-  for (const t of a) if (b.has(t)) intersection2++;
-  const union2 = a.size + b.size - intersection2;
-  return union2 === 0 ? 0 : intersection2 / union2;
+// src/inject/auto-search.ts
+var WHISPER_MIN_SCORE = 2;
+function shouldWhisper(results) {
+  if (results.length === 0) return false;
+  const top1 = results[0];
+  if (!top1 || top1.score < WHISPER_MIN_SCORE) return false;
+  return true;
 }
-
-// src/repomap/injector.ts
-function formatRepoMap(entries) {
-  if (entries.length === 0) return "";
-  const lines = entries.map(
-    (e) => `${e.file}: ${e.symbols.join(", ")}`
-  );
-  return `<deep-memory-repomap>
-${lines.join("\n")}
-</deep-memory-repomap>`;
-}
-
-// src/inject/system-payload.ts
-var TOOL_HINT = 'Memory tools available: memory_search, memory_store, memory_forget, memory_expand, deep_expand. Guidelines:\n  (1) BEFORE making ANY technical decision, search: memory_search(query="decision OR decided OR chose OR \u9009\u62E9 OR \u51B3\u5B9A", scope="project")\n  (2) BEFORE fixing an error, search for known pitfalls: memory_search(query="gotcha OR error OR bug OR \u5751 OR \u9519\u8BEF", scope="project")\n  (3) AFTER fixing an error, store it: memory_store(type="gotcha", content="[error]: ... \u2192 [fix]: ...", scope="project")\n  (4) WHEN user states a constraint/rule, store it: memory_store(type="constraint", content="...", scope="project")\n  (5) WHEN a technical decision is made, store it: memory_store(type="decision", content="[decision]: ... \u2192 [reason]: ...", scope="project")';
-async function composeSystemPayload(opts) {
-  const { state, sessionID, projectPath, mode, searchService, userQuery, logger, tracker } = opts;
-  const agent = sessionID ? state.agentOf(sessionID) : void 0;
-  const tier = classifyAgent(agent);
-  const budget = budgetFor(tier, mode);
-  if (budget.total <= 80) {
-    return {
-      stable: `<deep-memory-stable>
-<tool-hint>${TOOL_HINT}</tool-hint>
-</deep-memory-stable>`,
-      volatile: "",
-      stats: { searchEntries: 0, repoMapEntries: 0, hasCheckpoint: false }
-    };
-  }
-  const staticBudget = Math.floor(budget.memorySummary * 0.4);
-  const searchBudget = budget.memorySummary - staticBudget;
-  let staticMemory = "";
-  if (staticBudget > 0) {
-    const memoryPath = memoryFilePath("project", "memory", projectPath);
-    staticMemory = budgetedRead(memoryPath, staticBudget, ["Constraints", "Rules", "Decisions"]);
-  }
-  const stable = `<deep-memory-stable>
-<tool-hint>${TOOL_HINT}</tool-hint>
-<constraints>
-${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 });
-      if (results.length > 0) {
-        const deduped = dedupByJaccard(results, (r) => r.snippet);
-        const allocated = allocateAndRender(
-          deduped.map((r) => ({
-            score: r.score,
-            heading: r.heading,
-            snippet: r.snippet,
-            scope: r.scope
-          })),
-          { 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, [
-      "User Intent",
-      "Decisions",
-      "Constraints",
-      "Gotchas",
-      "File Changes"
-    ]);
-    hasCheckpoint = !!checkpointContent;
-  }
-  let volatile = `<deep-memory-volatile>
-<relevant>
-${volatileContent || "(none)"}
-</relevant>`;
-  if (checkpointContent) {
-    volatile += `
-<last-checkpoint>
-${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);
-    }
-  }
-  volatile += `
-</deep-memory-volatile>`;
-  logger?.debug("composeSystemPayload", {
-    agent: agent ?? "(undefined)",
-    tier,
-    mode,
-    stableSize: stable.length,
-    volatileSize: volatile.length
-  });
-  return { stable, volatile, stats: { searchEntries, repoMapEntries: repoMapSymbols, hasCheckpoint } };
+function formatWhisper(results, query) {
+  if (results.length === 0) return "";
+  const n = Math.min(results.length, 3);
+  const headings = results.slice(0, n).map((r) => r.heading).join(", ");
+  return `[memory hint: ${n} relevant entries (${headings}) \u2014 call memory_search("${query.slice(0, 40)}") for details]`;
 }
 
 // src/hooks/system-transform.ts
-function createSystemTransformHandler(state, projectPath, searchService, logger, tracker) {
+function createSystemTransformHandler(state, projectPath, searchService, logger) {
   return async (input, output) => {
     if (!input.sessionID) {
       logger?.debug("system.transform: no sessionID, skipping");
       return;
     }
     const sessionID = input.sessionID;
-    let mode = "normal";
-    if (state.hasPendingResume(sessionID)) {
-      const agent2 = state.agentOf(sessionID);
-      const tier2 = classifyAgent(agent2);
-      if (tier2 === "main") {
-        mode = "post-resume";
-        state.consumePendingResume(sessionID);
-      }
-    }
     const userQuery = state.consumeLastUserText(sessionID);
-    const { stable, volatile, stats: payloadStats } = await composeSystemPayload({
+    const { payload, cacheHit, memorySize } = await composeSystemPayload({
       state,
       sessionID,
       projectPath,
-      mode,
-      searchService,
-      userQuery,
-      logger,
-      tracker
+      logger
     });
-    if (stable) {
-      output.system.push(stable);
-    }
-    if (volatile) {
-      output.system.push(volatile);
+    let finalPayload = payload;
+    if (!state.hasGreetedSession(sessionID)) {
+      state.markGreetedSession(sessionID);
+      if (searchService && userQuery) {
+        try {
+          await searchService.ensureIndex();
+          const results = await searchService.search(userQuery, { scope: "all", limit: 10 });
+          if (shouldWhisper(results)) {
+            finalPayload += `
+${formatWhisper(results, userQuery)}`;
+          }
+        } catch {
+        }
+      }
     }
-    const agent = state.agentOf(sessionID);
-    const tier = classifyAgent(agent);
-    logger?.debug("system.transform: injected", {
+    output.system.push(finalPayload);
+    logger?.debug("system.transform V4: injected", {
       sessionID,
-      agent: agent ?? "(undefined)",
-      tier,
-      mode,
-      stableSize: stable.length,
-      volatileSize: volatile.length
+      cacheHit,
+      memorySize,
+      payloadSize: finalPayload.length
     });
     state.mergeNotify({
       injection: {
-        stableSize: stable.length,
-        volatileSize: volatile.length,
-        tier,
-        mode,
-        searchEntries: payloadStats.searchEntries,
-        repoMapEntries: payloadStats.repoMapEntries,
-        hasCheckpoint: payloadStats.hasCheckpoint
+        stableSize: finalPayload.length,
+        volatileSize: 0,
+        tier: "v4",
+        mode: "normal",
+        searchEntries: 0,
+        repoMapEntries: 0,
+        hasCheckpoint: false
       }
     });
   };
 }
 
-// src/schedule/resume.ts
-import fs4 from "fs";
-async function handleSessionCreated(args) {
-  const { state, event, projectPath, logger } = args;
-  const info = event.properties.info;
-  const sessionID = info.id;
-  if (info.parentID) {
-    logger?.debug("resume: skipping sub-session", {
-      sessionID,
-      parentID: info.parentID
-    });
-    return;
-  }
-  if (info.title.startsWith("Memory ")) {
-    logger?.debug("resume: skipping Memory-* session", {
-      sessionID,
-      title: info.title
-    });
-    return;
-  }
-  const projectHash = hashProject(projectPath);
-  const memoryPath = memoryFilePath("project", "memory", projectPath);
-  let memoryExists = false;
-  let memorySize = 0;
-  try {
-    const stat2 = fs4.statSync(memoryPath);
-    memoryExists = stat2.isFile();
-    memorySize = stat2.size;
-  } catch {
-    memoryExists = false;
-  }
-  if (!memoryExists) {
-    logger?.debug("resume: no MEMORY.md found, skipping", {
-      sessionID,
-      projectHash
-    });
-    return;
-  }
-  const wasSet = state.setPendingResume(sessionID, {
-    budgetTokens: 3e3,
-    projectHash
-  });
-  if (wasSet) {
-    logger?.info(
-      `Resume detected for session ${sessionID}, project ${projectHash}, MEMORY.md size ${memorySize}`
-    );
-  }
-}
-
-// src/schedule/auto-dream.ts
-import fs5 from "fs";
-import path5 from "path";
-
-// src/schedule/dream-executor.ts
-var DREAM_PROMPT_TEMPLATE = `You are a memory consolidation agent. Your task is to refine the project's persistent memory by reviewing raw notes and checkpoints, then storing durable findings.
-
-Project context:
-- Project path: {{projectPath}}
-- Notes file: {{notesFilePath}}
-- Sessions dir: {{sessionsDir}}
-
-Steps:
-1. Read the notes file at {{notesFilePath}}. These are raw captures from recent sessions (user messages with trigger keywords like "\u8BB0\u4F4F", "remember", "decided").
-2. Use the \`list\` tool to find checkpoint.md files under {{sessionsDir}}. Read the 5 most recent ones.
-3. Identify recurring themes across notes + checkpoints:
-   - Decisions that have been confirmed or acted upon (call memory_store with type="decision")
-   - Hard constraints or rules the user explicitly stated (call memory_store with type="constraint")
-   - Gotchas, errors, and their fixes (call memory_store with type="gotcha")
-   - Important facts about the codebase or domain (call memory_store with type="fact")
-4. Before storing each finding, call memory_search with a relevant phrase to avoid duplicating existing entries. Skip if a near-identical entry already exists.
-5. After storing all findings, append a section to {{notesFilePath}}:
-   ## Consolidated {{ISO timestamp}}
-   (Move processed entries under this header \u2014 do NOT delete them, preserve audit trail.)
-
-VERIFICATION STEP (before storing each finding):
-For each memory that references a specific source file:
-1. Use the read tool to check the file still exists and contains the referenced symbol
-2. If the file no longer exists or the referenced function/class/variable was removed/renamed:
-   - Call memory_forget to remove the stale entry
-   - Do NOT store the new finding
-3. Only store memories that reference files and symbols that STILL EXIST in the codebase
-4. Limit verification to 5 files maximum (do not read more than 5 files during this dream cycle)
-
-Be selective: only store findings that will matter in future sessions. Skip transient details, tool output noise, and one-off questions. Aim for 5-15 high-quality entries per dream cycle.
-
-IMPORTANT: Only consolidate findings about the PROJECT DOMAIN. Do NOT store meta-patterns about the memory plugin itself (e.g., "user says \u8BB0\u4F4F \u2192 call memory_store"). Those are plugin internals, not project knowledge.
-
-When done, output a brief summary: "Consolidated N findings (D decisions, C constraints, G gotchas, F facts)."`;
-function buildPrompt(projectPath) {
-  const notesFilePath = memoryFilePath("project", "notes", projectPath);
-  const sessionsDir = scopeDir("project", projectPath) + "/sessions";
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  return DREAM_PROMPT_TEMPLATE.replaceAll("{{projectPath}}", projectPath).replaceAll("{{notesFilePath}}", notesFilePath).replaceAll("{{sessionsDir}}", sessionsDir).replaceAll("{{ISO timestamp}}", timestamp);
-}
-async function runDream(opts) {
-  const { client, parentSessionID, projectPath, directory, logger } = opts;
-  let dreamSessionID = "";
-  try {
-    const result = await client.session.create({
-      body: {
-        parentID: parentSessionID,
-        title: `Memory Dream Consolidation ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`
-      },
-      query: { directory }
-    });
-    dreamSessionID = result.data?.id ?? "";
-    if (!dreamSessionID) {
-      logger?.error("dream-executor: session.create returned no ID", {
-        parentSessionID
-      });
-      return { sessionID: "", status: "failed" };
-    }
-    const prompt = buildPrompt(projectPath);
-    await client.session.promptAsync({
-      path: { id: dreamSessionID },
-      body: {
-        parts: [{ type: "text", text: prompt }],
-        agent: "general",
-        ...opts.model ? { model: opts.model } : {},
-        tools: {
-          memory_search: true,
-          memory_store: true,
-          memory_forget: true,
-          read: true,
-          list: true
-        }
-      }
-    });
-    logger?.info("dream-executor: dream session spawned", {
-      dreamSessionID,
-      parentSessionID
-    });
-    return { sessionID: dreamSessionID, status: "spawned" };
-  } catch (err) {
-    logger?.error("dream-executor: failed to run dream", {
-      dreamSessionID,
-      parentSessionID,
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return { sessionID: dreamSessionID || "", status: "failed" };
-  }
-}
-
-// src/schedule/auto-dream.ts
-var DREAM_INTERVAL_MS = 7 * 24 * 60 * 60 * 1e3;
-var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
-var NOTES_ACCUMULATION_THRESHOLD = 20;
-var DEFAULT_SCHEDULE = {
-  lastDream: null,
-  lastDistill: null
-};
-function readScheduleFile(projectPath, dataRoot) {
-  const filePath = scheduleFilePath(projectPath, dataRoot);
-  try {
-    const raw = fs5.readFileSync(filePath, "utf8");
-    const parsed = JSON.parse(raw);
-    return {
-      lastDream: parsed.lastDream ?? null,
-      lastDistill: parsed.lastDistill ?? null,
-      queuedDream: parsed.queuedDream,
-      queuedDreamReason: parsed.queuedDreamReason
-    };
-  } catch {
-    return { ...DEFAULT_SCHEDULE };
-  }
-}
-function writeScheduleFile(projectPath, data, dataRoot) {
-  const filePath = scheduleFilePath(projectPath, dataRoot);
-  fs5.mkdirSync(path5.dirname(filePath), { recursive: true });
-  fs5.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf8");
-}
-async function handleSessionCreatedForDream(args) {
-  const { event, config: config2 } = args;
-  const { client, projectPath, logger } = config2;
-  const info = event.properties.info;
-  if (info.parentID) {
-    logger?.debug("auto-dream: skipping sub-session", {
-      sessionID: info.id,
-      parentID: info.parentID
-    });
-    return;
-  }
-  if (info.title.startsWith("Memory ")) {
-    logger?.debug("auto-dream: skipping Memory session", {
-      sessionID: info.id,
-      title: info.title
-    });
-    return;
-  }
-  const schedule = readScheduleFile(projectPath);
-  logger?.debug("auto-dream: schedule state", {
-    lastDream: schedule.lastDream,
-    queuedDream: schedule.queuedDream
-  });
-  if (schedule.queuedDream) {
-    logger?.info("auto-dream: attempting queued dream", {
-      reason: schedule.queuedDreamReason
-    });
-    try {
-      const result = await runDream({
-        client,
-        parentSessionID: info.id,
-        projectPath,
-        directory: info.directory,
-        logger
-      });
-      if (result.status === "spawned") {
-        schedule.queuedDream = void 0;
-        schedule.queuedDreamReason = void 0;
-        writeScheduleFile(projectPath, schedule);
-        logger?.info("auto-dream: queued dream succeeded, flag cleared");
-      } else {
-        logger?.warn("auto-dream: queued dream still failing, leaving flag");
-      }
-    } catch (err) {
-      logger?.warn("auto-dream: queued dream attempt threw", {
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-    return;
-  }
-  const notesPath = memoryFilePath("project", "notes", projectPath);
-  let notesLines = 0;
-  let notesContent = "";
-  try {
-    notesContent = fs5.readFileSync(notesPath, "utf8");
-    if (notesContent.trim().length === 0) {
-      logger?.debug("auto-dream: notes.md is empty, skipping spawn");
-      return;
-    }
-    notesLines = notesContent.split("\n").filter((l) => l.trim()).length;
-  } catch {
-    logger?.debug("auto-dream: notes.md not found, skipping spawn");
-    return;
-  }
-  const memoryPath = memoryFilePath("project", "memory", projectPath);
-  if (!fs5.existsSync(memoryPath) || fs5.statSync(memoryPath).size < 50) {
-    if (notesLines >= 5) {
-      try {
-        fs5.writeFileSync(memoryPath, notesContent, "utf8");
-        logger?.info("auto-dream: bootstrapped MEMORY.md from notes.md", {
-          notesLines
-        });
-      } catch (err) {
-        logger?.warn("auto-dream: failed to bootstrap MEMORY.md", {
-          error: err instanceof Error ? err.message : String(err)
-        });
-        return;
-      }
-    } else {
-      logger?.debug("auto-dream: MEMORY.md missing and notes too small, skipping", {
-        sessionID: info.id
-      });
-      return;
-    }
-  }
-  const isSevenDayDue = schedule.lastDream === null || Date.now() - Date.parse(schedule.lastDream) > DREAM_INTERVAL_MS;
-  let isAccumulationDue = false;
-  if (!isSevenDayDue && schedule.lastDream !== null) {
-    const hoursSinceLastDream = (Date.now() - Date.parse(schedule.lastDream)) / ONE_DAY_MS;
-    if (hoursSinceLastDream >= 1 && notesLines > NOTES_ACCUMULATION_THRESHOLD) {
-      isAccumulationDue = true;
-      logger?.info("auto-dream: accumulation trigger", {
-        notesLines,
-        hoursSinceLastDream: hoursSinceLastDream.toFixed(1)
-      });
-    }
-  }
-  if (!isSevenDayDue && !isAccumulationDue) {
-    logger?.debug("auto-dream: not due, skipping");
-    return;
-  }
-  schedule.lastDream = (/* @__PURE__ */ new Date()).toISOString();
-  try {
-    writeScheduleFile(projectPath, schedule);
-  } catch (err) {
-    logger?.error("auto-dream: failed to write schedule file", {
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return;
-  }
-  logger?.info("auto-dream: spawning dream session", {
-    sessionID: info.id,
-    directory: info.directory
-  });
-  try {
-    runDream({
-      client,
-      parentSessionID: info.id,
-      projectPath,
-      directory: info.directory,
-      logger
-    }).catch((err) => {
-      logger?.error("auto-dream: dream spawn failed unexpectedly", {
-        error: err instanceof Error ? err.message : String(err)
-      });
-      try {
-        const fallback = readScheduleFile(projectPath);
-        fallback.queuedDream = true;
-        fallback.queuedDreamReason = `Unexpected failure: ${err instanceof Error ? err.message : String(err)}`;
-        writeScheduleFile(projectPath, fallback);
-      } catch {
-        logger?.error("auto-dream: failed to set queuedDream flag after error");
-      }
-    });
-  } catch (err) {
-    logger?.error("auto-dream: failed to kick off dream", {
-      error: err instanceof Error ? err.message : String(err)
-    });
-    try {
-      schedule.queuedDream = true;
-      schedule.queuedDreamReason = `Kickoff failure: ${err instanceof Error ? err.message : String(err)}`;
-      writeScheduleFile(projectPath, schedule);
-    } catch {
-      logger?.error("auto-dream: failed to set queuedDream flag");
-    }
-  }
-}
-
-// src/schedule/auto-distill.ts
-import fs6 from "fs";
-import path6 from "path";
-
-// src/schedule/distill-executor.ts
-var DISTILL_INTERVAL_MS = 30 * 24 * 60 * 60 * 1e3;
-var DISTILL_PROMPT_TEMPLATE = `You are a workflow distillation agent. Your task is to identify recurring patterns in the project's memory and package them as reusable skill candidates.
-
-Project context:
-- Project path: {{projectPath}}
-- Memory file: {{memoryFilePath}}
-- Notes file: {{notesFilePath}}
-- Sessions dir: {{sessionsDir}}
-- Output file: {{outputFilePath}}
-
-Steps:
-1. Read the memory file at {{memoryFilePath}} and the notes file at {{notesFilePath}}. Identify recurring workflows \u2014 patterns of tool calls or multi-step procedures that appear 3+ times across sessions.
-2. Use the \`list\` tool to find checkpoint.md files under {{sessionsDir}}. Read the 10 most recent ones to find additional recurring patterns.
-3. For each recurring workflow you identify, draft a skill candidate as Markdown with these sections:
-   - **Trigger**: when to use this workflow (natural language description)
-   - **Steps**: ordered list of concrete actions
-   - **Tools**: which tools are involved
-   - **Example**: one concrete instance from session history
-4. Before storing each finding, call memory_search with a relevant phrase to avoid duplicating existing entries. Skip if a near-identical entry already exists.
-5. Use memory_store with type="fact" and scope="project" to record each distilled workflow. Each entry must be at most 300 characters \u2014 be concise, no code blocks.
-6. Write all skill candidates to {{outputFilePath}} for human review.
-
-IMPORTANT: Only distill workflows related to the PROJECT DOMAIN (e.g., code patterns, testing procedures, deployment steps). Do NOT distill meta-patterns about the memory plugin itself (e.g., "user says \u8BB0\u4F4F \u2192 call memory_store"). Those are plugin internals, not reusable project knowledge.
-
-VERIFICATION STEP (before storing each finding):
-For each memory that references a specific source file:
-1. Use the read tool to check the file still exists and contains the referenced symbol
-2. If the file no longer exists or the referenced function/class/variable was removed/renamed:
-   - Call memory_forget to remove the stale entry
-   - Do NOT store the new finding
-3. Only store memories that reference files and symbols that STILL EXIST in the codebase
-4. Limit verification to 5 files maximum (do not read more than 5 files during this distill cycle)
-
-Distillation is about reusable patterns, not one-off actions. Skip anything that happened only once.
-
-When done, output a brief summary: "Distilled N workflow candidates."`;
-function buildPrompt2(projectPath) {
-  const memoryFilePathStr = memoryFilePath("project", "memory", projectPath);
-  const notesFilePath = memoryFilePath("project", "notes", projectPath);
-  const sessionsDir = scopeDir("project", projectPath) + "/sessions";
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const outputFilePath = scopeDir("project", projectPath) + `/distill-${timestamp.slice(0, 10)}.md`;
-  return DISTILL_PROMPT_TEMPLATE.replaceAll("{{projectPath}}", projectPath).replaceAll("{{memoryFilePath}}", memoryFilePathStr).replaceAll("{{notesFilePath}}", notesFilePath).replaceAll("{{sessionsDir}}", sessionsDir).replaceAll("{{outputFilePath}}", outputFilePath).replaceAll("{{ISO timestamp}}", timestamp);
-}
-async function runDistill(opts) {
-  const { client, parentSessionID, projectPath, directory, logger } = opts;
-  let distillSessionID = "";
-  try {
-    const result = await client.session.create({
-      body: {
-        parentID: parentSessionID,
-        title: `Memory Distill Workflow Packaging ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`
-      },
-      query: { directory }
-    });
-    distillSessionID = result.data?.id ?? "";
-    if (!distillSessionID) {
-      logger?.error("distill-executor: session.create returned no ID", {
-        parentSessionID
-      });
-      return { sessionID: "", status: "failed" };
-    }
-    const prompt = buildPrompt2(projectPath);
-    await client.session.promptAsync({
-      path: { id: distillSessionID },
-      body: {
-        parts: [{ type: "text", text: prompt }],
-        agent: "general",
-        ...opts.model ? { model: opts.model } : {},
-        tools: {
-          memory_search: true,
-          memory_store: true,
-          memory_forget: true,
-          read: true,
-          list: true
-        }
-      }
-    });
-    logger?.info("distill-executor: distill session spawned", {
-      distillSessionID,
-      parentSessionID
-    });
-    return { sessionID: distillSessionID, status: "spawned" };
-  } catch (err) {
-    logger?.error("distill-executor: failed to run distill", {
-      distillSessionID,
-      parentSessionID,
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return { sessionID: distillSessionID || "", status: "failed" };
-  }
-}
-
-// src/schedule/auto-distill.ts
-var DEFAULT_SCHEDULE2 = {
-  lastDream: null,
-  lastDistill: null
-};
-function readScheduleFile2(projectPath) {
-  const filePath = scheduleFilePath(projectPath);
-  try {
-    const raw = fs6.readFileSync(filePath, "utf8");
-    const parsed = JSON.parse(raw);
-    return {
-      lastDream: parsed["lastDream"] ?? null,
-      lastDistill: parsed["lastDistill"] ?? null,
-      queuedDream: parsed["queuedDream"],
-      queuedDreamReason: parsed["queuedDreamReason"],
-      queuedDistill: parsed["queuedDistill"],
-      queuedDistillReason: parsed["queuedDistillReason"]
-    };
-  } catch {
-    return { ...DEFAULT_SCHEDULE2 };
-  }
-}
-function writeScheduleFile2(projectPath, data) {
-  const filePath = scheduleFilePath(projectPath);
-  fs6.mkdirSync(path6.dirname(filePath), { recursive: true });
-  fs6.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf8");
-}
-async function handleSessionCreatedForDistill(args) {
-  const { event, config: config2 } = args;
-  const { client, projectPath, logger } = config2;
-  const info = event.properties.info;
-  if (info.parentID) {
-    logger?.debug("auto-distill: skipping sub-session", {
-      sessionID: info.id,
-      parentID: info.parentID
-    });
-    return;
-  }
-  if (info.title.startsWith("Memory ")) {
-    logger?.debug("auto-distill: skipping Memory session", {
-      sessionID: info.id,
-      title: info.title
-    });
-    return;
-  }
-  const schedule = readScheduleFile2(projectPath);
-  logger?.debug("auto-distill: schedule state", {
-    lastDistill: schedule.lastDistill,
-    queuedDistill: schedule.queuedDistill
-  });
-  if (schedule.queuedDistill) {
-    logger?.info("auto-distill: attempting queued distill", {
-      reason: schedule.queuedDistillReason
-    });
-    try {
-      const result = await runDistill({
-        client,
-        parentSessionID: info.id,
-        projectPath,
-        directory: info.directory,
-        logger
-      });
-      if (result.status === "spawned") {
-        schedule.queuedDistill = void 0;
-        schedule.queuedDistillReason = void 0;
-        writeScheduleFile2(projectPath, schedule);
-        logger?.info("auto-distill: queued distill succeeded, flag cleared");
-      } else {
-        logger?.warn("auto-distill: queued distill still failing, leaving flag");
-      }
-    } catch (err) {
-      logger?.warn("auto-distill: queued distill attempt threw", {
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-    return;
-  }
-  const memoryPath = memoryFilePath("project", "memory", projectPath);
-  if (!fs6.existsSync(memoryPath) || fs6.statSync(memoryPath).size < 50) {
-    logger?.debug("auto-distill: MEMORY.md missing or too small, skipping", {
-      sessionID: info.id
-    });
-    return;
-  }
-  const isDue = schedule.lastDistill == null || Date.now() - Date.parse(schedule.lastDistill) > DISTILL_INTERVAL_MS;
-  if (!isDue) {
-    logger?.debug("auto-distill: not due, skipping");
-    return;
-  }
-  schedule.lastDistill = (/* @__PURE__ */ new Date()).toISOString();
-  try {
-    writeScheduleFile2(projectPath, schedule);
-  } catch (err) {
-    logger?.error("auto-distill: failed to write schedule file", {
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return;
-  }
-  logger?.info("auto-distill: spawning distill session", {
-    sessionID: info.id,
-    directory: info.directory
-  });
-  try {
-    runDistill({
-      client,
-      parentSessionID: info.id,
-      projectPath,
-      directory: info.directory,
-      logger
-    }).catch((err) => {
-      logger?.error("auto-distill: distill spawn failed unexpectedly", {
-        error: err instanceof Error ? err.message : String(err)
-      });
-      try {
-        const fallback = readScheduleFile2(projectPath);
-        fallback.queuedDistill = true;
-        fallback.queuedDistillReason = `Unexpected failure: ${err instanceof Error ? err.message : String(err)}`;
-        writeScheduleFile2(projectPath, fallback);
-      } catch {
-        logger?.error("auto-distill: failed to set queuedDistill flag after error");
-      }
-    });
-  } catch (err) {
-    logger?.error("auto-distill: failed to kick off distill", {
-      error: err instanceof Error ? err.message : String(err)
-    });
-    try {
-      schedule.queuedDistill = true;
-      schedule.queuedDistillReason = `Kickoff failure: ${err instanceof Error ? err.message : String(err)}`;
-      writeScheduleFile2(projectPath, schedule);
-    } catch {
-      logger?.error("auto-distill: failed to set queuedDistill flag");
-    }
-  }
-}
-
 // src/search/service.ts
-import fs8 from "fs/promises";
+import fs6 from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-import path8 from "path";
+import path5 from "path";
 
 // src/search/bm25.ts
 var BM25Index = class _BM25Index {
@@ -1764,14 +814,14 @@ var BM25Index = class _BM25Index {
 };
 
 // src/search/reconcile.ts
-import fs7 from "fs/promises";
-import path7 from "path";
+import fs5 from "fs/promises";
+import path4 from "path";
 import { existsSync, readFileSync } from "fs";
 
 // src/search/tokenizer.ts
 var CJK_RE = /[\u4E00-\u9FFF\u3400-\u4DBF\uF900-\uFAFF\u3040-\u309F\u30A0-\u30FF]/;
 var TOKEN_SPLIT_RE = /[\s\p{P}]+/u;
-function tokenize2(text) {
+function tokenize(text) {
   if (!text) return [];
   const tokens = [];
   let cjkRun = "";
@@ -1812,7 +862,7 @@ function tokenizeQuery(text) {
   const phrases = text.split("|");
   const result = [];
   for (const phrase of phrases) {
-    const tokens = tokenize2(phrase.trim());
+    const tokens = tokenize(phrase.trim());
     if (tokens.length > 0) result.push(tokens);
   }
   return result;
@@ -1921,13 +971,13 @@ var Reconciler = class {
         dir = projectMemoryDir(this.projectPath);
         break;
       case "session": {
-        const sessionsDir = path7.join(projectMemoryDir(this.projectPath), "sessions");
+        const sessionsDir = path4.join(projectMemoryDir(this.projectPath), "sessions");
         if (!existsSync(sessionsDir)) return [];
-        const sessionDirs = await fs7.readdir(sessionsDir);
+        const sessionDirs = await fs5.readdir(sessionsDir);
         for (const sid of sessionDirs) {
-          const sessionDir = path7.join(sessionsDir, sid);
-          const stat2 = await fs7.stat(sessionDir);
-          if (!stat2.isDirectory()) continue;
+          const sessionDir = path4.join(sessionsDir, sid);
+          const stat = await fs5.stat(sessionDir);
+          if (!stat.isDirectory()) continue;
           const files = await this.walkMarkdown(sessionDir, scope);
           results.push(...files);
         }
@@ -1944,16 +994,16 @@ var Reconciler = class {
     const results = [];
     let entries;
     try {
-      entries = await fs7.readdir(dir);
+      entries = await fs5.readdir(dir);
     } catch {
       return [];
     }
     for (const entry of entries) {
-      const fullPath = path7.join(dir, entry);
+      const fullPath = path4.join(dir, entry);
       try {
-        const stat2 = await fs7.stat(fullPath);
-        if (stat2.isFile() && entry.endsWith(".md")) {
-          results.push({ path: fullPath, scope, mtime: stat2.mtimeMs });
+        const stat = await fs5.stat(fullPath);
+        if (stat.isFile() && entry.endsWith(".md")) {
+          results.push({ path: fullPath, scope, mtime: stat.mtimeMs });
         }
       } catch {
       }
@@ -1966,7 +1016,7 @@ var Reconciler = class {
   async indexFile(file2) {
     let content;
     try {
-      content = await fs7.readFile(file2.path, "utf8");
+      content = await fs5.readFile(file2.path, "utf8");
     } catch {
       return;
     }
@@ -1975,7 +1025,7 @@ var Reconciler = class {
     for (const section of sections) {
       const docId = section.heading ? `${file2.path}#${section.heading}` : file2.path;
       const textToTokenize = section.heading ? `${section.heading} ${section.body}` : section.body;
-      const tokens = tokenize2(textToTokenize);
+      const tokens = tokenize(textToTokenize);
       if (tokens.length > 0) {
         let timestamp;
         const tsMatch = section.body.match(/\[(\d{4}-\d{2}-\d{2})\]/);
@@ -2022,11 +1072,11 @@ var Reconciler = class {
    */
   async saveIndexState() {
     const statePath = this.getStatePath();
-    const dir = path7.dirname(statePath);
-    await fs7.mkdir(dir, { recursive: true });
+    const dir = path4.dirname(statePath);
+    await fs5.mkdir(dir, { recursive: true });
     const release = await acquireLock(statePath);
     try {
-      await fs7.writeFile(
+      await fs5.writeFile(
         statePath,
         JSON.stringify(this.indexState, null, 2),
         "utf8"
@@ -2062,6 +1112,9 @@ var SearchService = class {
       index: this.index
     });
   }
+  get project() {
+    return this.projectPath;
+  }
   /**
    * Ensure the index is initialized. Lazy — calls Reconciler.sync() on first call.
    */
@@ -2137,14 +1190,14 @@ var SearchService = class {
       void 0,
       this.dataRoot
     );
-    await fs8.mkdir(path8.dirname(filePath), { recursive: true });
+    await fs6.mkdir(path5.dirname(filePath), { recursive: true });
     const heading = `## ${section}`;
     const entry = `- ${content.trim()}`;
     const release = await acquireLock(filePath);
     try {
       let existing = "";
       if (existsSync2(filePath)) {
-        existing = await fs8.readFile(filePath, "utf8");
+        existing = await fs6.readFile(filePath, "utf8");
       }
       const headingIdx = existing.indexOf(heading);
       if (headingIdx !== -1) {
@@ -2153,14 +1206,14 @@ var SearchService = class {
           const before = existing.slice(0, afterHeading);
           const after = existing.slice(afterHeading);
           const newContent = before + "\n" + entry + "\n" + after;
-          await fs8.writeFile(filePath, newContent, "utf8");
+          await fs6.writeFile(filePath, newContent, "utf8");
         } else {
           const newContent = existing.trimEnd() + "\n" + entry + "\n";
-          await fs8.writeFile(filePath, newContent, "utf8");
+          await fs6.writeFile(filePath, newContent, "utf8");
         }
       } else {
         const newContent = existing.trimEnd() + "\n\n" + heading + "\n" + entry + "\n";
-        await fs8.writeFile(filePath, newContent, "utf8");
+        await fs6.writeFile(filePath, newContent, "utf8");
       }
     } finally {
       release();
@@ -2192,7 +1245,7 @@ var SearchService = class {
     const release = await acquireLock(filePath);
     let removed = 0;
     try {
-      const content = await fs8.readFile(filePath, "utf8");
+      const content = await fs6.readFile(filePath, "utf8");
       const lines = content.split("\n");
       const kept = [];
       for (const line of lines) {
@@ -2206,7 +1259,7 @@ var SearchService = class {
         kept.push(line);
       }
       if (removed > 0) {
-        await fs8.writeFile(filePath, kept.join("\n"), "utf8");
+        await fs6.writeFile(filePath, kept.join("\n"), "utf8");
       }
     } finally {
       release();
@@ -2253,7 +1306,7 @@ var SearchService = class {
   async extractSnippet(filePath, heading, matchedTerms) {
     let content;
     try {
-      content = await fs8.readFile(filePath, "utf8");
+      content = await fs6.readFile(filePath, "utf8");
     } catch {
       return "";
     }
@@ -2288,7 +1341,7 @@ var SearchService = class {
 };
 
 // src/tools/index.ts
-import { tool as tool4 } from "@opencode-ai/plugin";
+import { tool as tool5 } from "@opencode-ai/plugin";
 
 // src/tools/memory-search.ts
 import { tool } from "@opencode-ai/plugin";
@@ -2325,6 +1378,25 @@ function createMemorySearchTool(service) {
 
 // src/tools/memory-store.ts
 import { tool as tool2 } from "@opencode-ai/plugin";
+import fs7 from "fs";
+import nodePath2 from "path";
+var MEMORY_MAX_LINES = 200;
+var MEMORY_MAX_BYTES = 25e3;
+async function checkOverflow(filePath) {
+  try {
+    const content = await fs7.promises.readFile(filePath, "utf8");
+    return { lines: content.split("\n").length, bytes: content.length };
+  } catch {
+    return { lines: 0, bytes: 0 };
+  }
+}
+async function archiveEntry(filePath, entry) {
+  const archivePath = filePath.replace("MEMORY.md", "MEMORY-archive.md");
+  await fs7.promises.mkdir(nodePath2.dirname(archivePath), { recursive: true });
+  await fs7.promises.appendFile(archivePath, `
+${entry}
+`, "utf8");
+}
 function createMemoryStoreTool(service) {
   return tool2({
     description: "Store a memory entry (decision, constraint, gotcha, fact, note) to persistent memory.",
@@ -2344,6 +1416,12 @@ function createMemoryStoreTool(service) {
       const section = sectionMap[args.type] ?? "Notes";
       const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       const contentWithDate = `${args.content} [${today}]`;
+      const memoryPath = memoryFilePath(args.scope, "memory", service.project);
+      const { lines, bytes } = await checkOverflow(memoryPath);
+      if (lines >= MEMORY_MAX_LINES || bytes >= MEMORY_MAX_BYTES) {
+        await archiveEntry(memoryPath, `- ${contentWithDate}`);
+        return `MEMORY.md at cap (${lines} lines/${bytes} bytes). Entry archived to MEMORY-archive.md. Use memory_search on MEMORY.md content; archived entries are available for manual review.`;
+      }
       await service.addEntry(args.scope, "memory", section, contentWithDate);
       return `Stored ${args.type} in ${args.scope} memory under ## ${section}`;
     }
@@ -3125,10 +2203,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path12) {
-  if (!path12)
+function getElementAtPath(obj, path9) {
+  if (!path9)
     return obj;
-  return path12.reduce((acc, key) => acc?.[key], obj);
+  return path9.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -3489,11 +2567,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path12, issues) {
+function prefixIssues(path9, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path12);
+    iss.path.unshift(path9);
     return iss;
   });
 }
@@ -3661,7 +2739,7 @@ function treeifyError(error45, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error46, path12 = []) => {
+  const processError = (error46, path9 = []) => {
     var _a, _b;
     for (const issue2 of error46.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -3671,7 +2749,7 @@ function treeifyError(error45, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path12, ...issue2.path];
+        const fullpath = [...path9, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -3703,8 +2781,8 @@ function treeifyError(error45, _mapper) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path12 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path12) {
+  const path9 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path9) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14811,7 +13889,7 @@ function date4(params) {
 config(en_default());
 
 // src/tools/memory-expand.ts
-import fs9 from "fs";
+import fs8 from "fs";
 function createMemoryExpandTool(opts) {
   return {
     description: "Expand compressed context \u2014 retrieve original content of a message that was stripped by the memory plugin's context compression. Use when you need to see the full reasoning, tool output, or text of an old message that was compressed.",
@@ -14820,11 +13898,11 @@ function createMemoryExpandTool(opts) {
     }).shape,
     execute: async (args) => {
       const rawPath = checkpointRawPath(opts.projectPath, "");
-      if (!fs9.existsSync(rawPath)) {
+      if (!fs8.existsSync(rawPath)) {
         return "No checkpoint.raw.json found. No compressed messages to expand.";
       }
       try {
-        const raw = JSON.parse(fs9.readFileSync(rawPath, "utf8"));
+        const raw = JSON.parse(fs8.readFileSync(rawPath, "utf8"));
         const messages = raw.messages || [];
         const msg = messages.find(
           (m) => m.info?.id === args.messageID
@@ -14876,53 +13954,45 @@ ${part.thinking || part.text || "[empty]"}
   return output;
 }
 
-// src/compress/ccr.ts
-import { createHash as createHash2 } from "crypto";
-var CCR_TTL_MS = 30 * 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
+// src/tools/context-compress.ts
+import { tool as tool4 } from "@opencode-ai/plugin";
+function createContextCompressTool(state) {
+  return tool4({
+    description: "Compress older conversation context to reclaim token budget. Triggers compression of old tool outputs on the next turn \u2014 originals recoverable via deep_expand. Use when the conversation feels long or you're losing track of early context.",
+    args: {
+      keep_recent: tool4.schema.number().default(8).describe("Number of recent messages to protect from compression (default 8)")
+    },
+    async execute(args) {
+      const keep = Math.max(2, Math.floor(args.keep_recent));
+      state.requestCompression(keep);
+      return {
+        title: "Compression requested",
+        output: `Will compress tool outputs older than the last ${keep} messages on the next turn. Protected: memory_*, edit, write, todowrite, skill. Originals stored in CCR \u2014 call deep_expand("<hash>") to restore any compressed content.`
+      };
+    }
   });
-  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) {
+function createMemoryTools(service, state, opts) {
   const search = createMemorySearchTool(service);
   const store = createMemoryStoreTool(service);
   const forget = createMemoryForgetTool(service);
   const expand = opts?.projectPath ? createMemoryExpandTool({ projectPath: opts.projectPath }) : createMemoryExpandTool({ projectPath: "" });
+  const compress = createContextCompressTool(state);
   return {
     memory_search: search,
     memory_store: store,
     memory_forget: forget,
-    memory_expand: expand
+    memory_expand: expand,
+    context_compress: compress
   };
 }
 function createDeepExpandTool(state) {
-  return tool4({
+  return tool5({
     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")
+      hash: tool5.schema.string().describe("The hash from the [ccr:HASH] marker")
     },
     execute: async (args) => {
       const original = ccrRetrieve(state, args.hash);
@@ -14933,8 +14003,8 @@ function createDeepExpandTool(state) {
 }
 
 // src/extract/capture.ts
-import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import path9 from "path";
+import { writeFile, mkdir } from "fs/promises";
+import path6 from "path";
 async function captureMessages(args) {
   const { client, sessionID, projectPath, logger } = args;
   let result;
@@ -14962,10 +14032,10 @@ async function captureMessages(args) {
     null,
     2
   );
-  await mkdir2(path9.dirname(rawFilePath), { recursive: true });
+  await mkdir(path6.dirname(rawFilePath), { recursive: true });
   const release = await acquireLock(rawFilePath);
   try {
-    await writeFile2(rawFilePath, payload, "utf-8");
+    await writeFile(rawFilePath, payload, "utf-8");
   } finally {
     release();
   }
@@ -15089,17 +14159,17 @@ function extractFileChanges(messages) {
   for (const msg of messages) {
     for (const part of msg.parts) {
       if (part.type !== "tool" || !part.tool) continue;
-      const tool5 = part.tool.toLowerCase();
-      if (tool5 === "write" || tool5 === "edit") {
+      const tool6 = part.tool.toLowerCase();
+      if (tool6 === "write" || tool6 === "edit") {
         const filePath = part.args?.filePath || part.args?.path || "";
         if (filePath) {
-          const key = `${filePath}:${tool5}`;
+          const key = `${filePath}:${tool6}`;
           if (!seen.has(key)) {
             seen.add(key);
-            changes.push({ path: filePath, operation: tool5 });
+            changes.push({ path: filePath, operation: tool6 });
           }
         }
-      } else if (tool5 === "bash" || tool5 === "execute") {
+      } else if (tool6 === "bash" || tool6 === "execute") {
         const cmd = part.args?.command || "";
         const match = BASH_FILE_OP_RE.exec(cmd);
         if (match?.[1]) {
@@ -15125,8 +14195,8 @@ function extractHeuristics(messages) {
 }
 
 // src/extract/checkpoint-writer.ts
-import { writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import path10 from "path";
+import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import path7 from "path";
 function renderCheckpoint(args) {
   const { sessionID, tokenEstimate, result } = args;
   const lines = [];
@@ -15181,10 +14251,10 @@ function renderCheckpoint(args) {
 async function writeCheckpoint(args) {
   const { projectPath, content, logger } = args;
   const filePath = memoryFilePath("project", "checkpoint", projectPath);
-  await mkdir3(path10.dirname(filePath), { recursive: true });
+  await mkdir2(path7.dirname(filePath), { recursive: true });
   const release = await acquireLock(filePath);
   try {
-    await writeFile3(filePath, content, "utf-8");
+    await writeFile2(filePath, content, "utf-8");
   } finally {
     release();
   }
@@ -15192,8 +14262,71 @@ async function writeCheckpoint(args) {
   return filePath;
 }
 
+// src/extract/consolidate.ts
+function tokenize2(s) {
+  return s.toLowerCase().split(/[\s\-,.\[\](){}:]+/).filter((w) => w.length > 2);
+}
+function simHash(s, bits = 64) {
+  const tokens = tokenize2(s);
+  if (tokens.length === 0) return 0;
+  const v = new Int8Array(bits);
+  for (const token of tokens) {
+    let h = 0;
+    for (let i = 0; i < token.length; i++) {
+      h = (h << 5) - h + token.charCodeAt(i) | 0;
+    }
+    for (let i = 0; i < bits; i++) {
+      if (h >> i & 1) v[i]++;
+      else v[i]--;
+    }
+  }
+  let hash2 = 0;
+  for (let i = 0; i < bits; i++) {
+    if (v[i] > 0) hash2 |= 1 << i;
+  }
+  return hash2;
+}
+function hammingDistance(a, b) {
+  let xor = a ^ b;
+  let dist = 0;
+  while (xor) {
+    dist += xor & 1;
+    xor >>>= 1;
+  }
+  return dist;
+}
+function similarity(a, b, bits = 64) {
+  return 1 - hammingDistance(a, b) / bits;
+}
+var SIMILARITY_THRESHOLD = 0.92;
+var STALE_BINDING_RE = /^(- \[[^\]]+\] )(src\/[^\s:]+:[^\s:]+)(?::[a-f0-9]+)?\s/;
+function consolidateMemory(content, opts = {}) {
+  if (!content.trim()) return content;
+  const lines = content.split("\n");
+  const staleSet = new Set(opts.staleFilePaths ?? []);
+  const seen = [];
+  const result = [];
+  for (const line of lines) {
+    if (!line.startsWith("- [")) {
+      result.push(line);
+      continue;
+    }
+    if (staleSet.size > 0) {
+      const m = line.match(STALE_BINDING_RE);
+      if (m && staleSet.has(m[2])) continue;
+    }
+    const hash2 = simHash(line);
+    const isDup = seen.some((s) => similarity(hash2, s.hash) >= SIMILARITY_THRESHOLD);
+    if (isDup) continue;
+    seen.push({ hash: hash2, line });
+    result.push(line);
+  }
+  return result.join("\n");
+}
+
 // src/hooks/compacting.ts
-import { readFile as readFile2 } from "fs/promises";
+import { readFile, writeFile as writeFile3 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
 
 // src/extract/summarize.ts
 var HANDOFF_PREFIX = `Another OpenCode session started by the same user was working on this task. It was compacted mid-conversation to save context space. Review the summary below to understand what happened and continue from where it left off.`;
@@ -15242,7 +14375,7 @@ Be concise. Prefer structured lists over prose. Focus on what the next LLM NEEDS
 
 // src/hooks/compacting.ts
 function createCompactingHandler(args) {
-  const { client, state, projectPath, logger, tracker } = args;
+  const { client, projectPath, logger, tracker } = args;
   return async (input, output) => {
     const { sessionID } = input;
     try {
@@ -15256,7 +14389,7 @@ function createCompactingHandler(args) {
       }
       let rawMessages;
       try {
-        const raw = await readFile2(capture.rawFilePath, "utf-8");
+        const raw = await readFile(capture.rawFilePath, "utf-8");
         const parsed = JSON.parse(raw);
         rawMessages = parsed.messages;
       } catch (readErr) {
@@ -15285,7 +14418,30 @@ function createCompactingHandler(args) {
         content: markdown,
         logger
       });
-      state.setPendingEnrichment(sessionID);
+      try {
+        const memPath = memoryFilePath("project", "memory", projectPath);
+        if (existsSync3(memPath)) {
+          const release = await acquireLock(memPath);
+          try {
+            const content = await readFile(memPath, "utf8");
+            const consolidated = consolidateMemory(content);
+            if (consolidated !== content) {
+              await writeFile3(memPath, consolidated, "utf8");
+              logger?.info("compacting: consolidated MEMORY.md", {
+                beforeBytes: content.length,
+                afterBytes: consolidated.length,
+                diff: content.length - consolidated.length
+              });
+            }
+          } finally {
+            release();
+          }
+        }
+      } catch (err) {
+        logger?.warn("compacting: consolidate failed (non-fatal)", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
       if (capture.messageCount >= 20) {
         output.prompt = STRUCTURED_COMPACTION_PROMPT;
       }
@@ -15396,390 +14552,50 @@ function detectPressure(messages, modelContextWindow) {
   return { level, ratio, estimatedTokens: estimated, maxContext: ctx };
 }
 
-// src/compress/nudge.ts
-var NUDGE_COOLDOWN = 3;
-function shouldInjectNudge(level, messagesSinceLastNudge) {
-  if (level !== "high") return false;
-  if (messagesSinceLastNudge < NUDGE_COOLDOWN) return false;
-  return true;
-}
-function buildNudgeText(level) {
-  if (level === "high") {
-    return '\n<dm-nudge level="high">Context pressure is high. Consider summarizing old completed tasks and moving on. Use memory_store to persist important findings before they are compressed.</dm-nudge>';
-  }
-  return "";
-}
-
-// src/compress/memory-nudge.ts
-var MEMORY_NUDGE_COOLDOWN = 3;
-var DECISION_PATTERNS = [
-  /\b(?:decided|decision|chose|chosen|picked|selected)\b/i,
-  /(?:采用|选择|决定|确定|选用)/,
-  /\b(?:use|using|go with|went with)\b.*\b(?:because|since|due to)\b/i
-];
-var CONSTRAINT_PATTERNS = [
-  /\b(?:must not|cannot|should not|do not|never|always)\b/i,
-  /\b(?:constraint|restriction|limitation|requirement)\b/i,
-  /(?:不能|必须|禁止|约束|限制|要求|务必)/
-];
-var ERROR_FIX_PATTERNS = [
-  /\b(?:fix|fixed|resolve|resolved|patch|corrected)\b/i,
-  /(?:修复|修复了|解决|解决了)/,
-  /\b(?:the (?:bug|error|issue) (?:was|is)|root cause)\b/i
-];
-function detectMemoryNudge(messages, messagesSinceLastNudge) {
-  if (messagesSinceLastNudge < MEMORY_NUDGE_COOLDOWN) {
-    return { injected: false, type: null };
-  }
-  const protectedTail = Math.max(0, messages.length - 3);
-  const recentMessages = messages.slice(protectedTail);
-  const recentAssistantText = recentMessages.filter((m) => m.info.role === "assistant").flatMap((m) => m.parts.filter((p) => p.type === "text").map((p) => p.text || "")).join("\n");
-  const recentUserText = recentMessages.filter((m) => m.info.role === "user").flatMap((m) => m.parts.filter((p) => p.type === "text").map((p) => p.text || "")).join("\n");
-  const hasRecentToolError = recentMessages.some(
-    (m) => m.parts.some((p) => p.type === "tool" && p.state?.status === "error")
-  );
-  const recentAll = recentUserText + "\n" + recentAssistantText;
-  if (hasRecentToolError && ERROR_FIX_PATTERNS.some((p) => p.test(recentAssistantText))) {
-    return { injected: true, type: "gotcha" };
-  }
-  if (CONSTRAINT_PATTERNS.some((p) => p.test(recentAll))) {
-    return { injected: true, type: "constraint" };
-  }
-  if (DECISION_PATTERNS.some((p) => p.test(recentAll))) {
-    return { injected: true, type: "decision" };
-  }
-  return { injected: false, type: null };
-}
-function buildMemoryNudge(type) {
-  switch (type) {
-    case "gotcha":
-      return `
-<memory-nudge type="gotcha">You just fixed an error. Use memory_store(type="gotcha") to save what went wrong and how you fixed it, so future sessions don't repeat this mistake.</memory-nudge>`;
-    case "constraint":
-      return '\n<memory-nudge type="constraint">The user expressed a constraint or rule. Use memory_store(type="constraint") to persist it across sessions.</memory-nudge>';
-    case "decision":
-      return `
-<memory-nudge type="decision">A technical decision was made. Use memory_store(type="decision") to record what was decided and why, so future sessions don't re-decide.</memory-nudge>`;
-    default:
-      return "";
-  }
-}
-
-// src/compress/dedup.ts
-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}`;
-}
-
-// 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) => /^\s*(\d{4}-\d{2}-\d{2}|\[\d{4}|ERROR\b|WARN\b|INFO\b|DEBUG\b|FATAL\b|TRACE\b)/.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/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,
-  background_output: compressAgentOutput,
-  task: compressAgentOutput,
-  skill: compressSkillOutput,
-  session_read: compressAgentOutput,
-  webfetch: compressAgentOutput
+// src/compress/capture-cap.ts
+var DEFAULT_CAPS = {
+  bash: 48e3,
+  read: 5e4,
+  grep: 1e4,
+  glob: 1e4,
+  task: 3e4,
+  background_output: 3e4,
+  webfetch: 2e4,
+  generic: 4e4
 };
-var DEFAULT_HEAD_LINES = 50;
-var DEFAULT_TAIL_LINES = 20;
-var MAX_LINE_LENGTH = 500;
-function compressToolOutput(toolName, output) {
-  if (!output || output.length < 200) 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 && output.length <= 5e3) return output;
-  if (lines.length <= 50) {
-    if (detectContentType(output) === "json") {
-      return compressJsonOutput(output);
-    }
-    return lines.map((l) => l.length > MAX_LINE_LENGTH ? l.slice(0, MAX_LINE_LENGTH) + "..." : l).join("\n");
-  }
-  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]";
-}
-function compressJsonOutput(output) {
-  try {
-    const parsed = JSON.parse(output);
-    if (Array.isArray(parsed)) {
-      return compressJsonArray(parsed);
-    }
-    if (typeof parsed === "object" && parsed !== null) {
-      return compressJsonObject(parsed);
-    }
-    return output;
-  } catch {
-    return output;
-  }
-}
-function compressJsonArray(arr) {
-  const head = 30;
-  const tail = 15;
-  const maxItems = 50;
-  if (arr.length <= maxItems) return JSON.stringify(arr, null, 2);
-  const kept = [...arr.slice(0, head), { _truncated: true, total: arr.length }, ...arr.slice(-tail)];
-  return JSON.stringify(kept, null, 2);
-}
-function compressJsonObject(obj) {
-  const MAX_CHILD_ITEMS = 30;
-  let modified = false;
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (Array.isArray(value) && value.length > MAX_CHILD_ITEMS) {
-      result[key] = {
-        _truncated: true,
-        total: value.length,
-        items: [...value.slice(0, 10), toStringPlaceholder(value.slice(10, 20)), ...value.slice(-10)]
-      };
-      modified = true;
-    } else {
-      result[key] = value;
-    }
-  }
-  if (modified) {
-    return JSON.stringify(result, null, 2);
-  }
-  return JSON.stringify(obj, null, 2);
-}
-function toStringPlaceholder(items) {
-  return { _skipped: items.length };
-}
-function compressAgentOutput(output) {
-  if (detectContentType(output) === "json") {
-    return compressJsonOutput(output);
-  }
-  const lines = output.split("\n");
-  if (lines.length <= 40 && output.length <= 3e3) return output;
-  const MAX_SECTION_LINES = 5;
-  const result = [];
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (line.includes("[ccr:") || line.includes("[superseded")) {
-      result.push(line);
-      continue;
-    }
-    const isHeader = /^#{1,4}\s/.test(line) || /^---/.test(line) || /^\*\*$/.test(line);
-    const hasCode = line.includes("```");
-    const hasKey = /\b(error|fail|success|completed|result|summary|warning)\b/i.test(line);
-    if (isHeader || hasCode || hasKey) {
-      result.push(truncateLine(line, 300));
-      continue;
-    }
-    if (i < 5 || i >= lines.length - 10) {
-      result.push(truncateLine(line, 300));
-      continue;
-    }
-    const inSection = result.length > 0 && result[result.length - 1] !== "";
-    if (!inSection) {
-      if (line.trim()) {
-        result.push(line);
-      }
-    } else {
-      const recentLines = result.slice(-MAX_SECTION_LINES).filter((l) => l.trim() && l !== "...");
-      if (recentLines.length >= MAX_SECTION_LINES) {
-        result.push("...[truncated]");
-        while (i < lines.length && !/^#{1,4}\s/.test(lines[i]) && !lines[i].includes("```") && !/\b(error|fail|summary)\b/i.test(lines[i])) {
-          i++;
-        }
-        i--;
-      } else {
-        result.push(truncateLine(line, 300));
-      }
-    }
-  }
-  return result.join("\n");
-}
-function compressSkillOutput(output) {
-  const lines = output.split("\n");
-  if (lines.length <= 60 && output.length <= 4e3) return output;
-  const result = [];
-  const FRONTMATTER_END = lines.findIndex((l, i) => i > 0 && l.trim() === "---");
-  for (let i = 0; i < lines.length; i++) {
-    if (i <= FRONTMATTER_END || i < 10) {
-      result.push(lines[i]);
-      continue;
-    }
-    if (i >= lines.length - 10) {
-      result.push(lines[i]);
-      continue;
-    }
-    const line = lines[i];
-    if (/^#{1,4}\s/.test(line) || /^```/.test(line) || /^---/.test(line)) {
-      result.push(line);
-      continue;
-    }
-    if (/\b(must|must not|required|forbidden|never|always)\b/i.test(line)) {
-      result.push(line);
-      continue;
-    }
-    const recentNonEmpty = result.slice(-8).filter((l) => l.trim());
-    if (recentNonEmpty.length >= 8 && !result[result.length - 1].startsWith("...")) {
-      result.push("...[truncated]");
-      while (i < lines.length && !/^#{1,4}\s/.test(lines[i]) && !/^```/.test(lines[i])) {
-        i++;
-      }
-      i--;
-    } else {
-      result.push(line);
-    }
-  }
-  if (result.length < lines.length * 0.7) {
-    return result.join("\n");
-  }
-  return output;
-}
-
-// 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 truncateMiddle(content, maxChars, hint) {
+  if (content.length <= maxChars) return content;
+  const headLen = Math.floor(maxChars * 0.45);
+  const tailLen = Math.floor(maxChars * 0.4);
+  const head = content.slice(0, headLen);
+  const tail = content.slice(content.length - tailLen);
+  return `${head}
+
+[... truncated \u2014 ${hint} ...]
+
+${tail}`;
+}
+function hintFor(tool6) {
+  switch (tool6) {
+    case "bash":
+      return "use grep or read with offset for specifics";
+    case "read":
+      return "re-read with offset parameter for the omitted section";
+    case "grep":
+    case "search":
+      return "narrow your search pattern for fewer results";
+    case "webfetch":
+      return "the full page was larger than the cap";
+    default:
+      return "output was capped at capture time";
   }
 }
-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;
-    }
+function capToolOutput(content, tool6, opts) {
+  const limit = opts?.cap ?? DEFAULT_CAPS[tool6] ?? DEFAULT_CAPS.generic;
+  if (content.length <= limit) {
+    return { output: content, capped: false };
   }
-  return unique;
-}
-function sha2562(data) {
-  return createHash3("sha256").update(data).digest("hex");
+  return { output: truncateMiddle(content, limit, hintFor(tool6)), capped: true };
 }
 
 // src/compress/single-pass.ts
@@ -15875,47 +14691,33 @@ function singlePassCompress(messages, state, protectedTail) {
       if (toolState?.["status"] !== "completed") continue;
       const output = typeof toolState?.["output"] === "string" ? toolState["output"] : void 0;
       if (!output) continue;
-      if (output === "[superseded by duplicate call]") continue;
-      if (output.includes("[ccr:")) continue;
+      if (output === "[OUTDATED \u2014 superseded by duplicate call]") continue;
+      if (output.includes("deep_expand(")) continue;
       if (!PROTECTED_TOOLS.has(toolName) && !NEVER_DEDUP.has(toolName)) {
         const input = toolState["input"];
-        const signature = createToolSignature(toolName, input);
+        const signature = `${toolName}:${JSON.stringify(input ?? {})}`;
         const outputHash = simpleHash(output);
         const existing = seen.get(signature);
-        if (existing) {
-          if (existing.outputHash === outputHash) {
-            const prevMsg = messages[existing.msgIdx];
-            for (const prevPart of prevMsg.parts) {
-              if (typeof prevPart !== "object" || prevPart === null) continue;
-              const pp = prevPart;
-              const ppState = pp["state"];
-              if (ppState?.["output"] === "[superseded by duplicate call]") continue;
-              if (typeof ppState?.["output"] === "string" && simpleHash(ppState["output"]) === outputHash) {
-                ppState["output"] = "[superseded by duplicate call]";
-                stats.toolDedup++;
-              }
+        if (existing && existing.outputHash === outputHash) {
+          const prevMsg = messages[existing.msgIdx];
+          for (const prevPart of prevMsg.parts) {
+            if (typeof prevPart !== "object" || prevPart === null) continue;
+            const pp = prevPart;
+            const ppState = pp["state"];
+            if (typeof ppState?.["output"] === "string" && !ppState["output"].includes("[OUTDATED") && simpleHash(ppState["output"]) === outputHash) {
+              ppState["output"] = "[OUTDATED \u2014 superseded by newer identical call]";
+              stats.toolDedup++;
             }
           }
-          seen.set(signature, { msgIdx: i, outputHash });
-        } else {
-          seen.set(signature, { msgIdx: i, outputHash });
         }
+        seen.set(signature, { msgIdx: i, outputHash });
       }
       if (output.length >= 200 && !PROTECTED_TOOLS.has(toolName)) {
-        const result = compressToolOutput(toolName, output);
-        if (result.length < output.length * 0.85) {
-          const hash2 = ccrStore(state, output, result, toolName, callID);
-          toolState["output"] = ccrInjectMarker(result, hash2);
+        const capResult = capToolOutput(output, toolName);
+        if (capResult.capped) {
+          const hash2 = ccrStore(state, output, capResult.output, toolName, callID);
+          toolState["output"] = ccrInjectMarker(capResult.output, hash2);
           stats.toolOutputCompressed++;
-          continue;
-        }
-      }
-      if (output.length >= 200 && detectContentType(output) === "json" && !PROTECTED_TOOLS.has(toolName)) {
-        const crushed = crushJsonArray(output);
-        if (crushed.length < output.length * 0.85) {
-          const hash2 = ccrStore(state, output, crushed, toolName, callID);
-          toolState["output"] = ccrInjectMarker(crushed, hash2);
-          stats.jsonCrushed++;
         }
       }
     }
@@ -15965,7 +14767,7 @@ function computeProtectedTail(messages) {
   return 0;
 }
 function runCompressionPipeline(ctx) {
-  const { messages, state, sessionID, logger } = ctx;
+  const { messages, state, logger } = ctx;
   const pressure = detectPressure(messages, state.getModelContextWindow());
   state.recordInputTokens(pressure.estimatedTokens);
   const protectedTail = computeProtectedTail(messages);
@@ -15974,31 +14776,14 @@ function runCompressionPipeline(ctx) {
     toolDedup: spStats.toolDedup,
     errorPurge: spStats.errorPurge,
     toolOutputCompressed: spStats.toolOutputCompressed,
-    jsonCrushed: spStats.jsonCrushed,
+    jsonCrushed: 0,
     assistantCompressed: spStats.assistantCompressed,
     ccrStored: spStats.ccrStored,
     nudgeInjected: false,
     pressureLevel: pressure.level,
     estimatedTokens: pressure.estimatedTokens
   };
-  const sid = sessionID || "default";
-  const currentMsgCount = messages.length;
-  const pressureSince = state.messagesSinceLastNudge(sid, currentMsgCount);
-  if (shouldInjectNudge(pressure.level, pressureSince)) {
-    if (injectIntoLastAssistant(messages, buildNudgeText(pressure.level))) {
-      stats.nudgeInjected = true;
-      state.recordNudge(sid, currentMsgCount);
-    }
-  }
-  const memorySince = state.messagesSinceLastMemoryNudge(sid, currentMsgCount);
-  const memoryNudge = detectMemoryNudge(messages, memorySince);
-  if (memoryNudge.injected) {
-    if (injectIntoLastAssistant(messages, buildMemoryNudge(memoryNudge.type))) {
-      state.recordMemoryNudge(sid, currentMsgCount);
-      logger?.debug("compress: memory nudge", { type: memoryNudge.type });
-    }
-  }
-  const active = stats.toolDedup > 0 || stats.errorPurge > 0 || stats.toolOutputCompressed > 0 || stats.jsonCrushed > 0 || stats.assistantCompressed > 0 || stats.nudgeInjected;
+  const active = stats.toolDedup > 0 || stats.errorPurge > 0 || stats.toolOutputCompressed > 0 || stats.assistantCompressed > 0;
   if (active) {
     logger?.debug("compress: pipeline result", { ...stats });
   } else {
@@ -16006,20 +14791,6 @@ function runCompressionPipeline(ctx) {
   }
   return { stats };
 }
-function injectIntoLastAssistant(messages, text) {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.info.role !== "assistant") continue;
-    for (let j = msg.parts.length - 1; j >= 0; j--) {
-      const p = msg.parts[j];
-      if (p["type"] === "text" && typeof p["text"] === "string") {
-        p["text"] += text;
-        return true;
-      }
-    }
-  }
-  return false;
-}
 
 // src/hooks/messages-transform.ts
 var KEEP_RECENT = 8;
@@ -16068,44 +14839,6 @@ function isSystemInjected(msg) {
   }
   return hasText && allInjected;
 }
-function repairOrphanedToolCalls(messages) {
-  const toolUseIds = /* @__PURE__ */ new Set();
-  for (const msg of messages) {
-    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"] === "tool_use" && typeof p["id"] === "string") {
-        toolUseIds.add(p["id"]);
-      }
-    }
-  }
-  if (toolUseIds.size === 0) return;
-  const toolResultIds = /* @__PURE__ */ new Set();
-  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_result" && typeof p["tool_use_id"] === "string") {
-        toolResultIds.add(p["tool_use_id"]);
-      }
-    }
-  }
-  for (const msg of messages) {
-    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"] === "tool_use" && typeof p["id"] === "string") {
-        if (!toolResultIds.has(p["id"])) {
-          p["type"] = "tool";
-          p["state"] = { status: "ok" };
-          p["text"] = "[context-stripped]";
-        }
-      }
-    }
-  }
-}
 function createMessagesTransformHandler(state, logger) {
   return async (input, output) => {
     const messages = output.messages;
@@ -16177,10 +14910,38 @@ function createMessagesTransformHandler(state, logger) {
     for (let r = toRemove.length - 1; r >= 0; r--) {
       messages.splice(toRemove[r], 1);
     }
-    repairOrphanedToolCalls(messages);
     if (Object.values(stats).some((v) => v > 0)) {
       logger?.debug("messages.transform: stripped", stats);
     }
+    const compressReq = state.consumeCompressionRequest();
+    if (compressReq) {
+      const cutoff = messages.length - compressReq.keepRecent;
+      let agentCompressed = 0;
+      for (let i = 2; i < cutoff; i++) {
+        const msg = messages[i];
+        if (!msg?.parts?.length) continue;
+        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"];
+          const output2 = typeof toolState?.["output"] === "string" ? toolState["output"] : "";
+          if (output2.length < 500 || output2.includes("deep_expand(")) continue;
+          const lines = output2.split("\n");
+          if (lines.length < 20) continue;
+          const summary = lines.slice(0, 3).join("\n") + `
+[... ${lines.length - 6} lines compressed \u2014 call deep_expand to restore ...]
+` + lines.slice(-3).join("\n");
+          const { ccrStore: ccrStore2, ccrInjectMarker: ccrInjectMarker2 } = await import("./ccr-REOCHH53.js");
+          const hash2 = ccrStore2(state, output2, summary, "context_compress");
+          toolState["output"] = ccrInjectMarker2(summary, hash2);
+          agentCompressed++;
+        }
+      }
+      if (agentCompressed > 0) {
+        logger?.debug("messages.transform: agent-initiated compression", { agentCompressed });
+      }
+    }
     const pipelineResult = runCompressionPipeline({
       messages: output.messages,
       state,
@@ -16188,7 +14949,7 @@ function createMessagesTransformHandler(state, logger) {
       logger
     });
     const ds = pipelineResult.stats;
-    if (ds.toolDedup > 0 || ds.errorPurge > 0 || ds.toolOutputCompressed > 0 || ds.jsonCrushed > 0 || ds.assistantCompressed > 0 || ds.nudgeInjected) {
+    if (ds.toolDedup > 0 || ds.errorPurge > 0 || ds.toolOutputCompressed > 0 || ds.assistantCompressed > 0) {
       logger?.debug("messages.transform: deep compression", { ...ds });
       state.mergeNotify({
         compression: stats,
@@ -16197,23 +14958,6 @@ function createMessagesTransformHandler(state, logger) {
         protectedHead: PROTECTED_HEAD,
         protectedTail: KEEP_RECENT
       });
-      const recentEdits = state.getRecentEdits();
-      if (recentEdits.length > 0) {
-        const fileList = recentEdits.slice(0, 5).join(", ");
-        const nudge = '\n\n<dm-nudge level="medium">Context was compressed. Recent files may have shifted: ' + fileList + ". Use `read` to re-verify if needed.</dm-nudge>";
-        for (let k = output.messages.length - 1; k >= 0; k--) {
-          const msg = output.messages[k];
-          if (msg.info.role !== "assistant") continue;
-          for (const part of msg.parts) {
-            const p = part;
-            if (p["type"] === "text" && typeof p["text"] === "string") {
-              p.text += nudge;
-              break;
-            }
-          }
-          break;
-        }
-      }
     } else if (Object.values(stats).some((v) => v > 0)) {
       state.mergeNotify({
         compression: stats,
@@ -16345,101 +15089,6 @@ function createNotifyHandler(client, logger) {
   };
 }
 
-// src/extract/enrich.ts
-import { stat } from "fs/promises";
-
-// src/extract/enrich-prompt.ts
-var ENRICH_PROMPT_TEMPLATE = `You are a checkpoint enrichment agent. The compacting hook already wrote a checkpoint.md with instant heuristic extraction. Your job is to cross-reference it with the raw message dump to produce a richer checkpoint.
-
-Files to read:
-- Checkpoint: {{checkpointPath}}
-- Raw messages: {{rawPath}}
-- Project path: {{projectPath}}
-
-Steps:
-1. Read the current checkpoint.md \u2014 note its structure and contents.
-2. Read the raw messages JSON \u2014 these are the original conversation messages before compaction.
-3. Cross-reference:
-   a. Find related decisions that were made across multiple messages (consolidate fragments)
-   b. Identify constraints that were implicitly assumed but never explicitly stated
-   c. Link error messages to their fixes more precisely (the heuristic might have missed some)
-   d. Identify file changes that are part of larger refactoring patterns
-4. Update the checkpoint.md using memory_store or write tool \u2014 keep the same section structure but:
-   - Add cross-reference notes where relevant (e.g., "See also: [related decision]")
-   - Refine gotchas into more actionable descriptions
-   - Add a "## Synthesis" section summarizing the conversation's main themes (2-5 bullets)
-
-Quality target: the checkpoint should contain everything a restart session needs to continue the work without re-reading the original conversation. Be selective \u2014 only add value, don't pad.
-`;
-
-// src/extract/enrich.ts
-var MAX_RAW_AGE_MS = 10 * 60 * 1e3;
-async function runEnrichment(opts) {
-  const { client, projectPath, sessionID, logger } = opts;
-  const emptyResult = { sessionID: "", status: "skipped" };
-  const rawPath = checkpointRawPath(projectPath, sessionID);
-  let rawStat;
-  try {
-    rawStat = await stat(rawPath);
-  } catch {
-    logger?.debug("enrichment: checkpoint.raw.json missing, skipping", { sessionID, rawPath });
-    return emptyResult;
-  }
-  const rawAge = Date.now() - rawStat.mtimeMs;
-  if (rawAge > MAX_RAW_AGE_MS) {
-    logger?.debug("enrichment: checkpoint.raw.json is stale, skipping", {
-      sessionID,
-      rawPath,
-      ageMinutes: Math.round(rawAge / 6e4)
-    });
-    return emptyResult;
-  }
-  const checkpointPath = memoryFilePath("project", "checkpoint", projectPath);
-  try {
-    await stat(checkpointPath);
-  } catch {
-    logger?.debug("enrichment: checkpoint.md missing, skipping", { sessionID, checkpointPath });
-    return emptyResult;
-  }
-  try {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const title = `Memory Checkpoint Enrichment ${now}`;
-    const resp = await client.session.create({
-      body: { title }
-    });
-    const enrichSessionID = resp.data?.id;
-    if (!enrichSessionID) {
-      logger?.warn("enrichment: session.create returned no ID", { sessionID });
-      return { sessionID: "", status: "failed" };
-    }
-    const prompt = ENRICH_PROMPT_TEMPLATE.replaceAll("{{checkpointPath}}", checkpointPath).replaceAll("{{rawPath}}", rawPath).replaceAll("{{projectPath}}", projectPath).replaceAll("{{ISO timestamp}}", now);
-    await client.session.promptAsync({
-      path: { id: enrichSessionID },
-      body: {
-        parts: [{ type: "text", text: prompt }],
-        agent: "sisyphus",
-        tools: {
-          memory_search: true,
-          memory_store: true,
-          read: true,
-          list: true
-        }
-      }
-    });
-    logger?.info("enrichment: spawned background session", {
-      sessionID,
-      enrichSessionID
-    });
-    return { sessionID: enrichSessionID, status: "spawned" };
-  } catch (err) {
-    logger?.warn("enrichment: failed to spawn background session", {
-      sessionID,
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return { sessionID: "", status: "failed" };
-  }
-}
-
 // src/repomap/extractor.ts
 var EXT_TO_LANG = {
   ".ts": "typescript",
@@ -16589,18 +15238,18 @@ function recencyDecay(lastRead) {
 }
 var RepoMapTracker = class {
   files = /* @__PURE__ */ new Map();
-  recordRead(path12, content) {
-    const lang = getLanguage(path12);
+  recordRead(path9, content) {
+    const lang = getLanguage(path9);
     if (!lang) return;
-    const symbols = extractSymbols(path12, content);
-    const existing = this.files.get(path12);
+    const symbols = extractSymbols(path9, content);
+    const existing = this.files.get(path9);
     if (existing) {
       existing.symbols = symbols;
       existing.readCount += 1;
       existing.lastRead = Date.now();
     } else {
-      this.files.set(path12, {
-        path: path12,
+      this.files.set(path9, {
+        path: path9,
         symbols,
         readCount: 1,
         lastRead: Date.now(),
@@ -16665,6 +15314,13 @@ var deepMemoryPlugin = async (input) => {
     dataRoot,
     serverUrl: input.serverUrl.toString()
   });
+  try {
+    await migrateV3toV4(projectPath, logger.for("migrate"));
+  } catch (err) {
+    logger.warn("V3\u2192V4 migration failed (non-blocking)", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
   const searchService = new SearchService({
     dataRoot,
     projectPath,
@@ -16696,82 +15352,26 @@ var deepMemoryPlugin = async (input) => {
       error: err instanceof Error ? err.message : String(err)
     });
   });
-  const memoryTools = createMemoryTools(searchService, { projectPath });
+  const memoryTools = createMemoryTools(searchService, state, { projectPath });
   const notify = createNotifyHandler(input.client, logger.for("notify"));
   const hooks = {
     "chat.params": createChatParamsHandler(
       state,
       logger.for("chat-params")
     ),
-    "chat.message": createChatMessageHandler({
-      projectPath,
-      state,
-      logger: logger.for("chat-message")
-    }),
     "experimental.chat.system.transform": createSystemTransformHandler(
       state,
       projectPath,
       searchService,
-      logger.for("system-transform"),
-      tracker
+      logger.for("system-transform")
     ),
     event: async ({ event }) => {
       try {
         if (event.type === "session.created") {
-          const info = event.properties.info;
-          if (!info || typeof info !== "object") {
-            logger.debug("event session.created: missing info, skipping");
-            return;
-          }
-          const i = info;
-          if (typeof i.id !== "string") {
-            logger.debug("event session.created: info.id not string, skipping");
-            return;
-          }
-          const narrowed = {
-            type: "session.created",
-            properties: {
-              info: {
-                id: i.id,
-                parentID: typeof i.parentID === "string" ? i.parentID : void 0,
-                title: typeof i.title === "string" ? i.title : "",
-                directory: typeof i.directory === "string" ? i.directory : projectPath
-              }
-            }
-          };
-          await Promise.allSettled([
-            handleSessionCreated({ state, event: narrowed, projectPath, logger: logger.for("resume") }),
-            handleSessionCreatedForDream({
-              event: narrowed,
-              config: { client: input.client, projectPath, model: state.bestModel(), logger: logger.for("auto-dream") }
-            }),
-            handleSessionCreatedForDistill({
-              event: narrowed,
-              config: { client: input.client, projectPath, model: state.bestModel(), logger: logger.for("auto-distill") }
-            })
-          ]);
           return;
         }
         if (event.type === "session.idle") {
           const idleSessionID = event.properties.sessionID;
-          if (idleSessionID && state.hasPendingEnrichment(idleSessionID)) {
-            state.consumePendingEnrichment(idleSessionID);
-            try {
-              const result = await runEnrichment({
-                client: input.client,
-                projectPath,
-                sessionID: idleSessionID,
-                logger: logger.for("enrichment")
-              });
-              logger.info("idle enrichment result", { ...result });
-            } catch (err) {
-              logger.warn("idle enrichment failed", {
-                error: err instanceof Error ? err.message : String(err)
-              });
-            }
-          } else {
-            logger.debug("event session.idle (no pending enrichment)");
-          }
           if (idleSessionID) {
             const pending = state.consumePendingNotify();
             if (pending) {
@@ -16800,8 +15400,8 @@ var deepMemoryPlugin = async (input) => {
           }
           try {
             const auditLogDir = projectMemoryDir(projectPath);
-            await mkdir4(auditLogDir, { recursive: true });
-            const auditLogPath = path11.join(auditLogDir, ".compaction-log.jsonl");
+            await mkdir3(auditLogDir, { recursive: true });
+            const auditLogPath = path8.join(auditLogDir, ".compaction-log.jsonl");
             const line = JSON.stringify({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), sessionID: compactedSessionID }) + "\n";
             const releaseLock = await acquireLock(auditLogPath);
             try {