musememory 1.7.0 → 1.8.0

package/dist/index.js

@@ -4,6 +4,7 @@ var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 function __accessProp(key) {
   return this[key];
@@ -32,6 +33,23 @@ var __toESM = (mod, isNodeMode, target) => {
     cache.set(mod, to);
   return to;
 };
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -3511,9 +3529,256 @@ var init_types = __esm(() => {
   };
 });
 
+// src/graph.ts
+var exports_graph = {};
+__export(exports_graph, {
+  autoStampGraphMetadata: () => autoStampGraphMetadata,
+  detectGraphProvider: () => detectGraphProvider,
+  detectProvider: () => detectProvider,
+  extractReferencedSymbols: () => extractReferencedSymbols,
+  getGraphStatus: () => getGraphStatus,
+  getRuntimeTrustVerdict: () => getRuntimeTrustVerdict,
+  graphSymbolsPath: () => graphSymbolsPath,
+  indexGraph: () => indexGraph,
+  loadGraphSymbolIndex: () => loadGraphSymbolIndex,
+  verifyRuntimeFiles: () => verifyRuntimeFiles
+});
+import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "node:fs";
+import { join as join4, isAbsolute } from "node:path";
+function detectProvider(projectRoot) {
+  if (!projectRoot || !existsSync4(projectRoot))
+    return "none";
+  if (existsSync4(join4(projectRoot, ".codegraph"))) {
+    return "codegraph";
+  }
+  if (existsSync4(join4(projectRoot, ".graphify"))) {
+    return "graphify";
+  }
+  return "none";
+}
+function getGraphStatus(projectRoot) {
+  const provider = detectProvider(projectRoot);
+  if (provider === "codegraph") {
+    const codegraphDir = join4(projectRoot, ".codegraph");
+    let symbolCount;
+    let graphRevision;
+    try {
+      if (existsSync4(codegraphDir)) {
+        const files = readdirSync(codegraphDir);
+        symbolCount = files.length;
+        const metaPath = join4(codegraphDir, "meta.json");
+        if (existsSync4(metaPath)) {
+          const meta = JSON.parse(readFileSync4(metaPath, "utf8"));
+          graphRevision = meta.revision ?? meta.commit ?? meta.version;
+        }
+      }
+    } catch {}
+    return {
+      provider: "codegraph",
+      available: true,
+      root: codegraphDir,
+      graphRevision,
+      symbolCount
+    };
+  }
+  if (provider === "graphify") {
+    const graphifyDir = join4(projectRoot, ".graphify");
+    let symbolCount;
+    let graphRevision;
+    try {
+      if (existsSync4(graphifyDir)) {
+        const files = readdirSync(graphifyDir);
+        symbolCount = files.length;
+        const metaPath = join4(graphifyDir, "meta.json");
+        if (existsSync4(metaPath)) {
+          const meta = JSON.parse(readFileSync4(metaPath, "utf8"));
+          graphRevision = meta.revision ?? meta.commit ?? meta.version;
+        }
+      }
+    } catch {}
+    return {
+      provider: "graphify",
+      available: true,
+      root: graphifyDir,
+      graphRevision,
+      symbolCount
+    };
+  }
+  return {
+    provider: "none",
+    available: false,
+    root: projectRoot
+  };
+}
+function graphSymbolsPath(memoryDir) {
+  return join4(memoryDir, "graph-symbols.json");
+}
+function indexGraph(projectRoot, memoryDir) {
+  const status = getGraphStatus(projectRoot);
+  const symbols = {};
+  if (status.provider === "codegraph") {
+    const codegraphDir = join4(projectRoot, ".codegraph");
+    try {
+      const candidates = [
+        join4(codegraphDir, "symbols.json"),
+        join4(codegraphDir, "index.json"),
+        join4(codegraphDir, "graph.json")
+      ];
+      for (const c of candidates) {
+        if (existsSync4(c)) {
+          const data = JSON.parse(readFileSync4(c, "utf8"));
+          if (Array.isArray(data)) {
+            for (const item of data) {
+              if (item.name && item.path) {
+                symbols[String(item.name)] = String(item.path);
+              }
+            }
+          } else if (typeof data === "object" && data !== null) {
+            if (data.symbols && typeof data.symbols === "object") {
+              for (const [k, v] of Object.entries(data.symbols)) {
+                symbols[k] = typeof v === "string" ? v : v?.path || "";
+              }
+            } else {
+              for (const [k, v] of Object.entries(data)) {
+                if (typeof v === "string")
+                  symbols[k] = v;
+              }
+            }
+          }
+        }
+      }
+      if (Object.keys(symbols).length === 0 && existsSync4(codegraphDir)) {
+        const files = readdirSync(codegraphDir);
+        for (const file of files) {
+          if (file.endsWith(".json") && file !== "meta.json") {
+            try {
+              const content = JSON.parse(readFileSync4(join4(codegraphDir, file), "utf8"));
+              if (content.name && content.path) {
+                symbols[String(content.name)] = String(content.path);
+              } else if (content.symbols && Array.isArray(content.symbols)) {
+                for (const s of content.symbols) {
+                  if (s.name && (s.path || content.path)) {
+                    symbols[String(s.name)] = String(s.path || content.path);
+                  }
+                }
+              }
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+  } else if (status.provider === "graphify") {
+    const graphifyDir = join4(projectRoot, ".graphify");
+    try {
+      const candidates = [
+        join4(graphifyDir, "graph.json"),
+        join4(graphifyDir, "symbols.json")
+      ];
+      for (const c of candidates) {
+        if (existsSync4(c)) {
+          const data = JSON.parse(readFileSync4(c, "utf8"));
+          if (data.nodes && Array.isArray(data.nodes)) {
+            for (const node of data.nodes) {
+              if (node.name && node.path) {
+                symbols[String(node.name)] = String(node.path);
+              }
+            }
+          }
+        }
+      }
+    } catch {}
+  }
+  const index = {
+    provider: status.provider,
+    indexedAt: new Date().toISOString(),
+    symbolCount: Object.keys(symbols).length,
+    symbols
+  };
+  try {
+    mkdirSync4(memoryDir, { recursive: true });
+    writeFileSync3(graphSymbolsPath(memoryDir), JSON.stringify(index, null, 2), "utf8");
+  } catch {}
+  return index;
+}
+function loadGraphSymbolIndex(memoryDir) {
+  const p = graphSymbolsPath(memoryDir);
+  if (!existsSync4(p))
+    return null;
+  try {
+    const raw = readFileSync4(p, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function extractReferencedSymbols(text, memoryDir) {
+  const index = loadGraphSymbolIndex(memoryDir);
+  if (!index || index.symbolCount === 0) {
+    return { symbol_names: [], affected_paths: [], provider: "none" };
+  }
+  const matchedSymbols = new Set;
+  const affectedPaths = new Set;
+  const words = text.match(/[a-zA-Z_$][a-zA-Z0-9_$]*/g) || [];
+  const wordSet = new Set(words);
+  for (const [symbol, path] of Object.entries(index.symbols)) {
+    if (wordSet.has(symbol)) {
+      matchedSymbols.add(symbol);
+      if (path)
+        affectedPaths.add(path);
+    }
+  }
+  return {
+    symbol_names: Array.from(matchedSymbols),
+    affected_paths: Array.from(affectedPaths),
+    provider: index.provider
+  };
+}
+function autoStampGraphMetadata(text, memoryDir) {
+  const extracted = extractReferencedSymbols(text, memoryDir);
+  if (extracted.symbol_names.length === 0)
+    return;
+  return {
+    provider: extracted.provider,
+    symbol_names: extracted.symbol_names,
+    affected_paths: extracted.affected_paths,
+    graph_verified_at: new Date().toISOString()
+  };
+}
+function verifyRuntimeFiles(entry, workspaceRoot) {
+  const root = workspaceRoot || process.cwd();
+  const affected = entry.graph?.affected_paths || [];
+  if (affected.length === 0) {
+    return { verdict: "STRONG", existingPaths: [], missingPaths: [] };
+  }
+  const existingPaths = [];
+  const missingPaths = [];
+  for (const relPath of affected) {
+    const fullPath = isAbsolute(relPath) ? relPath : join4(root, relPath);
+    if (existsSync4(fullPath)) {
+      existingPaths.push(relPath);
+    } else {
+      missingPaths.push(relPath);
+    }
+  }
+  if (missingPaths.length > 0 && existingPaths.length === 0) {
+    return { verdict: "STALE", existingPaths, missingPaths, details: `Missing: ${missingPaths.join(", ")}` };
+  }
+  if (missingPaths.length > 0) {
+    return { verdict: "WEAK", existingPaths, missingPaths, details: `Partially missing: ${missingPaths.join(", ")}` };
+  }
+  return { verdict: "STRONG", existingPaths, missingPaths };
+}
+function getRuntimeTrustVerdict(entry, workspaceRoot) {
+  return verifyRuntimeFiles(entry, workspaceRoot).verdict;
+}
+var detectGraphProvider;
+var init_graph = __esm(() => {
+  detectGraphProvider = detectProvider;
+});
+
 // src/retrieval.ts
-import { existsSync as existsSync4 } from "node:fs";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync5 } from "node:fs";
+import { join as join5 } from "node:path";
 function tokenize(text) {
   if (!text || typeof text !== "string")
     return [];
@@ -3587,7 +3852,7 @@ function graphSymbolOverlapBonus(entry, queryTokens) {
     return 0;
   return Math.min(0.2, matches / queryTokens.length * 0.2);
 }
-function scoreEntry(entry, queryTokens, now) {
+function scoreEntry(entry, queryTokens, now = Date.now(), workspaceRoot) {
   const app = applicability(entry, queryTokens);
   const statusPenalty = STATUS_PENALTY[entry.status] ?? 0;
   const vLevel = entry.verification?.level ?? "unverified";
@@ -3597,9 +3862,19 @@ function scoreEntry(entry, queryTokens, now) {
   const reinforcementBonus = Math.sign(r) * 0.05 * Math.min(Math.abs(r), 5);
   const dueBonus = dueDateBonus(entry, now);
   const graphBonus = graphSymbolOverlapBonus(entry, queryTokens);
+  let trustAdjustment = 0;
+  if (entry.graph?.affected_paths && entry.graph.affected_paths.length > 0) {
+    const { verifyRuntimeFiles: verifyRuntimeFiles2 } = (init_graph(), __toCommonJS(exports_graph));
+    const verdict = verifyRuntimeFiles2(entry, workspaceRoot);
+    if (verdict.verdict === "STRONG")
+      trustAdjustment = 0.15;
+    else if (verdict.verdict === "STALE")
+      trustAdjustment = -0.4;
+  }
   const decayBase = entry.valid_from ?? entry.updated_at;
   const decay = 0.3 * Math.exp(-daysSince(decayBase, now) / 90);
-  return app + statusPenalty + verificationBonus + salienceBonus + reinforcementBonus + dueBonus + graphBonus + decay;
+  const zeroMatchPenalty = queryTokens.length > 0 && app === 0 && graphBonus === 0 ? -0.35 : 0;
+  return app + statusPenalty + verificationBonus + salienceBonus + reinforcementBonus + dueBonus + graphBonus + trustAdjustment + decay + zeroMatchPenalty;
 }
 function sortCandidates(candidates, queryTokens, now) {
   return candidates.map((entry) => ({ entry, score: scoreEntry(entry, queryTokens, now) })).sort((a, b) => {
@@ -3719,7 +3994,7 @@ function formatPromptContext(store, memoryDir, query = "", options = {}) {
     }
     parts.push("");
   }
-  if (memoryDir && existsSync4(join4(memoryDir, "wiki"))) {
+  if (memoryDir && existsSync5(join5(memoryDir, "wiki"))) {
     try {
       const wikiPages = listWikiPages(memoryDir, { detailLevel: "l1", project: options.project });
       if (wikiPages.length > 0) {
@@ -3979,17 +4254,17 @@ var init_retrieval = __esm(() => {
 });
 
 // src/governor.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "node:fs";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5 } from "node:fs";
+import { join as join6 } from "node:path";
 import { execSync } from "node:child_process";
 function currentFilePath(memoryDir) {
-  return join5(memoryDir, "CURRENT.md");
+  return join6(memoryDir, "CURRENT.md");
 }
 function parseCurrentFile(memoryDir) {
   const p = currentFilePath(memoryDir);
-  if (!existsSync5(p))
+  if (!existsSync6(p))
     return { constraints: [], handoff: null };
-  const raw = readFileSync4(p, "utf8");
+  const raw = readFileSync5(p, "utf8");
   const lines = raw.split(`
 `);
   const constraints = [];
@@ -4079,7 +4354,7 @@ function parseCurrentFile(memoryDir) {
 }
 function writeCurrentFile(memoryDir, data) {
   const p = currentFilePath(memoryDir);
-  mkdirSync4(memoryDir, { recursive: true });
+  mkdirSync5(memoryDir, { recursive: true });
   const parts = [`# Active Project Constraints & In-Flight Context
 `];
   parts.push("## Active Working Invariants & Hard Constraints");
@@ -4118,7 +4393,7 @@ function writeCurrentFile(memoryDir, data) {
     }
     parts.push("");
   }
-  writeFileSync3(p, parts.join(`
+  writeFileSync4(p, parts.join(`
 `), "utf8");
 }
 function updateSessionHandoff(memoryDir, update) {
@@ -4422,7 +4697,7 @@ var init_current = __esm(() => {
 });
 
 // src/transcript.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
 function parseJsonlTranscript(jsonlText) {
   if (!jsonlText)
     return [];
@@ -4473,8 +4748,8 @@ function parseJsonlTranscript(jsonlText) {
 }
 function searchTranscriptWithBookends(transcriptPathOrContent, query, options = {}) {
   let content = transcriptPathOrContent;
-  if (existsSync6(transcriptPathOrContent)) {
-    content = readFileSync5(transcriptPathOrContent, "utf8");
+  if (existsSync7(transcriptPathOrContent)) {
+    content = readFileSync6(transcriptPathOrContent, "utf8");
   }
   const turns = parseJsonlTranscript(content);
   if (turns.length === 0) {
@@ -4544,7 +4819,7 @@ ${m.matchedTurn}`);
 var init_transcript = () => {};
 
 // src/harvest.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "node:fs";
 import { createHash } from "node:crypto";
 function extractHarvestUnits(text) {
   if (!text || typeof text !== "string")
@@ -4679,8 +4954,8 @@ function openLoopId(text) {
 }
 function importTranscript(store, transcriptPathOrContent, options = {}) {
   let content = transcriptPathOrContent;
-  if (existsSync7(transcriptPathOrContent)) {
-    content = readFileSync6(transcriptPathOrContent, "utf8");
+  if (existsSync8(transcriptPathOrContent)) {
+    content = readFileSync7(transcriptPathOrContent, "utf8");
   }
   const blocks = parseJsonlTranscript(content);
   const fullText = blocks.join(`
@@ -4758,210 +5033,6 @@ var init_harvest = __esm(() => {
   ];
 });
 
-// src/graph.ts
-import { existsSync as existsSync8, readdirSync, readFileSync as readFileSync7, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5 } from "node:fs";
-import { join as join6 } from "node:path";
-function detectProvider(projectRoot) {
-  if (!projectRoot || !existsSync8(projectRoot))
-    return "none";
-  if (existsSync8(join6(projectRoot, ".codegraph"))) {
-    return "codegraph";
-  }
-  if (existsSync8(join6(projectRoot, ".graphify"))) {
-    return "graphify";
-  }
-  return "none";
-}
-function getGraphStatus(projectRoot) {
-  const provider = detectProvider(projectRoot);
-  if (provider === "codegraph") {
-    const codegraphDir = join6(projectRoot, ".codegraph");
-    let symbolCount;
-    let graphRevision;
-    try {
-      if (existsSync8(codegraphDir)) {
-        const files = readdirSync(codegraphDir);
-        symbolCount = files.length;
-        const metaPath = join6(codegraphDir, "meta.json");
-        if (existsSync8(metaPath)) {
-          const meta = JSON.parse(readFileSync7(metaPath, "utf8"));
-          graphRevision = meta.revision ?? meta.commit ?? meta.version;
-        }
-      }
-    } catch {}
-    return {
-      provider: "codegraph",
-      available: true,
-      root: codegraphDir,
-      graphRevision,
-      symbolCount
-    };
-  }
-  if (provider === "graphify") {
-    const graphifyDir = join6(projectRoot, ".graphify");
-    let symbolCount;
-    let graphRevision;
-    try {
-      if (existsSync8(graphifyDir)) {
-        const files = readdirSync(graphifyDir);
-        symbolCount = files.length;
-        const metaPath = join6(graphifyDir, "meta.json");
-        if (existsSync8(metaPath)) {
-          const meta = JSON.parse(readFileSync7(metaPath, "utf8"));
-          graphRevision = meta.revision ?? meta.commit ?? meta.version;
-        }
-      }
-    } catch {}
-    return {
-      provider: "graphify",
-      available: true,
-      root: graphifyDir,
-      graphRevision,
-      symbolCount
-    };
-  }
-  return {
-    provider: "none",
-    available: false,
-    root: projectRoot
-  };
-}
-function graphSymbolsPath(memoryDir) {
-  return join6(memoryDir, "graph-symbols.json");
-}
-function indexGraph(projectRoot, memoryDir) {
-  const status = getGraphStatus(projectRoot);
-  const symbols = {};
-  if (status.provider === "codegraph") {
-    const codegraphDir = join6(projectRoot, ".codegraph");
-    try {
-      const candidates = [
-        join6(codegraphDir, "symbols.json"),
-        join6(codegraphDir, "index.json"),
-        join6(codegraphDir, "graph.json")
-      ];
-      for (const c of candidates) {
-        if (existsSync8(c)) {
-          const data = JSON.parse(readFileSync7(c, "utf8"));
-          if (Array.isArray(data)) {
-            for (const item of data) {
-              if (item.name && item.path) {
-                symbols[String(item.name)] = String(item.path);
-              }
-            }
-          } else if (typeof data === "object" && data !== null) {
-            if (data.symbols && typeof data.symbols === "object") {
-              for (const [k, v] of Object.entries(data.symbols)) {
-                symbols[k] = typeof v === "string" ? v : v?.path || "";
-              }
-            } else {
-              for (const [k, v] of Object.entries(data)) {
-                if (typeof v === "string")
-                  symbols[k] = v;
-              }
-            }
-          }
-        }
-      }
-      if (Object.keys(symbols).length === 0 && existsSync8(codegraphDir)) {
-        const files = readdirSync(codegraphDir);
-        for (const file of files) {
-          if (file.endsWith(".json") && file !== "meta.json") {
-            try {
-              const content = JSON.parse(readFileSync7(join6(codegraphDir, file), "utf8"));
-              if (content.name && content.path) {
-                symbols[String(content.name)] = String(content.path);
-              } else if (content.symbols && Array.isArray(content.symbols)) {
-                for (const s of content.symbols) {
-                  if (s.name && (s.path || content.path)) {
-                    symbols[String(s.name)] = String(s.path || content.path);
-                  }
-                }
-              }
-            } catch {}
-          }
-        }
-      }
-    } catch {}
-  } else if (status.provider === "graphify") {
-    const graphifyDir = join6(projectRoot, ".graphify");
-    try {
-      const candidates = [
-        join6(graphifyDir, "graph.json"),
-        join6(graphifyDir, "symbols.json")
-      ];
-      for (const c of candidates) {
-        if (existsSync8(c)) {
-          const data = JSON.parse(readFileSync7(c, "utf8"));
-          if (data.nodes && Array.isArray(data.nodes)) {
-            for (const node of data.nodes) {
-              if (node.name && node.path) {
-                symbols[String(node.name)] = String(node.path);
-              }
-            }
-          }
-        }
-      }
-    } catch {}
-  }
-  const index = {
-    provider: status.provider,
-    indexedAt: new Date().toISOString(),
-    symbolCount: Object.keys(symbols).length,
-    symbols
-  };
-  try {
-    mkdirSync5(memoryDir, { recursive: true });
-    writeFileSync4(graphSymbolsPath(memoryDir), JSON.stringify(index, null, 2), "utf8");
-  } catch {}
-  return index;
-}
-function loadGraphSymbolIndex(memoryDir) {
-  const p = graphSymbolsPath(memoryDir);
-  if (!existsSync8(p))
-    return null;
-  try {
-    const raw = readFileSync7(p, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function extractReferencedSymbols(text, memoryDir) {
-  const index = loadGraphSymbolIndex(memoryDir);
-  if (!index || index.symbolCount === 0) {
-    return { symbol_names: [], affected_paths: [], provider: "none" };
-  }
-  const matchedSymbols = new Set;
-  const affectedPaths = new Set;
-  const words = text.match(/[a-zA-Z_$][a-zA-Z0-9_$]*/g) || [];
-  const wordSet = new Set(words);
-  for (const [symbol, path] of Object.entries(index.symbols)) {
-    if (wordSet.has(symbol)) {
-      matchedSymbols.add(symbol);
-      if (path)
-        affectedPaths.add(path);
-    }
-  }
-  return {
-    symbol_names: Array.from(matchedSymbols),
-    affected_paths: Array.from(affectedPaths),
-    provider: index.provider
-  };
-}
-function autoStampGraphMetadata(text, memoryDir) {
-  const extracted = extractReferencedSymbols(text, memoryDir);
-  if (extracted.symbol_names.length === 0)
-    return;
-  return {
-    provider: extracted.provider,
-    symbol_names: extracted.symbol_names,
-    affected_paths: extracted.affected_paths,
-    graph_verified_at: new Date().toISOString()
-  };
-}
-var init_graph = () => {};
-
 // src/sqlite.ts
 import { existsSync as existsSync9, mkdirSync as mkdirSync6 } from "node:fs";
 import { dirname } from "node:path";
@@ -6776,6 +6847,9 @@ function ancestorChain(startDir) {
   }
   return chain;
 }
+function resolveMemoryDir(options = {}) {
+  return findOrCreateProjectRoot(options.root || process.cwd(), options).memoryDir;
+}
 var MEMORY_DIR_NAMES;
 var init_root = __esm(() => {
   init_user();
@@ -26553,6 +26627,211 @@ var init_settings2 = __esm(() => {
   init_settings();
 });
 
+// src/plasticity.ts
+var exports_plasticity = {};
+__export(exports_plasticity, {
+  getAssociatedMemories: () => getAssociatedMemories,
+  getHebbianAssociationWeight: () => getHebbianAssociationWeight,
+  loadHebbianGraph: () => loadHebbianGraph,
+  recordCoActivation: () => recordCoActivation,
+  saveHebbianGraph: () => saveHebbianGraph
+});
+import { existsSync as existsSync30, readFileSync as readFileSync24, writeFileSync as writeFileSync16 } from "node:fs";
+import { join as join27 } from "node:path";
+function getPlasticityPath(memoryDir) {
+  return join27(memoryDir, "hebbian-plasticity.json");
+}
+function loadHebbianGraph(memoryDir) {
+  const p = getPlasticityPath(memoryDir);
+  if (!existsSync30(p))
+    return {};
+  try {
+    return JSON.parse(readFileSync24(p, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveHebbianGraph(memoryDir, graph) {
+  const p = getPlasticityPath(memoryDir);
+  try {
+    writeFileSync16(p, JSON.stringify(graph, null, 2), "utf8");
+  } catch {}
+}
+function recordCoActivation(memoryIds, memoryDir) {
+  const ids = Array.from(new Set(memoryIds.filter(Boolean)));
+  if (ids.length < 2)
+    return;
+  const graph = loadHebbianGraph(memoryDir);
+  const now = new Date().toISOString();
+  for (let i = 0;i < ids.length; i++) {
+    const src = ids[i];
+    if (!graph[src])
+      graph[src] = {};
+    for (let j = 0;j < ids.length; j++) {
+      if (i === j)
+        continue;
+      const tgt = ids[j];
+      const existing = graph[src][tgt];
+      const prevWeight = existing ? existing.weight : 0;
+      const prevCount = existing ? existing.count : 0;
+      const newWeight = Math.min(1, Math.round((prevWeight + 0.05) * 1000) / 1000);
+      graph[src][tgt] = {
+        weight: newWeight,
+        count: prevCount + 1,
+        lastActivated: now
+      };
+    }
+  }
+  saveHebbianGraph(memoryDir, graph);
+}
+function getHebbianAssociationWeight(sourceId, targetId, memoryDir) {
+  const graph = loadHebbianGraph(memoryDir);
+  return graph[sourceId]?.[targetId]?.weight ?? 0;
+}
+function getAssociatedMemories(sourceId, memoryDir) {
+  const graph = loadHebbianGraph(memoryDir);
+  const targets = graph[sourceId];
+  if (!targets)
+    return [];
+  return Object.entries(targets).map(([targetId, edge]) => ({
+    targetId,
+    weight: edge.weight,
+    count: edge.count
+  })).sort((a, b) => b.weight - a.weight);
+}
+var init_plasticity = () => {};
+
+// src/compress.ts
+var exports_compress = {};
+__export(exports_compress, {
+  compressPromptContext: () => compressPromptContext,
+  estimateTokens: () => estimateTokens
+});
+function estimateTokens(text) {
+  if (!text || text.trim().length === 0)
+    return 0;
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+function compressPromptContext(text, options = {}) {
+  if (!text || text.trim().length === 0) {
+    return {
+      compressed: "",
+      originalTokens: 0,
+      compressedTokens: 0,
+      savingsPercent: 0
+    };
+  }
+  const originalTokens = estimateTokens(text);
+  let cleaned = text.replace(/\n\s*\n\s*\n+/g, `
+
+`).replace(/### Active Working Constraints \(CURRENT\.md\)/gi, "### Active Constraints").replace(/### Active In-Flight Context & Session Handoff \(CURRENT\.md\)/gi, "### In-Flight Handoff").replace(/### User Profile & Preferences \(USER\.md\)/gi, "### User Profile").replace(/### Relevant Memories & Learned Patterns/gi, "### Memories").replace(/\n\s*---\s*\n/g, `
+`).replace(/\*Memory Directive: When learning durable facts[^\n]*\*/gi, "").replace(/[ \t]{2,}/g, " ").trim();
+  const compressedTokens = estimateTokens(cleaned);
+  const diff = originalTokens - compressedTokens;
+  const savingsPercent = originalTokens > 0 ? Math.round(Math.max(0, diff) / originalTokens * 100) : 0;
+  return {
+    compressed: cleaned,
+    originalTokens,
+    compressedTokens,
+    savingsPercent
+  };
+}
+
+// src/drift.ts
+var exports_drift = {};
+__export(exports_drift, {
+  getGitChangedFiles: () => getGitChangedFiles,
+  scanCodeDrift: () => scanCodeDrift,
+  scanCodeDriftFromDiff: () => scanCodeDriftFromDiff
+});
+import { execSync as execSync2 } from "node:child_process";
+import { existsSync as existsSync31 } from "node:fs";
+import { join as join28, isAbsolute as isAbsolute2 } from "node:path";
+function scanCodeDriftFromDiff(entries, changedFiles, workspaceRoot) {
+  const root = workspaceRoot || process.cwd();
+  const normalizedChanged = new Set(changedFiles.map((f) => f.trim().replace(/^[\.\/]+/, "")).filter(Boolean));
+  const drifted = [];
+  for (const entry of entries) {
+    if (entry.status !== "confirmed" && entry.status !== "candidate")
+      continue;
+    const paths = entry.graph?.affected_paths || [];
+    const symbols = entry.graph?.symbol_names || [];
+    for (const p of paths) {
+      const norm = p.trim().replace(/^[\.\/]+/, "");
+      const matched = Array.from(normalizedChanged).find((cf) => cf === norm || cf.endsWith(`/${norm}`) || norm.endsWith(`/${cf}`));
+      if (matched) {
+        const fullPath = isAbsolute2(p) ? p : join28(root, p);
+        const exists = existsSync31(fullPath);
+        drifted.push({
+          memoryId: entry.id,
+          title: entry.title,
+          affectedPath: p,
+          symbols,
+          driftType: exists ? "modified" : "deleted",
+          suggestedAction: exists ? "verify" : "mark_stale"
+        });
+        break;
+      }
+    }
+  }
+  return {
+    isDrifted: drifted.length > 0,
+    driftCount: drifted.length,
+    driftedMemories: drifted,
+    scannedFilesCount: normalizedChanged.size,
+    changedFiles: Array.from(normalizedChanged)
+  };
+}
+function getGitChangedFiles(workspaceRoot) {
+  const root = workspaceRoot || process.cwd();
+  try {
+    const stdout = execSync2("git status --porcelain", {
+      cwd: root,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const files = [];
+    for (const line of stdout.split(`
+`)) {
+      const trimmed = line.trim();
+      if (!trimmed)
+        continue;
+      const parts = trimmed.split(/\s+/);
+      const filePath = parts.length >= 2 ? parts[parts.length - 1] : "";
+      if (filePath)
+        files.push(filePath);
+    }
+    try {
+      const diffOut = execSync2("git diff --name-only HEAD", {
+        cwd: root,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      for (const line of diffOut.split(`
+`)) {
+        const f = line.trim();
+        if (f && !files.includes(f))
+          files.push(f);
+      }
+    } catch {}
+    return files;
+  } catch {
+    return [];
+  }
+}
+function scanCodeDrift(options = {}) {
+  const root = options.workspaceRoot || process.cwd();
+  const changedFiles = getGitChangedFiles(root);
+  const memDir = options.memoryDir || resolveMemoryDir({ global: false, root });
+  const store = openStore(memDir);
+  const entries = list(store);
+  return scanCodeDriftFromDiff(entries, changedFiles, root);
+}
+var init_drift = __esm(() => {
+  init_store();
+  init_root();
+});
+
 // src/mcp.ts
 var exports_mcp = {};
 __export(exports_mcp, {
@@ -27163,6 +27442,28 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
           },
           required: ["settings"]
         }
+      },
+      {
+        name: "memory_drift",
+        description: "Scan the local Git workspace for modified or deleted code files and AST symbols referenced by memories. Flags drifted memories for re-verification or supersession.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            dir: { type: "string", description: "Optional project workspace directory path" }
+          }
+        }
+      },
+      {
+        name: "memory_compress",
+        description: "Compress formatted prompt context losslessly, stripping header whitespace and boilerplate while preserving all architectural facts.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            text: { type: "string", description: "Markdown prompt context to compress" },
+            level: { type: "string", enum: ["light", "aggressive"], description: "Compression aggressiveness level" }
+          },
+          required: ["text"]
+        }
       }
     ]
   }));
@@ -27200,8 +27501,19 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
             verified: a.verified === true,
             depth: a.depth ? String(a.depth) : undefined
           });
+          if (formatted.entries.length >= 2 && activeMemoryDir) {
+            try {
+              const { recordCoActivation: recordCoActivation2 } = await Promise.resolve().then(() => (init_plasticity(), exports_plasticity));
+              recordCoActivation2(formatted.entries.map((e) => e.entry.id), activeMemoryDir);
+            } catch {}
+          }
+          let finalMarkdown = formatted.markdown;
+          if (a.compress === true) {
+            const { compressPromptContext: compressPromptContext2 } = await Promise.resolve().then(() => exports_compress);
+            finalMarkdown = compressPromptContext2(finalMarkdown).compressed;
+          }
           return toolResult({
-            markdown: formatted.markdown,
+            markdown: finalMarkdown,
             entries: formatted.entries.map((r) => ({ ...r.entry, score: r.score })),
             total_tokens_used: formatted.totalTokensUsed,
             constraints: formatted.constraints,
@@ -27635,6 +27947,18 @@ Path: ${item.path}`,
             return toolError(err instanceof Error ? err.message : String(err));
           }
         }
+        case "memory_drift": {
+          const { scanCodeDrift: scanCodeDrift2 } = await Promise.resolve().then(() => (init_drift(), exports_drift));
+          const report = scanCodeDrift2({ workspaceRoot: activeRoot, memoryDir: activeMemoryDir });
+          return toolResult(report);
+        }
+        case "memory_compress": {
+          const { compressPromptContext: compressPromptContext2 } = await Promise.resolve().then(() => exports_compress);
+          const text = String(a.text ?? "");
+          const level = a.level === "aggressive" ? "aggressive" : "light";
+          const result = compressPromptContext2(text, { level });
+          return toolResult(result);
+        }
         default:
           return toolError(`unknown tool ${name}`);
       }
@@ -27699,8 +28023,8 @@ __export(exports_daemon, {
   startHub: () => startHub
 });
 import { createServer as createServer2 } from "node:http";
-import { existsSync as existsSync30 } from "node:fs";
-import { join as join27 } from "node:path";
+import { existsSync as existsSync32 } from "node:fs";
+import { join as join29 } from "node:path";
 import { watch } from "node:fs";
 function startHub(port, memoryDir) {
   const clients = new Set;
@@ -27766,7 +28090,7 @@ data: ${JSON.stringify(event)}
     return clients.size;
   }
   if (memoryDir) {
-    const memoriesDir = join27(memoryDir, "memories");
+    const memoriesDir = join29(memoryDir, "memories");
     const armDebounced = (type2) => {
       if (debounceTimer)
         clearTimeout(debounceTimer);
@@ -27775,11 +28099,11 @@ data: ${JSON.stringify(event)}
       }, DEBOUNCE_MS);
     };
     try {
-      if (existsSync30(memoriesDir)) {
+      if (existsSync32(memoriesDir)) {
         watchers.push(watch(memoriesDir, () => armDebounced("memory.changed")));
       }
-      const currentMd = join27(memoryDir, "CURRENT.md");
-      if (existsSync30(currentMd)) {
+      const currentMd = join29(memoryDir, "CURRENT.md");
+      if (existsSync32(currentMd)) {
         watchers.push(watch(currentMd, () => armDebounced("constraints.changed")));
       }
     } catch {}
@@ -27812,19 +28136,19 @@ var DEBOUNCE_MS = 300;
 var init_daemon = () => {};
 
 // src/cli/ecosystem.ts
-import { join as join28 } from "node:path";
-import { existsSync as existsSync31, mkdirSync as mkdirSync18, writeFileSync as writeFileSync16, readFileSync as readFileSync24 } from "node:fs";
+import { join as join30 } from "node:path";
+import { existsSync as existsSync33, mkdirSync as mkdirSync18, writeFileSync as writeFileSync17, readFileSync as readFileSync25 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
 function ensureProjectAgentInstructions(targetDir) {
-  const agentsMdPath = join28(targetDir, "AGENTS.md");
-  if (existsSync31(agentsMdPath)) {
+  const agentsMdPath = join30(targetDir, "AGENTS.md");
+  if (existsSync33(agentsMdPath)) {
     try {
-      const existing = readFileSync24(agentsMdPath, "utf8");
+      const existing = readFileSync25(agentsMdPath, "utf8");
       if (existing.includes("<!-- agentmemory:start -->")) {
         const updated = existing.replace(/<!-- agentmemory:start -->[\s\S]*?<!-- agentmemory:end -->/, MUSE_MEMORY_DIRECTIVE);
-        writeFileSync16(agentsMdPath, updated, "utf8");
+        writeFileSync17(agentsMdPath, updated, "utf8");
       } else if (!existing.includes("<!-- musememory:start -->") && !existing.includes("Muse Memory")) {
-        writeFileSync16(agentsMdPath, `${existing.trim()}
+        writeFileSync17(agentsMdPath, `${existing.trim()}
 
 ${MUSE_MEMORY_DIRECTIVE}
 `, "utf8");
@@ -27835,23 +28159,23 @@ ${MUSE_MEMORY_DIRECTIVE}
 
 ${MUSE_MEMORY_DIRECTIVE}
 `;
-    writeFileSync16(agentsMdPath, initialContent, "utf8");
+    writeFileSync17(agentsMdPath, initialContent, "utf8");
   }
 }
 async function handleInstallCommand({ positional, flags }) {
   const isGlobal = flags["global"] === "true" || flags["g"] === "true";
-  const targetDir = positional[0] ? join28(process.cwd(), positional[0]) : process.cwd();
-  const memoryDir = isGlobal ? getGlobalMemoryDir() : join28(targetDir, ".memory");
+  const targetDir = positional[0] ? join30(process.cwd(), positional[0]) : process.cwd();
+  const memoryDir = isGlobal ? getGlobalMemoryDir() : join30(targetDir, ".memory");
   const globalDir = getGlobalMemoryDir();
-  mkdirSync18(join28(memoryDir, "memories"), { recursive: true });
-  mkdirSync18(join28(globalDir, "memories"), { recursive: true });
-  const currentPath = join28(memoryDir, "CURRENT.md");
-  if (!existsSync31(currentPath)) {
-    writeFileSync16(currentPath, `# Active Project Constraints
+  mkdirSync18(join30(memoryDir, "memories"), { recursive: true });
+  mkdirSync18(join30(globalDir, "memories"), { recursive: true });
+  const currentPath = join30(memoryDir, "CURRENT.md");
+  if (!existsSync33(currentPath)) {
+    writeFileSync17(currentPath, `# Active Project Constraints
 `, "utf8");
   }
   const globalUserPath = userFilePath(globalDir);
-  if (!existsSync31(globalUserPath)) {
+  if (!existsSync33(globalUserPath)) {
     const { promptSingleSelect: promptSingleSelect2 } = await Promise.resolve().then(() => (init_prompt(), exports_prompt));
     const archetypeOptions = [
       { id: "developer", label: "Software Engineer / Developer", hint: "Code-first, direct, strict typing" },
@@ -27867,13 +28191,13 @@ async function handleInstallCommand({ positional, flags }) {
   if (!isGlobal) {
     ensureProjectAgentInstructions(targetDir);
   }
-  const globalAgentsMd = join28(homedir6(), ".agents", "AGENTS.md");
-  if (existsSync31(globalAgentsMd)) {
+  const globalAgentsMd = join30(homedir6(), ".agents", "AGENTS.md");
+  if (existsSync33(globalAgentsMd)) {
     try {
-      const existing = readFileSync24(globalAgentsMd, "utf8");
+      const existing = readFileSync25(globalAgentsMd, "utf8");
       if (existing.includes("<!-- agentmemory:start -->")) {
         const updated = existing.replace(/<!-- agentmemory:start -->[\s\S]*?<!-- agentmemory:end -->/, MUSE_MEMORY_DIRECTIVE);
-        writeFileSync16(globalAgentsMd, updated, "utf8");
+        writeFileSync17(globalAgentsMd, updated, "utf8");
       }
     } catch {}
   }
@@ -27901,11 +28225,11 @@ async function handleInstallCommand({ positional, flags }) {
   return 0;
 }
 async function promptOrNotifyGitHook(targetDir, autoInstall = false) {
-  const gitDir = join28(targetDir, ".git");
-  if (!existsSync31(gitDir))
+  const gitDir = join30(targetDir, ".git");
+  if (!existsSync33(gitDir))
     return false;
-  const hookPath = join28(gitDir, "hooks", "pre-commit");
-  const isInstalled = existsSync31(hookPath) && readFileSync24(hookPath, "utf8").includes("memory harvest-auto");
+  const hookPath = join30(gitDir, "hooks", "pre-commit");
+  const isInstalled = existsSync33(hookPath) && readFileSync25(hookPath, "utf8").includes("memory harvest-auto");
   if (isInstalled)
     return true;
   if (autoInstall) {
@@ -27949,7 +28273,7 @@ async function handleUninstallCommand({ positional, flags }) {
   }
   if (purge) {
     const ctx = requireRoot(flags);
-    if (ctx && existsSync31(ctx.memoryDir) && !dryRun) {
+    if (ctx && existsSync33(ctx.memoryDir) && !dryRun) {
       const { rmSync: rmSync3 } = await import("node:fs");
       rmSync3(ctx.memoryDir, { recursive: true, force: true });
       console.log(`  [PURGED] Memory directory removed: ${ctx.memoryDir}`);
@@ -27962,13 +28286,13 @@ async function handleUninstallCommand({ positional, flags }) {
 }
 async function handleInitCommand({ positional, flags }) {
   const isGlobal = flags["global"] === "true";
-  const targetDir = positional[0] ? join28(process.cwd(), positional[0]) : process.cwd();
+  const targetDir = positional[0] ? join30(process.cwd(), positional[0]) : process.cwd();
   const memoryDirName = flags["legacy"] === "true" ? ".musememory" : ".memory";
-  const memoryDir = isGlobal ? getGlobalMemoryDir() : join28(targetDir, memoryDirName);
-  mkdirSync18(join28(memoryDir, "memories"), { recursive: true });
-  const currentPath = join28(memoryDir, "CURRENT.md");
-  if (!existsSync31(currentPath)) {
-    writeFileSync16(currentPath, `# Active Project Constraints
+  const memoryDir = isGlobal ? getGlobalMemoryDir() : join30(targetDir, memoryDirName);
+  mkdirSync18(join30(memoryDir, "memories"), { recursive: true });
+  const currentPath = join30(memoryDir, "CURRENT.md");
+  if (!existsSync33(currentPath)) {
+    writeFileSync17(currentPath, `# Active Project Constraints
 `, "utf8");
   }
   if (!isGlobal) {
@@ -28192,9 +28516,46 @@ async function handleDaemonCommand({ flags }) {
   const { startHub: startHub2 } = await Promise.resolve().then(() => (init_daemon(), exports_daemon));
   const hub = await startHub2(port, ctx.memoryDir);
   console.log(`Agency hub listening on ${hub.url}`);
-  console.log(`Publish events: curl -X POST http://localhost:${hub.port}/publish -d '{"type":"agent.joined","payload":{"name":"me"}}'`);
   return new Promise(() => {});
 }
+async function handleDriftCommand({ flags }) {
+  const ctx = requireRoot(flags);
+  if (!ctx)
+    return 1;
+  const { scanCodeDrift: scanCodeDrift2 } = await Promise.resolve().then(() => (init_drift(), exports_drift));
+  const report = scanCodeDrift2({ workspaceRoot: ctx.root, memoryDir: ctx.memoryDir });
+  if (flags["json"] === "true") {
+    console.log(JSON.stringify(report, null, 2));
+    return 0;
+  }
+  console.log(`[Code-Drift Scanner] Scanned ${report.scannedFilesCount} modified/deleted files in Git workspace.`);
+  if (!report.isDrifted) {
+    console.log(`✓ 0 drifted memories. All referenced code symbols and files are intact.`);
+    return 0;
+  }
+  console.log(`⚠️ Detected ${report.driftCount} drifted memories:`);
+  for (const d of report.driftedMemories) {
+    console.log(`  - [${d.driftType.toUpperCase()}] ${d.memoryId}: "${d.title}" -> ${d.affectedPath} (action: ${d.suggestedAction})`);
+  }
+  return 0;
+}
+async function handleCompressCommand({ positional, flags }) {
+  const text = positional.join(" ") || "";
+  if (!text) {
+    return usageError("compress requires text or input");
+  }
+  const { compressPromptContext: compressPromptContext2 } = await Promise.resolve().then(() => exports_compress);
+  const level = flags["aggressive"] === "true" ? "aggressive" : "light";
+  const result = compressPromptContext2(text, { level });
+  if (flags["json"] === "true") {
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  }
+  console.log(`[Prompt Compression] Tokens: ${result.originalTokens} ➔ ${result.compressedTokens} (${result.savingsPercent}% savings)
+`);
+  console.log(result.compressed);
+  return 0;
+}
 var MUSE_MEMORY_DIRECTIVE = `<!-- musememory:start -->
 ## \uD83E\uDDE0 Persistent Cognitive Memory (Muse Memory)
 
@@ -28215,8 +28576,8 @@ var init_ecosystem = __esm(() => {
 });
 
 // src/agentcontract.ts
-import { existsSync as existsSync32 } from "node:fs";
-import { join as join29 } from "node:path";
+import { existsSync as existsSync34 } from "node:fs";
+import { join as join31 } from "node:path";
 function parseAgentMemoryContract(markdown) {
   if (!markdown || !markdown.startsWith("---"))
     return null;
@@ -28248,17 +28609,17 @@ function parseAgentMemoryContract(markdown) {
 function resolveAgentFile(nameOrPath, workspaceRoot) {
   if (!nameOrPath)
     return null;
-  if (existsSync32(nameOrPath))
+  if (existsSync34(nameOrPath))
     return nameOrPath;
   const candidates = [
-    join29(workspaceRoot, ".agents", `${nameOrPath}.md`),
-    join29(workspaceRoot, ".memory", "agents", `${nameOrPath}.md`)
+    join31(workspaceRoot, ".agents", `${nameOrPath}.md`),
+    join31(workspaceRoot, ".memory", "agents", `${nameOrPath}.md`)
   ];
   const home = process.env.HOME;
   if (home)
-    candidates.push(join29(home, ".config", "opencode", "agents", `${nameOrPath}.md`));
+    candidates.push(join31(home, ".config", "opencode", "agents", `${nameOrPath}.md`));
   for (const c of candidates) {
-    if (existsSync32(c))
+    if (existsSync34(c))
       return c;
   }
   return null;
@@ -28268,8 +28629,8 @@ var init_agentcontract = __esm(() => {
 });
 
 // src/cli/retrieval.ts
-import { existsSync as existsSync33, readFileSync as readFileSync25 } from "node:fs";
-import { join as join30 } from "node:path";
+import { existsSync as existsSync35, readFileSync as readFileSync26 } from "node:fs";
+import { join as join32 } from "node:path";
 async function handleContextCommand({ positional, flags }) {
   let agentTypes;
   let agentTags;
@@ -28277,7 +28638,7 @@ async function handleContextCommand({ positional, flags }) {
     const file = resolveAgentFile(flags["for-agent"], flags["dir"] ?? process.cwd());
     if (!file)
       return usageError(`--for-agent: cannot resolve agent '${flags["for-agent"]}'`);
-    const contract = parseAgentMemoryContract(readFileSync25(file, "utf8"));
+    const contract = parseAgentMemoryContract(readFileSync26(file, "utf8"));
     if (contract) {
       agentTypes = contract.types;
       agentTags = contract.tags;
@@ -28417,7 +28778,7 @@ async function handleHarvestCommand({ positional, flags }) {
   const project = flags["project"];
   if (!project)
     return usageError("harvest requires --project");
-  const rawText = existsSync33(target) ? readFileSync25(target, "utf8") : target;
+  const rawText = existsSync35(target) ? readFileSync26(target, "utf8") : target;
   const created = harvestMemories(ctx.store, {
     text: rawText,
     project,
@@ -28453,8 +28814,8 @@ async function handleSearchTranscriptCommand({ positional, flags }) {
   const filePath = positional[1];
   if (!query)
     return usageError("search-transcript requires <query> [file.jsonl]");
-  const targetFile = filePath ? filePath.startsWith("/") ? filePath : join30(process.cwd(), filePath) : join30(process.cwd(), "transcript.jsonl");
-  if (!existsSync33(targetFile)) {
+  const targetFile = filePath ? filePath.startsWith("/") ? filePath : join32(process.cwd(), filePath) : join32(process.cwd(), "transcript.jsonl");
+  if (!existsSync35(targetFile)) {
     return fail(`error: transcript file not found: ${targetFile}`);
   }
   const windowSize = flags["window"] ? parseInt(flags["window"], 10) : 2;
@@ -28470,7 +28831,7 @@ async function handleReindexCommand({ flags }) {
   const { rebuildIndex: rebuildIndex2, saveIndex: saveIndex2 } = await Promise.resolve().then(() => (init_vector(), exports_vector));
   const index = rebuildIndex2(ctx.store);
   saveIndex2(index, ctx.memoryDir);
-  console.log(`indexed ${Object.keys(index.entries).length} entries -> ${join30(ctx.memoryDir, "index.json")}`);
+  console.log(`indexed ${Object.keys(index.entries).length} entries -> ${join32(ctx.memoryDir, "index.json")}`);
   return 0;
 }
 async function handleHookCommand({ positional, flags }) {
@@ -28861,7 +29222,7 @@ var init_entities2 = __esm(() => {
 });
 
 // src/cli/settings.ts
-import { writeFileSync as writeFileSync17, readFileSync as readFileSync26 } from "node:fs";
+import { writeFileSync as writeFileSync18, readFileSync as readFileSync27 } from "node:fs";
 function handleSettingsCommand(parsed) {
   const ctx = requireRoot(parsed.flags);
   if (!ctx)
@@ -28943,7 +29304,7 @@ function handleSettingsCommand(parsed) {
     const out = parsed.flags.out;
     const json2 = exportSettings(memoryDir);
     if (out) {
-      writeFileSync17(out, json2, "utf8");
+      writeFileSync18(out, json2, "utf8");
       console.log(`Exported settings to ${out}`);
     } else {
       console.log(json2);
@@ -28957,7 +29318,7 @@ function handleSettingsCommand(parsed) {
       return 2;
     }
     try {
-      const raw = readFileSync26(file, "utf8");
+      const raw = readFileSync27(file, "utf8");
       importSettings(memoryDir, raw);
       console.log(`Successfully imported settings from ${file}`);
       return 0;
@@ -28980,16 +29341,16 @@ var init_nudge = __esm(() => {
 });
 
 // src/routines.ts
-import { readFileSync as readFileSync27, existsSync as existsSync34 } from "node:fs";
-import { join as join31 } from "node:path";
+import { readFileSync as readFileSync28, existsSync as existsSync36 } from "node:fs";
+import { join as join33 } from "node:path";
 function routinesPath(memoryDir) {
-  return join31(memoryDir, "routines.yaml");
+  return join33(memoryDir, "routines.yaml");
 }
 function loadRoutines(memoryDir) {
   const p = routinesPath(memoryDir);
-  if (!existsSync34(p))
+  if (!existsSync36(p))
     return { routines: {} };
-  const doc2 = yaml.load(readFileSync27(p, "utf8"), { schema: yaml.JSON_SCHEMA }) ?? {};
+  const doc2 = yaml.load(readFileSync28(p, "utf8"), { schema: yaml.JSON_SCHEMA }) ?? {};
   const routines = doc2.routines ?? {};
   for (const [name, r] of Object.entries(routines)) {
     if (!r || typeof r.schedule !== "string" || !r.schedule.trim()) {
@@ -29027,7 +29388,7 @@ var init_routines = __esm(() => {
 });
 
 // src/cli/lifecycle.ts
-import { writeFileSync as writeFileSync18, readFileSync as readFileSync28, existsSync as existsSync35 } from "node:fs";
+import { writeFileSync as writeFileSync19, readFileSync as readFileSync29, existsSync as existsSync37 } from "node:fs";
 async function handleProposeCommand({ positional, flags }) {
   const ctx = requireRoot(flags);
   if (!ctx)
@@ -29176,7 +29537,7 @@ async function handleExportCommand({ flags }) {
   const snapshot = exportSnapshot(ctx.store);
   const outPath = flags["out"];
   if (outPath) {
-    writeFileSync18(outPath, JSON.stringify(snapshot, null, 2), "utf8");
+    writeFileSync19(outPath, JSON.stringify(snapshot, null, 2), "utf8");
     console.log(`exported ${snapshot.total} memories to ${outPath}`);
   } else {
     console.log(JSON.stringify(snapshot, null, 2));
@@ -29190,9 +29551,9 @@ async function handleImportCommand({ positional, flags }) {
   const file = positional[0];
   if (!file)
     return usageError("import requires <file.json>");
-  if (!existsSync35(file))
+  if (!existsSync37(file))
     return fail(`error: file ${file} does not exist`);
-  const raw = JSON.parse(readFileSync28(file, "utf8"));
+  const raw = JSON.parse(readFileSync29(file, "utf8"));
   const res = importSnapshot(ctx.store, raw, { overwrite: flags["overwrite"] === "true" });
   if (res.errors.length > 0) {
     console.error(`import encountered errors:`);
@@ -29577,6 +29938,11 @@ async function main(argv) {
       return handleUiCommand(parsed);
     case "graph":
       return handleGraphCommand(parsed);
+    case "drift":
+    case "check":
+      return handleDriftCommand(parsed);
+    case "compress":
+      return handleCompressCommand(parsed);
     case "mcp":
       return handleMcpCommand();
     case "daemon":