engramx 0.4.0 → 0.4.2

package/dist/cli.js

@@ -24,17 +24,17 @@ import {
 
 // src/cli.ts
 import { Command } from "commander";
-import chalk from "chalk";
+import chalk2 from "chalk";
 import {
-  existsSync as existsSync7,
-  readFileSync as readFileSync4,
+  existsSync as existsSync8,
+  readFileSync as readFileSync5,
   writeFileSync as writeFileSync2,
   mkdirSync,
   unlinkSync,
   copyFileSync,
   renameSync as renameSync3
 } from "fs";
-import { dirname as dirname3, join as join7, resolve as pathResolve } from "path";
+import { dirname as dirname3, join as join8, resolve as pathResolve } from "path";
 import { homedir } from "os";
 
 // src/intercept/safety.ts
@@ -44,8 +44,8 @@ var PASSTHROUGH = null;
 var DEFAULT_HANDLER_TIMEOUT_MS = 2e3;
 async function withTimeout(promise, ms = DEFAULT_HANDLER_TIMEOUT_MS) {
   let timer;
-  const timeout = new Promise((resolve6) => {
-    timer = setTimeout(() => resolve6(PASSTHROUGH), ms);
+  const timeout = new Promise((resolve7) => {
+    timer = setTimeout(() => resolve7(PASSTHROUGH), ms);
   });
   try {
     return await Promise.race([promise, timeout]);
@@ -1162,6 +1162,244 @@ function watchProject(projectRoot, options = {}) {
   return controller;
 }
 
+// src/dashboard.ts
+import chalk from "chalk";
+import { existsSync as existsSync6, statSync as statSync4 } from "fs";
+import { join as join6, resolve as resolve6, basename as basename4 } from "path";
+
+// src/intercept/stats.ts
+var ESTIMATED_TOKENS_PER_READ_DENY = 1200;
+function summarizeHookLog(entries) {
+  const byEvent = {};
+  const byTool = {};
+  const byDecision = {};
+  let readDenyCount = 0;
+  let firstEntryTs = null;
+  let lastEntryTs = null;
+  for (const entry of entries) {
+    const event = entry.event ?? "unknown";
+    byEvent[event] = (byEvent[event] ?? 0) + 1;
+    const tool = entry.tool ?? "unknown";
+    byTool[tool] = (byTool[tool] ?? 0) + 1;
+    if (entry.decision) {
+      byDecision[entry.decision] = (byDecision[entry.decision] ?? 0) + 1;
+    }
+    if (event === "PreToolUse" && tool === "Read" && entry.decision === "deny") {
+      readDenyCount += 1;
+    }
+    const ts = entry.ts;
+    if (typeof ts === "string") {
+      if (firstEntryTs === null || ts < firstEntryTs) firstEntryTs = ts;
+      if (lastEntryTs === null || ts > lastEntryTs) lastEntryTs = ts;
+    }
+  }
+  return {
+    totalInvocations: entries.length,
+    byEvent: Object.freeze(byEvent),
+    byTool: Object.freeze(byTool),
+    byDecision: Object.freeze(byDecision),
+    readDenyCount,
+    estimatedTokensSaved: readDenyCount * ESTIMATED_TOKENS_PER_READ_DENY,
+    firstEntry: firstEntryTs,
+    lastEntry: lastEntryTs
+  };
+}
+function formatStatsSummary(summary) {
+  if (summary.totalInvocations === 0) {
+    return "engram hook stats: no log entries yet.\n\nRun engram install-hook in a project, then use Claude Code to see interceptions.";
+  }
+  const lines = [];
+  lines.push(`engram hook stats (${summary.totalInvocations} invocations)`);
+  lines.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  if (summary.firstEntry && summary.lastEntry) {
+    lines.push(`Time range: ${summary.firstEntry} \u2192 ${summary.lastEntry}`);
+    lines.push("");
+  }
+  lines.push("By event:");
+  const eventEntries = Object.entries(summary.byEvent).sort(
+    (a, b) => b[1] - a[1]
+  );
+  for (const [event, count] of eventEntries) {
+    const pct = (count / summary.totalInvocations * 100).toFixed(1);
+    lines.push(`  ${event.padEnd(18)} ${String(count).padStart(5)} (${pct}%)`);
+  }
+  lines.push("");
+  lines.push("By tool:");
+  const toolEntries = Object.entries(summary.byTool).filter(([k]) => k !== "unknown").sort((a, b) => b[1] - a[1]);
+  for (const [tool, count] of toolEntries) {
+    lines.push(`  ${tool.padEnd(18)} ${String(count).padStart(5)}`);
+  }
+  if (toolEntries.length === 0) {
+    lines.push("  (no tool-tagged entries)");
+  }
+  lines.push("");
+  const decisionEntries = Object.entries(summary.byDecision);
+  if (decisionEntries.length > 0) {
+    lines.push("PreToolUse decisions:");
+    for (const [decision, count] of decisionEntries.sort(
+      (a, b) => b[1] - a[1]
+    )) {
+      lines.push(`  ${decision.padEnd(18)} ${String(count).padStart(5)}`);
+    }
+    lines.push("");
+  }
+  if (summary.readDenyCount > 0) {
+    lines.push(
+      `Estimated tokens saved: ~${summary.estimatedTokensSaved.toLocaleString()}`
+    );
+    lines.push(
+      `  (${summary.readDenyCount} Read denies \xD7 ${ESTIMATED_TOKENS_PER_READ_DENY} tok/deny avg)`
+    );
+  } else {
+    lines.push("Estimated tokens saved: 0");
+    lines.push("  (no PreToolUse:Read denies recorded yet)");
+  }
+  return lines.join("\n");
+}
+
+// src/dashboard.ts
+var AMBER = chalk.hex("#d97706");
+var DIM = chalk.dim;
+var GREEN = chalk.green;
+var RED = chalk.red;
+var BOLD = chalk.bold;
+var WHITE = chalk.white;
+function bar(pct, width = 20) {
+  const filled = Math.round(pct / 100 * width);
+  const empty = width - filled;
+  return AMBER("\u2588".repeat(filled)) + DIM("\u2591".repeat(empty));
+}
+function fmt(n) {
+  return n.toLocaleString();
+}
+function topFiles(entries, n) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    if (e.event === "PreToolUse" && e.decision === "deny" && e.path) {
+      counts.set(e.path, (counts.get(e.path) ?? 0) + 1);
+    }
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, n).map(([path2, count]) => ({ path: path2, count }));
+}
+function recentActivity(entries, n) {
+  return entries.slice(-n);
+}
+function formatActivity(entry) {
+  const tool = entry.tool ?? "?";
+  const decision = entry.decision ?? "?";
+  const path2 = entry.path ? entry.path.length > 40 ? "..." + entry.path.slice(-37) : entry.path : "";
+  const icon = decision === "deny" ? GREEN("\u2713") : decision === "allow" ? DIM("\u2192") : DIM("\xB7");
+  const decLabel = decision === "deny" ? GREEN("intercepted") : decision === "allow" ? DIM("allowed") : DIM("passthrough");
+  return `  ${icon} ${WHITE(tool.padEnd(6))} ${decLabel.padEnd(22)} ${DIM(path2)}`;
+}
+function clearScreen() {
+  process.stdout.write("\x1B[2J\x1B[H");
+}
+function render(projectRoot, entries) {
+  const summary = summarizeHookLog(entries);
+  const projectName = basename4(resolve6(projectRoot));
+  const totalReads = (summary.byDecision["deny"] ?? 0) + (summary.byDecision["allow"] ?? 0) + (summary.byDecision["passthrough"] ?? 0);
+  const intercepted = summary.readDenyCount;
+  const hitRate = totalReads > 0 ? intercepted / totalReads * 100 : 0;
+  const tokensSaved = summary.estimatedTokensSaved;
+  const landmines = entries.filter(
+    (e) => e.event === "PreToolUse" && e.tool === "Edit" && e.decision === "allow" && e.injection
+  ).length;
+  clearScreen();
+  console.log(
+    AMBER("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557")
+  );
+  console.log(
+    AMBER("  \u2551") + WHITE(
+      `  engram dashboard \u2014 ${projectName}`.padEnd(54)
+    ) + AMBER("\u2551")
+  );
+  console.log(
+    AMBER("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D")
+  );
+  console.log();
+  console.log(
+    `  ${AMBER("TOKENS SAVED")}    ${GREEN(BOLD(fmt(tokensSaved)))} ${DIM(`(~${fmt(intercepted)} reads \xD7 ${fmt(ESTIMATED_TOKENS_PER_READ_DENY)} tokens)`)}`
+  );
+  console.log();
+  console.log(
+    `  ${AMBER("HIT RATE")}        ${bar(hitRate)} ${WHITE(BOLD(hitRate.toFixed(1) + "%"))} ${DIM(`(${intercepted}/${totalReads} tool calls)`)}`
+  );
+  console.log();
+  const denied = summary.byDecision["deny"] ?? 0;
+  const allowed = summary.byDecision["allow"] ?? 0;
+  const passthrough = summary.byDecision["passthrough"] ?? 0;
+  console.log(
+    `  ${AMBER("DECISIONS")}       ${GREEN("\u25A0")} intercepted ${GREEN(BOLD(String(denied)))}    ${DIM("\u25A0")} allowed ${DIM(String(allowed))}    ${DIM("\u25A0")} passthrough ${DIM(String(passthrough))}`
+  );
+  if (landmines > 0) {
+    console.log(
+      `                  ${RED("\u25B2")} landmine warnings ${RED(BOLD(String(landmines)))}`
+    );
+  }
+  console.log();
+  const events = summary.byEvent;
+  const eventLine = Object.entries(events).sort((a, b) => b[1] - a[1]).map(([k, v]) => `${DIM(k)} ${WHITE(String(v))}`).join("  ");
+  console.log(`  ${AMBER("EVENTS")}          ${eventLine}`);
+  console.log();
+  const top = topFiles(entries, 5);
+  if (top.length > 0) {
+    console.log(`  ${AMBER("TOP FILES")}       ${DIM("(most intercepted)")}`);
+    for (const f of top) {
+      const barLen = Math.min(
+        Math.round(f.count / (top[0]?.count ?? 1) * 15),
+        15
+      );
+      console.log(
+        `                  ${AMBER("\u2588".repeat(barLen))} ${WHITE(String(f.count).padStart(3))}  ${DIM(f.path)}`
+      );
+    }
+    console.log();
+  }
+  const recent = recentActivity(entries, 8);
+  if (recent.length > 0) {
+    console.log(`  ${AMBER("RECENT")}          ${DIM("(last 8 events)")}`);
+    for (const e of recent) {
+      console.log(formatActivity(e));
+    }
+    console.log();
+  }
+  console.log(
+    DIM(
+      `  Total invocations: ${summary.totalInvocations}` + (summary.firstEntry ? `  |  Since: ${summary.firstEntry}` : "") + `  |  Press Ctrl+C to exit`
+    )
+  );
+}
+function startDashboard(projectRoot, options = {}) {
+  const root = resolve6(projectRoot);
+  const interval = options.interval ?? 1e3;
+  const controller = new AbortController();
+  let lastSize = 0;
+  let cachedEntries = [];
+  const tick = () => {
+    if (controller.signal.aborted) return;
+    try {
+      const logPath = join6(root, ".engram", "hook-log.jsonl");
+      if (existsSync6(logPath)) {
+        const currentSize = statSync4(logPath).size;
+        if (currentSize !== lastSize) {
+          cachedEntries = readHookLog(root);
+          lastSize = currentSize;
+        }
+      }
+      render(root, cachedEntries);
+    } catch {
+    }
+  };
+  tick();
+  const timer = setInterval(tick, interval);
+  timer.unref();
+  controller.signal.addEventListener("abort", () => {
+    clearInterval(timer);
+  });
+  return controller;
+}
+
 // src/intercept/cursor-adapter.ts
 var ALLOW = { permission: "allow" };
 function toClaudeReadPayload(cursorPayload) {
@@ -1334,105 +1572,15 @@ function formatInstallDiff(before, after) {
   return lines.length > 0 ? lines.join("\n") : "(no changes)";
 }
 
-// src/intercept/stats.ts
-var ESTIMATED_TOKENS_PER_READ_DENY = 1200;
-function summarizeHookLog(entries) {
-  const byEvent = {};
-  const byTool = {};
-  const byDecision = {};
-  let readDenyCount = 0;
-  let firstEntryTs = null;
-  let lastEntryTs = null;
-  for (const entry of entries) {
-    const event = entry.event ?? "unknown";
-    byEvent[event] = (byEvent[event] ?? 0) + 1;
-    const tool = entry.tool ?? "unknown";
-    byTool[tool] = (byTool[tool] ?? 0) + 1;
-    if (entry.decision) {
-      byDecision[entry.decision] = (byDecision[entry.decision] ?? 0) + 1;
-    }
-    if (event === "PreToolUse" && tool === "Read" && entry.decision === "deny") {
-      readDenyCount += 1;
-    }
-    const ts = entry.ts;
-    if (typeof ts === "string") {
-      if (firstEntryTs === null || ts < firstEntryTs) firstEntryTs = ts;
-      if (lastEntryTs === null || ts > lastEntryTs) lastEntryTs = ts;
-    }
-  }
-  return {
-    totalInvocations: entries.length,
-    byEvent: Object.freeze(byEvent),
-    byTool: Object.freeze(byTool),
-    byDecision: Object.freeze(byDecision),
-    readDenyCount,
-    estimatedTokensSaved: readDenyCount * ESTIMATED_TOKENS_PER_READ_DENY,
-    firstEntry: firstEntryTs,
-    lastEntry: lastEntryTs
-  };
-}
-function formatStatsSummary(summary) {
-  if (summary.totalInvocations === 0) {
-    return "engram hook stats: no log entries yet.\n\nRun engram install-hook in a project, then use Claude Code to see interceptions.";
-  }
-  const lines = [];
-  lines.push(`engram hook stats (${summary.totalInvocations} invocations)`);
-  lines.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-  if (summary.firstEntry && summary.lastEntry) {
-    lines.push(`Time range: ${summary.firstEntry} \u2192 ${summary.lastEntry}`);
-    lines.push("");
-  }
-  lines.push("By event:");
-  const eventEntries = Object.entries(summary.byEvent).sort(
-    (a, b) => b[1] - a[1]
-  );
-  for (const [event, count] of eventEntries) {
-    const pct = (count / summary.totalInvocations * 100).toFixed(1);
-    lines.push(`  ${event.padEnd(18)} ${String(count).padStart(5)} (${pct}%)`);
-  }
-  lines.push("");
-  lines.push("By tool:");
-  const toolEntries = Object.entries(summary.byTool).filter(([k]) => k !== "unknown").sort((a, b) => b[1] - a[1]);
-  for (const [tool, count] of toolEntries) {
-    lines.push(`  ${tool.padEnd(18)} ${String(count).padStart(5)}`);
-  }
-  if (toolEntries.length === 0) {
-    lines.push("  (no tool-tagged entries)");
-  }
-  lines.push("");
-  const decisionEntries = Object.entries(summary.byDecision);
-  if (decisionEntries.length > 0) {
-    lines.push("PreToolUse decisions:");
-    for (const [decision, count] of decisionEntries.sort(
-      (a, b) => b[1] - a[1]
-    )) {
-      lines.push(`  ${decision.padEnd(18)} ${String(count).padStart(5)}`);
-    }
-    lines.push("");
-  }
-  if (summary.readDenyCount > 0) {
-    lines.push(
-      `Estimated tokens saved: ~${summary.estimatedTokensSaved.toLocaleString()}`
-    );
-    lines.push(
-      `  (${summary.readDenyCount} Read denies \xD7 ${ESTIMATED_TOKENS_PER_READ_DENY} tok/deny avg)`
-    );
-  } else {
-    lines.push("Estimated tokens saved: 0");
-    lines.push("  (no PreToolUse:Read denies recorded yet)");
-  }
-  return lines.join("\n");
-}
-
 // src/intercept/memory-md.ts
 import {
-  existsSync as existsSync6,
-  readFileSync as readFileSync3,
+  existsSync as existsSync7,
+  readFileSync as readFileSync4,
   writeFileSync,
   renameSync as renameSync2,
-  statSync as statSync4
+  statSync as statSync5
 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 var ENGRAM_MARKER_START = "<!-- engram:structural-facts:start -->";
 var ENGRAM_MARKER_END = "<!-- engram:structural-facts:end -->";
 var MAX_MEMORY_FILE_BYTES = 1e6;
@@ -1503,15 +1651,15 @@ function writeEngramSectionToMemoryMd(projectRoot, engramSection) {
   if (engramSection.length > MAX_ENGRAM_SECTION_BYTES) {
     return false;
   }
-  const memoryPath = join6(projectRoot, "MEMORY.md");
+  const memoryPath = join7(projectRoot, "MEMORY.md");
   try {
     let existing = "";
-    if (existsSync6(memoryPath)) {
-      const st = statSync4(memoryPath);
+    if (existsSync7(memoryPath)) {
+      const st = statSync5(memoryPath);
       if (st.size > MAX_MEMORY_FILE_BYTES) {
         return false;
       }
-      existing = readFileSync3(memoryPath, "utf-8");
+      existing = readFileSync4(memoryPath, "utf-8");
     }
     const updated = upsertEngramSection(existing, engramSection);
     const tmpPath = memoryPath + ".engram-tmp";
@@ -1524,55 +1672,58 @@ function writeEngramSectionToMemoryMd(projectRoot, engramSection) {
 }
 
 // src/cli.ts
-import { basename as basename4 } from "path";
+import { basename as basename5 } from "path";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var { version: PKG_VERSION } = require2("../package.json");
 var program = new Command();
 program.name("engram").description(
   "Context as infra for AI coding tools \u2014 hook-based Read/Edit interception + structural graph summaries"
-).version("0.3.0");
+).version(PKG_VERSION);
 program.command("init").description("Scan codebase and build knowledge graph (zero LLM cost)").argument("[path]", "Project directory", ".").option(
   "--with-skills [dir]",
   "Also index Claude Code skills from ~/.claude/skills/ or a given path"
 ).action(async (projectPath, opts) => {
-  console.log(chalk.dim("\u{1F50D} Scanning codebase..."));
+  console.log(chalk2.dim("\u{1F50D} Scanning codebase..."));
   const result = await init(projectPath, {
     withSkills: opts.withSkills
   });
   console.log(
-    chalk.green("\u{1F333} AST extraction complete") + chalk.dim(` (${result.timeMs}ms, 0 tokens used)`)
+    chalk2.green("\u{1F333} AST extraction complete") + chalk2.dim(` (${result.timeMs}ms, 0 tokens used)`)
   );
   console.log(
-    `   ${chalk.bold(String(result.nodes))} nodes, ${chalk.bold(String(result.edges))} edges from ${chalk.bold(String(result.fileCount))} files (${result.totalLines.toLocaleString()} lines)`
+    `   ${chalk2.bold(String(result.nodes))} nodes, ${chalk2.bold(String(result.edges))} edges from ${chalk2.bold(String(result.fileCount))} files (${result.totalLines.toLocaleString()} lines)`
   );
   if (result.skillCount && result.skillCount > 0) {
     console.log(
-      chalk.cyan(`   ${chalk.bold(String(result.skillCount))} skills indexed`)
+      chalk2.cyan(`   ${chalk2.bold(String(result.skillCount))} skills indexed`)
     );
   }
   const bench = await benchmark(projectPath);
   if (bench.naiveFullCorpus > 0 && bench.reductionVsRelevant > 1) {
     console.log(
-      chalk.cyan(`
-\u{1F4CA} Token savings: ${chalk.bold(bench.reductionVsRelevant + "x")} fewer tokens vs relevant files (${bench.reductionVsFull}x vs full corpus)`)
+      chalk2.cyan(`
+\u{1F4CA} Token savings: ${chalk2.bold(bench.reductionVsRelevant + "x")} fewer tokens vs relevant files (${bench.reductionVsFull}x vs full corpus)`)
     );
     console.log(
-      chalk.dim(`   Full corpus: ~${bench.naiveFullCorpus.toLocaleString()} tokens | Graph query: ~${bench.avgQueryTokens.toLocaleString()} tokens`)
+      chalk2.dim(`   Full corpus: ~${bench.naiveFullCorpus.toLocaleString()} tokens | Graph query: ~${bench.avgQueryTokens.toLocaleString()} tokens`)
     );
   }
-  console.log(chalk.green("\n\u2705 Ready. Your AI now has persistent memory."));
-  console.log(chalk.dim("   Graph stored in .engram/graph.db"));
+  console.log(chalk2.green("\n\u2705 Ready. Your AI now has persistent memory."));
+  console.log(chalk2.dim("   Graph stored in .engram/graph.db"));
   const resolvedProject = pathResolve(projectPath);
-  const localSettings = join7(resolvedProject, ".claude", "settings.local.json");
-  const projectSettings = join7(resolvedProject, ".claude", "settings.json");
-  const hasHooks = existsSync7(localSettings) && readFileSync4(localSettings, "utf-8").includes("engram intercept") || existsSync7(projectSettings) && readFileSync4(projectSettings, "utf-8").includes("engram intercept");
+  const localSettings = join8(resolvedProject, ".claude", "settings.local.json");
+  const projectSettings = join8(resolvedProject, ".claude", "settings.json");
+  const hasHooks = existsSync8(localSettings) && readFileSync5(localSettings, "utf-8").includes("engram intercept") || existsSync8(projectSettings) && readFileSync5(projectSettings, "utf-8").includes("engram intercept");
   if (!hasHooks) {
     console.log(
-      chalk.yellow("\n\u{1F4A1} Next step: ") + chalk.white("engram install-hook") + chalk.dim(
+      chalk2.yellow("\n\u{1F4A1} Next step: ") + chalk2.white("engram install-hook") + chalk2.dim(
         " \u2014 enables automatic Read interception (82% token savings)"
       )
     );
     console.log(
-      chalk.dim(
-        "   Also recommended: " + chalk.white("engram hooks install") + " \u2014 auto-rebuild graph on git commit"
+      chalk2.dim(
+        "   Also recommended: " + chalk2.white("engram hooks install") + " \u2014 auto-rebuild graph on git commit"
       )
     );
   }
@@ -1580,24 +1731,43 @@ program.command("init").description("Scan codebase and build knowledge graph (ze
 program.command("watch").description("Watch project for file changes and re-index incrementally").argument("[path]", "Project directory", ".").action(async (projectPath) => {
   const resolvedPath = pathResolve(projectPath);
   console.log(
-    chalk.dim("\u{1F441}  Watching ") + chalk.white(resolvedPath) + chalk.dim(" for changes...")
+    chalk2.dim("\u{1F441}  Watching ") + chalk2.white(resolvedPath) + chalk2.dim(" for changes...")
   );
   const controller = watchProject(resolvedPath, {
     onReindex: (filePath, nodeCount) => {
       console.log(
-        chalk.green("  \u21BB ") + chalk.white(filePath) + chalk.dim(` (${nodeCount} nodes)`)
+        chalk2.green("  \u21BB ") + chalk2.white(filePath) + chalk2.dim(` (${nodeCount} nodes)`)
       );
     },
     onError: (err) => {
-      console.error(chalk.red("  \u2717 ") + err.message);
+      console.error(chalk2.red("  \u2717 ") + err.message);
     },
     onReady: () => {
-      console.log(chalk.green("  \u2713 Watcher active.") + chalk.dim(" Press Ctrl+C to stop."));
+      console.log(chalk2.green("  \u2713 Watcher active.") + chalk2.dim(" Press Ctrl+C to stop."));
     }
   });
   process.on("SIGINT", () => {
     controller.abort();
-    console.log(chalk.dim("\n  Watcher stopped."));
+    console.log(chalk2.dim("\n  Watcher stopped."));
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+});
+program.command("dashboard").alias("hud").description("Live terminal dashboard showing hook activity and token savings").argument("[path]", "Project directory", ".").action(async (projectPath) => {
+  const resolvedPath = pathResolve(projectPath);
+  const dbPath = join8(resolvedPath, ".engram", "graph.db");
+  if (!existsSync8(dbPath)) {
+    console.error(
+      chalk2.red("No engram graph found at ") + chalk2.white(resolvedPath)
+    );
+    console.error(chalk2.dim("Run 'engram init' first."));
+    process.exit(1);
+  }
+  const controller = startDashboard(resolvedPath);
+  process.on("SIGINT", () => {
+    controller.abort();
+    console.log(chalk2.dim("\n  Dashboard closed."));
     process.exit(0);
   });
   await new Promise(() => {
@@ -1610,10 +1780,10 @@ program.command("query").description("Query the knowledge graph").argument("<que
     tokenBudget: Number(opts.budget)
   });
   if (result.nodesFound === 0) {
-    console.log(chalk.yellow("No matching nodes found."));
+    console.log(chalk2.yellow("No matching nodes found."));
     return;
   }
-  console.log(chalk.dim(`Found ${result.nodesFound} nodes (~${result.estimatedTokens} tokens)
+  console.log(chalk2.dim(`Found ${result.nodesFound} nodes (~${result.estimatedTokens} tokens)
 `));
   console.log(result.text);
 });
@@ -1624,25 +1794,25 @@ program.command("path").description("Find shortest path between two concepts").a
 program.command("gods").description("Show most connected entities (god nodes)").option("-n, --top <n>", "Number of nodes", "10").option("-p, --project <path>", "Project directory", ".").action(async (opts) => {
   const gods = await godNodes(opts.project, Number(opts.top));
   if (gods.length === 0) {
-    console.log(chalk.yellow("No nodes found. Run `engram init` first."));
+    console.log(chalk2.yellow("No nodes found. Run `engram init` first."));
     return;
   }
-  console.log(chalk.bold("God nodes (most connected):\n"));
+  console.log(chalk2.bold("God nodes (most connected):\n"));
   for (let i = 0; i < gods.length; i++) {
     const g = gods[i];
     console.log(
-      `  ${chalk.dim(String(i + 1) + ".")} ${chalk.bold(g.label)} ${chalk.dim(`[${g.kind}]`)} \u2014 ${g.degree} edges ${chalk.dim(g.sourceFile)}`
+      `  ${chalk2.dim(String(i + 1) + ".")} ${chalk2.bold(g.label)} ${chalk2.dim(`[${g.kind}]`)} \u2014 ${g.degree} edges ${chalk2.dim(g.sourceFile)}`
     );
   }
 });
 program.command("stats").description("Show knowledge graph statistics and token savings").option("-p, --project <path>", "Project directory", ".").action(async (opts) => {
   const s = await stats(opts.project);
   const bench = await benchmark(opts.project);
-  console.log(chalk.bold("\n\u{1F4CA} engram stats\n"));
-  console.log(`  Nodes:       ${chalk.bold(String(s.nodes))}`);
-  console.log(`  Edges:       ${chalk.bold(String(s.edges))}`);
+  console.log(chalk2.bold("\n\u{1F4CA} engram stats\n"));
+  console.log(`  Nodes:       ${chalk2.bold(String(s.nodes))}`);
+  console.log(`  Edges:       ${chalk2.bold(String(s.edges))}`);
   console.log(
-    `  Confidence:  ${chalk.green(s.extractedPct + "% EXTRACTED")} \xB7 ${chalk.yellow(s.inferredPct + "% INFERRED")} \xB7 ${chalk.red(s.ambiguousPct + "% AMBIGUOUS")}`
+    `  Confidence:  ${chalk2.green(s.extractedPct + "% EXTRACTED")} \xB7 ${chalk2.yellow(s.inferredPct + "% INFERRED")} \xB7 ${chalk2.red(s.ambiguousPct + "% AMBIGUOUS")}`
   );
   if (s.lastMined > 0) {
     const ago = Math.round((Date.now() - s.lastMined) / 6e4);
@@ -1650,20 +1820,20 @@ program.command("stats").description("Show knowledge graph statistics and token
   }
   if (bench.naiveFullCorpus > 0) {
     console.log(`
-  ${chalk.cyan("Token savings:")}`);
+  ${chalk2.cyan("Token savings:")}`);
     console.log(`    Full corpus:   ~${bench.naiveFullCorpus.toLocaleString()} tokens`);
     console.log(`    Avg query:     ~${bench.avgQueryTokens.toLocaleString()} tokens`);
-    console.log(`    vs relevant:   ${chalk.bold.cyan(bench.reductionVsRelevant + "x")} fewer tokens`);
-    console.log(`    vs full:       ${chalk.bold.cyan(bench.reductionVsFull + "x")} fewer tokens`);
+    console.log(`    vs relevant:   ${chalk2.bold.cyan(bench.reductionVsRelevant + "x")} fewer tokens`);
+    console.log(`    vs full:       ${chalk2.bold.cyan(bench.reductionVsFull + "x")} fewer tokens`);
   }
   console.log();
 });
 program.command("learn").description("Teach engram a decision, pattern, or lesson").argument("<text>", "What to remember (e.g., 'We chose JWT over sessions for horizontal scaling')").option("-p, --project <path>", "Project directory", ".").action(async (text, opts) => {
   const result = await learn(opts.project, text);
   if (result.nodesAdded > 0) {
-    console.log(chalk.green(`\u{1F9E0} Learned ${result.nodesAdded} new insight(s).`));
+    console.log(chalk2.green(`\u{1F9E0} Learned ${result.nodesAdded} new insight(s).`));
   } else {
-    console.log(chalk.yellow("No patterns extracted. Try a more specific statement."));
+    console.log(chalk2.yellow("No patterns extracted. Try a more specific statement."));
   }
 });
 program.command("mistakes").description("List known mistakes extracted from past sessions").option("-p, --project <path>", "Project directory", ".").option("-l, --limit <n>", "Max entries to display", "20").option("--since <days>", "Only mistakes from the last N days").action(
@@ -1673,11 +1843,11 @@ program.command("mistakes").description("List known mistakes extracted from past
       sinceDays: opts.since ? Number(opts.since) : void 0
     });
     if (result.length === 0) {
-      console.log(chalk.yellow("No mistakes recorded."));
+      console.log(chalk2.yellow("No mistakes recorded."));
       return;
     }
     console.log(
-      chalk.bold(`
+      chalk2.bold(`
 \u26A0\uFE0F  ${result.length} mistake(s) recorded:
 `)
     );
@@ -1687,7 +1857,7 @@ program.command("mistakes").description("List known mistakes extracted from past
         Math.round((Date.now() - m.lastVerified) / 864e5)
       );
       console.log(
-        `  ${chalk.dim(`[${m.sourceFile}, ${ago}d ago]`)} ${m.label}`
+        `  ${chalk2.dim(`[${m.sourceFile}, ${ago}d ago]`)} ${m.label}`
       );
     }
     console.log();
@@ -1695,14 +1865,14 @@ program.command("mistakes").description("List known mistakes extracted from past
 );
 program.command("bench").description("Run token reduction benchmark").option("-p, --project <path>", "Project directory", ".").action(async (opts) => {
   const result = await benchmark(opts.project);
-  console.log(chalk.bold("\n\u26A1 engram token reduction benchmark\n"));
+  console.log(chalk2.bold("\n\u26A1 engram token reduction benchmark\n"));
   console.log(`  Full corpus:     ~${result.naiveFullCorpus.toLocaleString()} tokens`);
   console.log(`  Avg graph query: ~${result.avgQueryTokens.toLocaleString()} tokens`);
-  console.log(`  vs relevant:     ${chalk.bold.green(result.reductionVsRelevant + "x")} fewer tokens`);
-  console.log(`  vs full corpus:  ${chalk.bold.green(result.reductionVsFull + "x")} fewer tokens
+  console.log(`  vs relevant:     ${chalk2.bold.green(result.reductionVsRelevant + "x")} fewer tokens`);
+  console.log(`  vs full corpus:  ${chalk2.bold.green(result.reductionVsFull + "x")} fewer tokens
 `);
   for (const pq of result.perQuestion) {
-    console.log(`  ${chalk.dim(`[${pq.reductionRelevant}x relevant / ${pq.reductionFull}x full]`)} ${pq.question}`);
+    console.log(`  ${chalk2.dim(`[${pq.reductionRelevant}x relevant / ${pq.reductionFull}x full]`)} ${pq.question}`);
   }
   console.log();
 });
@@ -1718,7 +1888,7 @@ program.command("gen").description("Generate CLAUDE.md / .cursorrules section fr
     const target = opts.target;
     const result = await autogen(opts.project, target, opts.task);
     console.log(
-      chalk.green(
+      chalk2.green(
         `\u2705 Updated ${result.file} (${result.nodesIncluded} nodes, view: ${result.view})`
       )
     );
@@ -1728,11 +1898,11 @@ function resolveSettingsPath(scope, projectPath) {
   const absProject = pathResolve(projectPath);
   switch (scope) {
     case "local":
-      return join7(absProject, ".claude", "settings.local.json");
+      return join8(absProject, ".claude", "settings.local.json");
     case "project":
-      return join7(absProject, ".claude", "settings.json");
+      return join8(absProject, ".claude", "settings.json");
     case "user":
-      return join7(homedir(), ".claude", "settings.json");
+      return join8(homedir(), ".claude", "settings.json");
     default:
       return null;
   }
@@ -1819,25 +1989,25 @@ program.command("install-hook").description("Install engram hook entries into Cl
     const settingsPath = resolveSettingsPath(opts.scope, opts.project);
     if (!settingsPath) {
       console.error(
-        chalk.red(
+        chalk2.red(
           `Unknown scope: ${opts.scope} (expected: local | project | user)`
         )
       );
       process.exit(1);
     }
     let existing = {};
-    if (existsSync7(settingsPath)) {
+    if (existsSync8(settingsPath)) {
       try {
-        const raw = readFileSync4(settingsPath, "utf-8");
+        const raw = readFileSync5(settingsPath, "utf-8");
         existing = raw.trim() ? JSON.parse(raw) : {};
       } catch (err) {
         console.error(
-          chalk.red(
+          chalk2.red(
             `Failed to parse ${settingsPath}: ${err.message}`
           )
         );
         console.error(
-          chalk.dim(
+          chalk2.dim(
             "Fix the JSON syntax and re-run install-hook, or remove the file and start fresh."
           )
         );
@@ -1846,38 +2016,38 @@ program.command("install-hook").description("Install engram hook entries into Cl
     }
     const result = installEngramHooks(existing);
     console.log(
-      chalk.bold(`
+      chalk2.bold(`
 \u{1F4CC} engram install-hook (scope: ${opts.scope})`)
     );
-    console.log(chalk.dim(`   Target: ${settingsPath}`));
+    console.log(chalk2.dim(`   Target: ${settingsPath}`));
     if (result.added.length === 0) {
       console.log(
-        chalk.yellow(
+        chalk2.yellow(
           `
    All engram hooks already installed (${result.alreadyPresent.join(", ")}).`
         )
       );
       console.log(
-        chalk.dim(
+        chalk2.dim(
           "   Run 'engram uninstall-hook' first if you want to reinstall."
         )
       );
       return;
     }
-    console.log(chalk.cyan("\n   Changes:"));
+    console.log(chalk2.cyan("\n   Changes:"));
     console.log(
       formatInstallDiff(existing, result.updated).split("\n").map((l) => "     " + l).join("\n")
     );
     if (opts.dryRun) {
-      console.log(chalk.dim("\n   (dry-run \u2014 no changes written)"));
+      console.log(chalk2.dim("\n   (dry-run \u2014 no changes written)"));
       return;
     }
     try {
       mkdirSync(dirname3(settingsPath), { recursive: true });
-      if (existsSync7(settingsPath)) {
+      if (existsSync8(settingsPath)) {
         const backupPath = `${settingsPath}.engram-backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.bak`;
         copyFileSync(settingsPath, backupPath);
-        console.log(chalk.dim(`   Backup: ${backupPath}`));
+        console.log(chalk2.dim(`   Backup: ${backupPath}`));
       }
       const tmpPath = settingsPath + ".engram-tmp";
       writeFileSync2(
@@ -1887,26 +2057,26 @@ program.command("install-hook").description("Install engram hook entries into Cl
       renameSync3(tmpPath, settingsPath);
     } catch (err) {
       console.error(
-        chalk.red(`
+        chalk2.red(`
    \u274C Write failed: ${err.message}`)
       );
       process.exit(1);
     }
     console.log(
-      chalk.green(
+      chalk2.green(
         `
    \u2705 Installed ${result.added.length} hook event${result.added.length === 1 ? "" : "s"}: ${result.added.join(", ")}`
       )
     );
     if (result.alreadyPresent.length > 0) {
       console.log(
-        chalk.dim(
+        chalk2.dim(
           `   Already present: ${result.alreadyPresent.join(", ")}`
         )
       );
     }
     console.log(
-      chalk.dim(
+      chalk2.dim(
         "\n   Next: open a Claude Code session and engram will start intercepting tool calls."
       )
     );
@@ -1915,29 +2085,29 @@ program.command("install-hook").description("Install engram hook entries into Cl
 program.command("uninstall-hook").description("Remove engram hook entries from Claude Code settings").option("--scope <scope>", "local | project | user", "local").option("-p, --project <path>", "Project directory", ".").action(async (opts) => {
   const settingsPath = resolveSettingsPath(opts.scope, opts.project);
   if (!settingsPath) {
-    console.error(chalk.red(`Unknown scope: ${opts.scope}`));
+    console.error(chalk2.red(`Unknown scope: ${opts.scope}`));
     process.exit(1);
   }
-  if (!existsSync7(settingsPath)) {
+  if (!existsSync8(settingsPath)) {
     console.log(
-      chalk.yellow(`No settings file at ${settingsPath} \u2014 nothing to remove.`)
+      chalk2.yellow(`No settings file at ${settingsPath} \u2014 nothing to remove.`)
     );
     return;
   }
   let existing;
   try {
-    const raw = readFileSync4(settingsPath, "utf-8");
+    const raw = readFileSync5(settingsPath, "utf-8");
     existing = raw.trim() ? JSON.parse(raw) : {};
   } catch (err) {
     console.error(
-      chalk.red(`Failed to parse ${settingsPath}: ${err.message}`)
+      chalk2.red(`Failed to parse ${settingsPath}: ${err.message}`)
     );
     process.exit(1);
   }
   const result = uninstallEngramHooks(existing);
   if (result.removed.length === 0) {
     console.log(
-      chalk.yellow(`
+      chalk2.yellow(`
    No engram hooks found in ${settingsPath}.`)
     );
     return;
@@ -1949,15 +2119,15 @@ program.command("uninstall-hook").description("Remove engram hook entries from C
     writeFileSync2(tmpPath, JSON.stringify(result.updated, null, 2) + "\n");
     renameSync3(tmpPath, settingsPath);
     console.log(
-      chalk.green(
+      chalk2.green(
         `
    \u2705 Removed engram hooks from ${result.removed.length} event${result.removed.length === 1 ? "" : "s"}: ${result.removed.join(", ")}`
       )
     );
-    console.log(chalk.dim(`   Backup: ${backupPath}`));
+    console.log(chalk2.dim(`   Backup: ${backupPath}`));
   } catch (err) {
     console.error(
-      chalk.red(`
+      chalk2.red(`
    \u274C Write failed: ${err.message}`)
     );
     process.exit(1);
@@ -1984,16 +2154,16 @@ program.command("hook-preview").description("Show what the Read handler would do
     tool_input: { file_path: absFile }
   };
   const result = await dispatchHook(payload);
-  console.log(chalk.bold(`
+  console.log(chalk2.bold(`
 \u{1F4CB} Hook preview: ${absFile}`));
-  console.log(chalk.dim(`   Project: ${absProject}`));
+  console.log(chalk2.dim(`   Project: ${absProject}`));
   console.log();
   if (result === null || result === void 0) {
     console.log(
-      chalk.yellow("   Decision: PASSTHROUGH (Read would execute normally)")
+      chalk2.yellow("   Decision: PASSTHROUGH (Read would execute normally)")
     );
     console.log(
-      chalk.dim(
+      chalk2.dim(
         "   Possible reasons: file not in graph, confidence below threshold, content unsafe, outside project, stale graph."
       )
     );
@@ -2002,8 +2172,8 @@ program.command("hook-preview").description("Show what the Read handler would do
   const wrapped = result;
   const decision = wrapped.hookSpecificOutput?.permissionDecision;
   if (decision === "deny") {
-    console.log(chalk.green("   Decision: DENY (Read would be replaced)"));
-    console.log(chalk.dim("   Summary (would be delivered to Claude):"));
+    console.log(chalk2.green("   Decision: DENY (Read would be replaced)"));
+    console.log(chalk2.dim("   Summary (would be delivered to Claude):"));
     console.log();
     const reason = wrapped.hookSpecificOutput?.permissionDecisionReason ?? "";
     console.log(
@@ -2012,41 +2182,41 @@ program.command("hook-preview").description("Show what the Read handler would do
     return;
   }
   if (decision === "allow") {
-    console.log(chalk.cyan("   Decision: ALLOW (with additionalContext)"));
+    console.log(chalk2.cyan("   Decision: ALLOW (with additionalContext)"));
     const ctx = wrapped.hookSpecificOutput?.additionalContext ?? "";
     if (ctx) {
-      console.log(chalk.dim("   Additional context that would be injected:"));
+      console.log(chalk2.dim("   Additional context that would be injected:"));
       console.log(
         ctx.split("\n").map((l) => "     " + l).join("\n")
       );
     }
     return;
   }
-  console.log(chalk.yellow(`   Decision: ${decision ?? "unknown"}`));
+  console.log(chalk2.yellow(`   Decision: ${decision ?? "unknown"}`));
 });
 program.command("hook-disable").description("Disable engram hooks via kill switch (does not uninstall)").option("-p, --project <path>", "Project directory", ".").action(async (opts) => {
   const absProject = pathResolve(opts.project);
   const projectRoot = findProjectRoot(absProject);
   if (!projectRoot) {
     console.error(
-      chalk.red(`Not an engram project: ${absProject}`)
+      chalk2.red(`Not an engram project: ${absProject}`)
     );
-    console.error(chalk.dim("Run 'engram init' first."));
+    console.error(chalk2.dim("Run 'engram init' first."));
     process.exit(1);
   }
-  const flagPath = join7(projectRoot, ".engram", "hook-disabled");
+  const flagPath = join8(projectRoot, ".engram", "hook-disabled");
   try {
     writeFileSync2(flagPath, (/* @__PURE__ */ new Date()).toISOString());
     console.log(
-      chalk.green(`\u2705 engram hooks disabled for ${projectRoot}`)
+      chalk2.green(`\u2705 engram hooks disabled for ${projectRoot}`)
     );
-    console.log(chalk.dim(`   Flag: ${flagPath}`));
+    console.log(chalk2.dim(`   Flag: ${flagPath}`));
     console.log(
-      chalk.dim("   Run 'engram hook-enable' to re-enable.")
+      chalk2.dim("   Run 'engram hook-enable' to re-enable.")
     );
   } catch (err) {
     console.error(
-      chalk.red(`Failed to create flag: ${err.message}`)
+      chalk2.red(`Failed to create flag: ${err.message}`)
     );
     process.exit(1);
   }
@@ -2055,24 +2225,24 @@ program.command("hook-enable").description("Re-enable engram hooks (remove kill
   const absProject = pathResolve(opts.project);
   const projectRoot = findProjectRoot(absProject);
   if (!projectRoot) {
-    console.error(chalk.red(`Not an engram project: ${absProject}`));
+    console.error(chalk2.red(`Not an engram project: ${absProject}`));
     process.exit(1);
   }
-  const flagPath = join7(projectRoot, ".engram", "hook-disabled");
-  if (!existsSync7(flagPath)) {
+  const flagPath = join8(projectRoot, ".engram", "hook-disabled");
+  if (!existsSync8(flagPath)) {
     console.log(
-      chalk.yellow(`engram hooks already enabled for ${projectRoot}`)
+      chalk2.yellow(`engram hooks already enabled for ${projectRoot}`)
     );
     return;
   }
   try {
     unlinkSync(flagPath);
     console.log(
-      chalk.green(`\u2705 engram hooks re-enabled for ${projectRoot}`)
+      chalk2.green(`\u2705 engram hooks re-enabled for ${projectRoot}`)
     );
   } catch (err) {
     console.error(
-      chalk.red(`Failed to remove flag: ${err.message}`)
+      chalk2.red(`Failed to remove flag: ${err.message}`)
     );
     process.exit(1);
   }
@@ -2085,9 +2255,9 @@ program.command("memory-sync").description(
     const projectRoot = findProjectRoot(absProject);
     if (!projectRoot) {
       console.error(
-        chalk.red(`Not an engram project: ${absProject}`)
+        chalk2.red(`Not an engram project: ${absProject}`)
       );
-      console.error(chalk.dim("Run 'engram init' first."));
+      console.error(chalk2.dim("Run 'engram init' first."));
       process.exit(1);
     }
     const [gods, mistakeList, graphStats] = await Promise.all([
@@ -2096,21 +2266,21 @@ program.command("memory-sync").description(
       stats(projectRoot).catch(() => null)
     ]);
     if (!graphStats) {
-      console.error(chalk.red("Failed to read graph stats."));
+      console.error(chalk2.red("Failed to read graph stats."));
       process.exit(1);
     }
     let branch = null;
     try {
-      const headPath = join7(projectRoot, ".git", "HEAD");
-      if (existsSync7(headPath)) {
-        const content = readFileSync4(headPath, "utf-8").trim();
+      const headPath = join8(projectRoot, ".git", "HEAD");
+      if (existsSync8(headPath)) {
+        const content = readFileSync5(headPath, "utf-8").trim();
         const m = content.match(/^ref:\s+refs\/heads\/(.+)$/);
         if (m) branch = m[1];
       }
     } catch {
     }
     const section = buildEngramSection({
-      projectName: basename4(projectRoot),
+      projectName: basename5(projectRoot),
       branch,
       stats: {
         nodes: graphStats.nodes,
@@ -2125,37 +2295,37 @@ program.command("memory-sync").description(
       lastMined: graphStats.lastMined
     });
     console.log(
-      chalk.bold(`
+      chalk2.bold(`
 \u{1F4DD} engram memory-sync`)
     );
     console.log(
-      chalk.dim(`   Target: ${join7(projectRoot, "MEMORY.md")}`)
+      chalk2.dim(`   Target: ${join8(projectRoot, "MEMORY.md")}`)
     );
     if (opts.dryRun) {
-      console.log(chalk.cyan("\n   Section to write (dry-run):\n"));
+      console.log(chalk2.cyan("\n   Section to write (dry-run):\n"));
       console.log(
         section.split("\n").map((l) => "     " + l).join("\n")
       );
-      console.log(chalk.dim("\n   (dry-run \u2014 no changes written)"));
+      console.log(chalk2.dim("\n   (dry-run \u2014 no changes written)"));
       return;
     }
     const ok = writeEngramSectionToMemoryMd(projectRoot, section);
     if (!ok) {
       console.error(
-        chalk.red(
+        chalk2.red(
           "\n   \u274C Write failed. MEMORY.md may be too large, or the engram section exceeded its size cap."
         )
       );
       process.exit(1);
     }
     console.log(
-      chalk.green(
+      chalk2.green(
         `
    \u2705 Synced ${gods.length} god nodes${mistakeList.length > 0 ? ` and ${mistakeList.length} landmines` : ""} to MEMORY.md`
       )
     );
     console.log(
-      chalk.dim(
+      chalk2.dim(
         `
    Next: Anthropic's Auto-Dream will consolidate this alongside its prose entries.
 `

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engramx",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "The structural code graph your AI agent can't forget to use. A Claude Code hook layer that intercepts Read/Edit/Write/Bash and replaces file contents with ~300-token structural graph summaries. 82% measured token reduction. Context rot is empirically solved — cite Chroma. Local SQLite, zero LLM cost, zero cloud, zero native deps.",
   "type": "module",
   "bin": {