engramx 2.0.2 → 3.0.0

package/dist/cli.js

@@ -1,28 +1,38 @@
 #!/usr/bin/env node
 import {
   ESTIMATED_TOKENS_PER_READ_DENY,
-  formatHudStatus,
   formatStatsSummary,
-  getComponentStatus,
   summarizeHookLog
-} from "./chunk-533LR4I7.js";
-import {
-  readConfig
-} from "./chunk-22INHMKB.js";
+} from "./chunk-FKY6HIT2.js";
 import {
   logHookEvent,
   readHookLog
 } from "./chunk-KL6NSPVA.js";
+import {
+  formatInstallDiff,
+  installEngramHooks,
+  uninstallEngramHooks
+} from "./chunk-SMU4WR3D.js";
+import {
+  formatHudStatus,
+  getComponentStatus
+} from "./chunk-G4U3QOOW.js";
+import {
+  resolveRichPacket,
+  warmAllProviders
+} from "./chunk-RJC6RNXJ.js";
+import "./chunk-22INHMKB.js";
 import {
   autogen,
   install,
   status,
   uninstall
-} from "./chunk-C6GBUOAL.js";
+} from "./chunk-VLTWBTQ7.js";
 import {
   benchmark,
   computeKeywordIDF,
   extractFile,
+  formatThousands,
   getDbPath,
   getFileContext,
   getStore,
@@ -32,26 +42,25 @@ import {
   mistakes,
   path,
   query,
-  renderFileStructure,
   stats,
   toPosixPath
-} from "./chunk-SJT7VS2G.js";
-import "./chunk-PEH54LYC.js";
+} from "./chunk-B4UOE64J.js";
+import "./chunk-645NBY6L.js";
 
 // src/cli.ts
 import { Command } from "commander";
 import chalk2 from "chalk";
 import {
-  existsSync as existsSync9,
-  readFileSync as readFileSync5,
+  existsSync as existsSync7,
+  readFileSync as readFileSync4,
   writeFileSync as writeFileSync2,
   mkdirSync,
   unlinkSync,
   copyFileSync,
   renameSync as renameSync2
 } from "fs";
-import { dirname as dirname4, join as join9, resolve as pathResolve } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname3, join as join7, resolve as pathResolve2 } from "path";
+import { fileURLToPath } from "url";
 import { homedir } from "os";
 
 // src/intercept/safety.ts
@@ -356,1145 +365,6 @@ function buildSessionContextResponse(eventName, additionalContext) {
   };
 }
 
-// src/providers/types.ts
-var PROVIDER_PRIORITY = [
-  "engram:ast",
-  "engram:structure",
-  "engram:mistakes",
-  "mempalace",
-  "context7",
-  "engram:git",
-  "obsidian",
-  "engram:lsp"
-];
-var DEFAULT_CACHE_TTL_SEC = 3600;
-
-// src/providers/ast.ts
-import { readFileSync } from "fs";
-
-// src/providers/grammar-loader.ts
-import { existsSync as existsSync3 } from "fs";
-import { join as join3, dirname as dirname2 } from "path";
-import { createRequire } from "module";
-import { fileURLToPath } from "url";
-var require2 = createRequire(import.meta.url);
-var parserCache = /* @__PURE__ */ new Map();
-var tsParserInit = false;
-var EXT_TO_LANG = {
-  ts: "typescript",
-  tsx: "tsx",
-  js: "javascript",
-  jsx: "javascript",
-  mjs: "javascript",
-  cjs: "javascript",
-  py: "python",
-  go: "go",
-  rs: "rust",
-  rb: "ruby",
-  java: "java",
-  c: "c",
-  cpp: "cpp",
-  h: "c",
-  hpp: "cpp",
-  php: "php"
-};
-var LANG_TO_PKG = {
-  typescript: "tree-sitter-typescript",
-  tsx: "tree-sitter-typescript",
-  javascript: "tree-sitter-javascript",
-  python: "tree-sitter-python",
-  go: "tree-sitter-go",
-  rust: "tree-sitter-rust"
-};
-function getSupportedLang(filePath) {
-  const ext = filePath.split(".").pop()?.toLowerCase();
-  return ext ? EXT_TO_LANG[ext] ?? null : null;
-}
-function findGrammarWasm(lang) {
-  const pkg = LANG_TO_PKG[lang];
-  if (!pkg) return null;
-  const wasmName = lang === "tsx" ? "tree-sitter-tsx.wasm" : `tree-sitter-${lang}.wasm`;
-  const candidates = [];
-  try {
-    const here = dirname2(fileURLToPath(import.meta.url));
-    candidates.push(join3(here, "..", "grammars", wasmName));
-    candidates.push(join3(here, "grammars", wasmName));
-  } catch {
-  }
-  try {
-    const here = dirname2(fileURLToPath(import.meta.url));
-    candidates.push(join3(here, "..", "..", "node_modules", pkg, wasmName));
-  } catch {
-  }
-  try {
-    const pkgMain = require2.resolve(`${pkg}/package.json`);
-    const pkgDir = dirname2(pkgMain);
-    candidates.push(join3(pkgDir, wasmName));
-  } catch {
-  }
-  return candidates.find((c) => existsSync3(c)) ?? null;
-}
-async function getParser(lang) {
-  const cached = parserCache.get(lang);
-  if (cached) return cached;
-  try {
-    const { Parser, Language } = await import("web-tree-sitter");
-    if (!tsParserInit) {
-      await Parser.init();
-      tsParserInit = true;
-    }
-    const wasmPath = findGrammarWasm(lang);
-    if (!wasmPath) return null;
-    const language = await Language.load(wasmPath);
-    const parser = new Parser();
-    parser.setLanguage(language);
-    parserCache.set(lang, parser);
-    return parser;
-  } catch {
-    return null;
-  }
-}
-
-// src/providers/ast.ts
-function extractParams(node) {
-  const paramsNode = node.childForFieldName("parameters") ?? node.childForFieldName("formal_parameters");
-  if (!paramsNode) return "";
-  return paramsNode.text.replace(/\n/g, " ").replace(/\s+/g, " ").slice(0, 80).trim();
-}
-function extractSymbols(rootNode) {
-  const symbols = [];
-  function visit(node) {
-    switch (node.type) {
-      // ── Functions ───────────────────────────────────────────────
-      case "function_declaration":
-      case "function_definition": {
-        const nameNode = node.childForFieldName("name");
-        if (nameNode) {
-          symbols.push({
-            name: nameNode.text,
-            kind: "function",
-            line: node.startPosition.row + 1,
-            params: extractParams(node)
-          });
-        }
-        break;
-      }
-      // ── Classes ─────────────────────────────────────────────────
-      case "class_declaration":
-      case "class_definition": {
-        const nameNode = node.childForFieldName("name");
-        if (nameNode) {
-          symbols.push({
-            name: nameNode.text,
-            kind: "class",
-            line: node.startPosition.row + 1
-          });
-        }
-        break;
-      }
-      // ── Methods ─────────────────────────────────────────────────
-      case "method_definition":
-      case "method_declaration": {
-        const nameNode = node.childForFieldName("name");
-        if (nameNode) {
-          symbols.push({
-            name: nameNode.text,
-            kind: "method",
-            line: node.startPosition.row + 1,
-            params: extractParams(node)
-          });
-        }
-        break;
-      }
-      // ── TypeScript interfaces ────────────────────────────────────
-      case "interface_declaration": {
-        const nameNode = node.childForFieldName("name");
-        if (nameNode) {
-          symbols.push({
-            name: nameNode.text,
-            kind: "interface",
-            line: node.startPosition.row + 1
-          });
-        }
-        break;
-      }
-      // ── TypeScript type aliases ──────────────────────────────────
-      case "type_alias_declaration": {
-        const nameNode = node.childForFieldName("name");
-        if (nameNode) {
-          symbols.push({
-            name: nameNode.text,
-            kind: "type",
-            line: node.startPosition.row + 1
-          });
-        }
-        break;
-      }
-      // ── Exported variable declarations (incl. arrow functions) ──
-      case "lexical_declaration":
-      case "variable_declaration": {
-        for (let i = 0; i < node.childCount; i++) {
-          const child = node.child(i);
-          if (!child || child.type !== "variable_declarator") continue;
-          const nameNode = child.childForFieldName("name");
-          const valueNode = child.childForFieldName("value");
-          if (!nameNode) continue;
-          const isArrow = valueNode?.type === "arrow_function" || valueNode?.type === "function";
-          symbols.push({
-            name: nameNode.text,
-            kind: isArrow ? "function" : "variable",
-            line: node.startPosition.row + 1,
-            params: isArrow && valueNode ? extractParams(valueNode) : void 0
-          });
-        }
-        break;
-      }
-      default:
-        break;
-    }
-    for (let i = 0; i < node.childCount; i++) {
-      const child = node.child(i);
-      if (child) visit(child);
-    }
-  }
-  visit(rootNode);
-  return symbols;
-}
-function formatSymbols(symbols, tokenBudget) {
-  const lines = symbols.map((s) => {
-    const params = s.params !== void 0 ? `(${s.params})` : "";
-    return `${s.kind.toUpperCase()} ${s.name}${params} L${s.line}`;
-  });
-  const charBudget = tokenBudget * 4;
-  let text = lines.join("\n");
-  if (text.length > charBudget) {
-    text = text.slice(0, charBudget).trimEnd() + "\n... (truncated)";
-  }
-  return text;
-}
-var astProvider = {
-  name: "engram:ast",
-  label: "AST STRUCTURE",
-  tier: 1,
-  tokenBudget: 300,
-  timeoutMs: 200,
-  async resolve(filePath, _context) {
-    const lang = getSupportedLang(filePath);
-    if (!lang) return null;
-    const parser = await getParser(lang);
-    if (!parser) return null;
-    try {
-      const source = readFileSync(filePath, "utf-8");
-      const tree = parser.parse(source);
-      if (!tree) return null;
-      const symbols = extractSymbols(tree.rootNode);
-      if (symbols.length === 0) return null;
-      return {
-        provider: "engram:ast",
-        content: formatSymbols(symbols, this.tokenBudget),
-        confidence: 1,
-        cached: false
-      };
-    } catch {
-      return null;
-    }
-  },
-  async isAvailable() {
-    try {
-      const { Parser } = await import("web-tree-sitter");
-      await Parser.init();
-      return true;
-    } catch {
-      return false;
-    }
-  }
-};
-
-// src/providers/engram-structure.ts
-var structureProvider = {
-  name: "engram:structure",
-  label: "STRUCTURE",
-  tier: 1,
-  tokenBudget: 250,
-  timeoutMs: 500,
-  async resolve(filePath, context) {
-    try {
-      const store = await getStore(context.projectRoot);
-      try {
-        const result = renderFileStructure(store, filePath);
-        if (!result || result.nodeCount === 0) return null;
-        return {
-          provider: "engram:structure",
-          content: result.text,
-          confidence: result.avgConfidence,
-          cached: false
-        };
-      } finally {
-        store.close();
-      }
-    } catch {
-      return null;
-    }
-  },
-  async isAvailable() {
-    return true;
-  }
-};
-
-// src/providers/engram-mistakes.ts
-var mistakesProvider = {
-  name: "engram:mistakes",
-  label: "KNOWN ISSUES",
-  tier: 1,
-  tokenBudget: 50,
-  timeoutMs: 200,
-  async resolve(filePath, context) {
-    try {
-      const store = await getStore(context.projectRoot);
-      try {
-        const allMistakes = store.getNodesByFile(filePath).filter((n) => n.kind === "mistake");
-        if (allMistakes.length === 0) return null;
-        const lines = allMistakes.slice(0, 5).map((m) => `  ! ${m.label} (flagged ${formatAge(m.lastVerified)})`).join("\n");
-        return {
-          provider: "engram:mistakes",
-          content: lines,
-          confidence: 0.95,
-          cached: false
-        };
-      } finally {
-        store.close();
-      }
-    } catch {
-      return null;
-    }
-  },
-  async isAvailable() {
-    return true;
-  }
-};
-function formatAge(timestampMs) {
-  if (timestampMs === 0) return "unknown";
-  const days = Math.floor((Date.now() - timestampMs) / (1e3 * 60 * 60 * 24));
-  if (days === 0) return "today";
-  if (days === 1) return "yesterday";
-  if (days < 30) return `${days}d ago`;
-  return `${Math.floor(days / 30)}mo ago`;
-}
-
-// src/providers/engram-git.ts
-import { execFileSync } from "child_process";
-var gitProvider = {
-  name: "engram:git",
-  label: "CHANGES",
-  tier: 1,
-  tokenBudget: 50,
-  timeoutMs: 200,
-  async resolve(filePath, context) {
-    try {
-      const cwd = context.projectRoot;
-      const lastLog = git(
-        ["log", "-1", "--format=%ar|%an|%s", "--", filePath],
-        cwd
-      );
-      if (!lastLog) return null;
-      const [timeAgo, author, message] = lastLog.split("|", 3);
-      const recentCount = git(
-        [
-          "rev-list",
-          "--count",
-          "--since=30.days",
-          "HEAD",
-          "--",
-          filePath
-        ],
-        cwd
-      );
-      const churnNote = context.churnRate > 0.3 ? "high churn" : context.churnRate > 0.1 ? "moderate" : "stable";
-      const parts = [
-        `  Last modified: ${timeAgo} by ${author} (${truncate(message, 50)})`,
-        `  Churn: ${context.churnRate.toFixed(2)} (${churnNote}) | ${recentCount || "0"} changes in 30d`
-      ];
-      return {
-        provider: "engram:git",
-        content: parts.join("\n"),
-        confidence: 0.9,
-        cached: false
-      };
-    } catch {
-      return null;
-    }
-  },
-  async isAvailable() {
-    try {
-      execFileSync("git", ["--version"], {
-        encoding: "utf-8",
-        timeout: 2e3
-      });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-};
-function git(args, cwd) {
-  try {
-    return execFileSync("git", args, {
-      cwd,
-      encoding: "utf-8",
-      timeout: 3e3,
-      maxBuffer: 1024 * 1024
-    }).trim();
-  } catch {
-    return "";
-  }
-}
-function truncate(s, max) {
-  return s.length <= max ? s : s.slice(0, max - 1) + "\u2026";
-}
-
-// src/providers/mempalace.ts
-import { execFile } from "child_process";
-var MAX_SEARCH_RESULTS = 3;
-var mempalaceProvider = {
-  name: "mempalace",
-  label: "DECISIONS",
-  tier: 2,
-  tokenBudget: 100,
-  timeoutMs: 200,
-  async resolve(filePath, context) {
-    try {
-      const store = await getStore(context.projectRoot);
-      try {
-        const cached = store.getCachedContextForProvider(
-          "mempalace",
-          filePath
-        );
-        if (cached) {
-          return {
-            provider: "mempalace",
-            content: cached.content,
-            confidence: 0.8,
-            cached: true
-          };
-        }
-      } finally {
-        store.close();
-      }
-      const query2 = buildQuery(filePath, context);
-      const raw = await searchMempalace(query2);
-      if (!raw) return null;
-      const content = formatResults(raw);
-      if (!content) return null;
-      const store2 = await getStore(context.projectRoot);
-      try {
-        store2.setCachedContext(
-          "mempalace",
-          filePath,
-          content,
-          DEFAULT_CACHE_TTL_SEC,
-          query2
-        );
-        store2.save();
-      } finally {
-        store2.close();
-      }
-      return {
-        provider: "mempalace",
-        content,
-        confidence: 0.8,
-        cached: false
-      };
-    } catch {
-      return null;
-    }
-  },
-  async warmup(projectRoot) {
-    const start = Date.now();
-    const entries = [];
-    try {
-      const store = await getStore(projectRoot);
-      let projectName;
-      try {
-        projectName = store.getStat("project_name") ?? projectRoot.split("/").pop() ?? "";
-      } finally {
-        store.close();
-      }
-      if (!projectName) {
-        return { provider: "mempalace", entries, durationMs: Date.now() - start };
-      }
-      const raw = await searchMempalace(
-        `${projectName} decisions architecture patterns`
-      );
-      if (!raw) {
-        return { provider: "mempalace", entries, durationMs: Date.now() - start };
-      }
-      const content = formatResults(raw);
-      if (content) {
-        entries.push({ filePath: "__project__", content });
-      }
-    } catch {
-    }
-    return { provider: "mempalace", entries, durationMs: Date.now() - start };
-  },
-  async isAvailable() {
-    try {
-      const result = await execFilePromise("mcp-mempalace", [
-        "mempalace-status"
-      ]);
-      return result.includes("palace") || result.includes("drawers");
-    } catch {
-      return false;
-    }
-  }
-};
-function buildQuery(filePath, context) {
-  const fileName = filePath.split("/").pop()?.replace(/\.\w+$/, "") ?? "";
-  const importTerms = context.imports.slice(0, 3).join(" ");
-  return `${fileName} ${importTerms}`.trim();
-}
-function searchMempalace(query2) {
-  return new Promise((resolve7) => {
-    const timeout = setTimeout(() => resolve7(null), 3e3);
-    execFile(
-      "mcp-mempalace",
-      ["mempalace-search", "--query", query2],
-      { encoding: "utf-8", timeout: 3e3, maxBuffer: 1024 * 1024 },
-      (err, stdout) => {
-        clearTimeout(timeout);
-        if (err || !stdout.trim()) {
-          resolve7(null);
-          return;
-        }
-        resolve7(stdout.trim());
-      }
-    );
-  });
-}
-function formatResults(raw) {
-  try {
-    const parsed = JSON.parse(raw);
-    const results = Array.isArray(parsed) ? parsed : parsed?.results ?? parsed?.drawers ?? [];
-    if (results.length === 0) return null;
-    const lines = results.slice(0, MAX_SEARCH_RESULTS).map((r) => {
-      const content = r.content ?? r.text ?? r.summary ?? "";
-      const truncated = content.split(/\s+/).slice(0, 30).join(" ");
-      return `  - ${truncated}`;
-    }).filter((l) => l.length > 4);
-    return lines.length > 0 ? lines.join("\n") : null;
-  } catch {
-    const lines = raw.split("\n").filter((l) => l.trim()).slice(0, MAX_SEARCH_RESULTS).map((l) => `  - ${l.trim().slice(0, 120)}`);
-    return lines.length > 0 ? lines.join("\n") : null;
-  }
-}
-function execFilePromise(cmd, args) {
-  return new Promise((resolve7, reject) => {
-    execFile(
-      cmd,
-      args,
-      { encoding: "utf-8", timeout: 3e3 },
-      (err, stdout) => {
-        if (err) reject(err);
-        else resolve7(stdout.trim());
-      }
-    );
-  });
-}
-
-// src/providers/context7.ts
-import { execFile as execFile2 } from "child_process";
-var LIBRARY_CACHE_TTL = 4 * 3600;
-var context7Provider = {
-  name: "context7",
-  label: "LIBRARY",
-  tier: 2,
-  tokenBudget: 100,
-  timeoutMs: 200,
-  async resolve(filePath, context) {
-    if (context.imports.length === 0) return null;
-    try {
-      const store = await getStore(context.projectRoot);
-      try {
-        const cached = store.getCachedContextForProvider("context7", filePath);
-        if (cached) {
-          return {
-            provider: "context7",
-            content: cached.content,
-            confidence: 0.85,
-            cached: true
-          };
-        }
-      } finally {
-        store.close();
-      }
-      const primaryImport = context.imports[0];
-      const docs = await queryContext7(primaryImport);
-      if (!docs) return null;
-      const content = formatDocs(primaryImport, docs);
-      if (!content) return null;
-      const store2 = await getStore(context.projectRoot);
-      try {
-        store2.setCachedContext(
-          "context7",
-          filePath,
-          content,
-          LIBRARY_CACHE_TTL,
-          primaryImport
-        );
-        store2.save();
-      } finally {
-        store2.close();
-      }
-      return {
-        provider: "context7",
-        content,
-        confidence: 0.85,
-        cached: false
-      };
-    } catch {
-      return null;
-    }
-  },
-  async warmup(projectRoot) {
-    const start = Date.now();
-    const entries = [];
-    try {
-      const store = await getStore(projectRoot);
-      let importEdges;
-      try {
-        const allEdges = store.getAllEdges();
-        importEdges = allEdges.filter((e) => e.relation === "imports").map((e) => ({ source: e.sourceFile, target: e.target }));
-      } finally {
-        store.close();
-      }
-      const packages = [
-        ...new Set(
-          importEdges.map((e) => {
-            const parts = e.target.split("::");
-            return parts[parts.length - 1];
-          }).filter(isExternalPackage)
-        )
-      ].slice(0, 10);
-      for (const pkg of packages) {
-        const docs = await queryContext7(pkg);
-        if (docs) {
-          const content = formatDocs(pkg, docs);
-          if (content) {
-            const files = importEdges.filter((e) => e.target.includes(pkg)).map((e) => e.source);
-            for (const file of [...new Set(files)]) {
-              entries.push({ filePath: file, content });
-            }
-          }
-        }
-      }
-    } catch {
-    }
-    return { provider: "context7", entries, durationMs: Date.now() - start };
-  },
-  async isAvailable() {
-    try {
-      const result = await execFilePromise2("mcp-context7", ["--list"]);
-      return result.includes("resolve-library-id");
-    } catch {
-      return false;
-    }
-  }
-};
-function isExternalPackage(name) {
-  if (!name) return false;
-  if (name.startsWith(".") || name.startsWith("/")) return false;
-  if ([
-    "fs",
-    "path",
-    "os",
-    "url",
-    "http",
-    "https",
-    "crypto",
-    "stream",
-    "util",
-    "events",
-    "child_process",
-    "node:fs",
-    "node:path",
-    "node:os",
-    "node:url",
-    "node:http",
-    "node:https",
-    "node:crypto",
-    "node:stream",
-    "node:util",
-    "node:events",
-    "node:child_process"
-  ].includes(name))
-    return false;
-  return true;
-}
-function queryContext7(packageName) {
-  return new Promise((resolve7) => {
-    const timeout = setTimeout(() => resolve7(null), 5e3);
-    execFile2(
-      "mcp-context7",
-      [
-        "query-docs",
-        "--context7CompatibleLibraryID",
-        packageName,
-        "--topic",
-        "API reference quick start"
-      ],
-      { encoding: "utf-8", timeout: 5e3, maxBuffer: 2 * 1024 * 1024 },
-      (err, stdout) => {
-        clearTimeout(timeout);
-        if (err || !stdout.trim()) {
-          resolve7(null);
-          return;
-        }
-        resolve7(stdout.trim());
-      }
-    );
-  });
-}
-function formatDocs(pkg, raw) {
-  const truncated = raw.slice(0, 400);
-  const lines = truncated.split("\n").filter((l) => l.trim()).slice(0, 5).map((l) => `  ${l.trim()}`);
-  if (lines.length === 0) return null;
-  return `  ${pkg}:
-${lines.join("\n")}`;
-}
-function execFilePromise2(cmd, args) {
-  return new Promise((resolve7, reject) => {
-    execFile2(
-      cmd,
-      args,
-      { encoding: "utf-8", timeout: 3e3 },
-      (err, stdout) => {
-        if (err) reject(err);
-        else resolve7(stdout.trim());
-      }
-    );
-  });
-}
-
-// src/providers/obsidian.ts
-var OBSIDIAN_PORT = 27124;
-var OBSIDIAN_BASE = `http://127.0.0.1:${OBSIDIAN_PORT}`;
-var obsidianProvider = {
-  name: "obsidian",
-  label: "PROJECT NOTES",
-  tier: 2,
-  tokenBudget: 50,
-  timeoutMs: 200,
-  async resolve(filePath, context) {
-    try {
-      const store = await getStore(context.projectRoot);
-      try {
-        const cached = store.getCachedContextForProvider("obsidian", filePath);
-        if (cached) {
-          return {
-            provider: "obsidian",
-            content: cached.content,
-            confidence: 0.7,
-            cached: true
-          };
-        }
-      } finally {
-        store.close();
-      }
-      const projectName = context.projectRoot.split("/").pop() ?? "";
-      const fileName = filePath.split("/").pop()?.replace(/\.\w+$/, "") ?? "";
-      const query2 = `${projectName} ${fileName}`;
-      const results = await searchObsidian(query2);
-      if (!results) return null;
-      const content = formatResults2(results);
-      if (!content) return null;
-      const store2 = await getStore(context.projectRoot);
-      try {
-        store2.setCachedContext(
-          "obsidian",
-          filePath,
-          content,
-          DEFAULT_CACHE_TTL_SEC,
-          query2
-        );
-        store2.save();
-      } finally {
-        store2.close();
-      }
-      return {
-        provider: "obsidian",
-        content,
-        confidence: 0.7,
-        cached: false
-      };
-    } catch {
-      return null;
-    }
-  },
-  async warmup(projectRoot) {
-    const start = Date.now();
-    const entries = [];
-    try {
-      const projectName = projectRoot.split("/").pop() ?? "";
-      if (!projectName) {
-        return { provider: "obsidian", entries, durationMs: Date.now() - start };
-      }
-      const results = await searchObsidian(
-        `${projectName} architecture design decisions`
-      );
-      if (results) {
-        const content = formatResults2(results);
-        if (content) {
-          entries.push({ filePath: "__project__", content });
-        }
-      }
-    } catch {
-    }
-    return { provider: "obsidian", entries, durationMs: Date.now() - start };
-  },
-  async isAvailable() {
-    try {
-      const response = await fetchWithTimeout(
-        `${OBSIDIAN_BASE}/`,
-        1e3
-      );
-      return response.ok;
-    } catch {
-      return false;
-    }
-  }
-};
-async function searchObsidian(query2) {
-  try {
-    const response = await fetchWithTimeout(
-      `${OBSIDIAN_BASE}/search/simple/?query=${encodeURIComponent(query2)}`,
-      2e3
-    );
-    if (!response.ok) return null;
-    const data = await response.json();
-    if (!Array.isArray(data) || data.length === 0) return null;
-    return data.slice(0, 3);
-  } catch {
-    return null;
-  }
-}
-function formatResults2(results) {
-  if (results.length === 0) return null;
-  const lines = results.slice(0, 3).map((r) => {
-    const name = r.filename.replace(/\.md$/, "");
-    return `  Related: ${name}`;
-  });
-  return lines.join("\n");
-}
-async function fetchWithTimeout(url, timeoutMs) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    return await fetch(url, { signal: controller.signal });
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-// src/providers/lsp-connection.ts
-import { connect } from "net";
-import { existsSync as existsSync4 } from "fs";
-import { tmpdir } from "os";
-import { join as join4 } from "path";
-function candidateSockets() {
-  const uid = process.getuid?.() ?? 0;
-  const tmp = tmpdir();
-  return [
-    // TypeScript language server (used by VS Code)
-    join4(tmp, `tsserver-${uid}.sock`),
-    // Generic LSP socket (some editors, e.g. Helix)
-    join4(tmp, "lsp-server.sock"),
-    // TypeScript language server alternate path
-    join4(tmp, "typescript-language-server.sock"),
-    // Pyright (Python)
-    join4(tmp, `pyright-${uid}.sock`),
-    // rust-analyzer
-    join4(tmp, "rust-analyzer.sock")
-  ];
-}
-var LspConnection = class _LspConnection {
-  socket = null;
-  _requestId = 0;
-  /**
-   * Attempt to connect to any currently-running LSP server socket.
-   * Returns null — not throws — if no socket is found or connection fails.
-   * Timeout per candidate: 500ms.
-   */
-  static async tryConnect() {
-    const candidates = candidateSockets().filter((p) => existsSync4(p));
-    if (candidates.length === 0) return null;
-    for (const path2 of candidates) {
-      try {
-        const conn = new _LspConnection();
-        await conn._connect(path2);
-        return conn;
-      } catch {
-        continue;
-      }
-    }
-    return null;
-  }
-  /** Internal: open a socket to the given path with a 500ms timeout. */
-  _connect(socketPath) {
-    return new Promise((resolve7, reject) => {
-      const socket = connect(socketPath);
-      const timeout = setTimeout(() => {
-        socket.destroy();
-        reject(new Error("LSP connect timeout"));
-      }, 500);
-      socket.on("connect", () => {
-        clearTimeout(timeout);
-        this.socket = socket;
-        resolve7();
-      });
-      socket.on("error", (err) => {
-        clearTimeout(timeout);
-        reject(err);
-      });
-    });
-  }
-  /**
-   * Request hover info for a position.
-   *
-   * Stub: returns null. A full implementation would send a JSON-RPC
-   * textDocument/hover request and parse the response. Left as a stub
-   * because the response requires a request/response correlation loop
-   * over a streaming socket — non-trivial, and out of scope for v0.5.x.
-   * The provider benefits from the availability check alone.
-   */
-  async hover(_filePath, _line, _character) {
-    if (!this.socket) return null;
-    return null;
-  }
-  /**
-   * Fetch diagnostics for a file.
-   *
-   * Stub: returns []. A full implementation would use the
-   * textDocument/diagnostic pull request (LSP 3.17+) or subscribe to
-   * publishDiagnostics push notifications. Deferred to a future sprint.
-   */
-  async getDiagnostics(_filePath) {
-    if (!this.socket) return [];
-    return [];
-  }
-  /** Whether this connection has a live socket. */
-  get connected() {
-    return this.socket !== null && !this.socket.destroyed;
-  }
-  /** Close and destroy the socket. Safe to call multiple times. */
-  close() {
-    this.socket?.destroy();
-    this.socket = null;
-  }
-};
-
-// src/providers/lsp.ts
-var cachedConnection = void 0;
-async function getConnection() {
-  if (cachedConnection instanceof LspConnection) {
-    if (cachedConnection.connected) return cachedConnection;
-    cachedConnection.close();
-    cachedConnection = void 0;
-  }
-  if (cachedConnection === null) return null;
-  cachedConnection = await LspConnection.tryConnect();
-  return cachedConnection;
-}
-var lspProvider = {
-  name: "engram:lsp",
-  label: "LSP CONTEXT",
-  tier: 1,
-  tokenBudget: 100,
-  timeoutMs: 100,
-  async resolve(filePath, _context) {
-    try {
-      const conn = await getConnection();
-      if (!conn) return null;
-      const hover = await conn.hover(filePath, 0, 0);
-      if (!hover?.contents) return null;
-      const content = typeof hover.contents === "string" ? hover.contents : JSON.stringify(hover.contents);
-      const charBudget = this.tokenBudget * 4;
-      const truncated = content.length > charBudget ? content.slice(0, charBudget) + "..." : content;
-      return {
-        provider: "engram:lsp",
-        content: truncated,
-        confidence: 0.95,
-        cached: false
-      };
-    } catch {
-      return null;
-    }
-  },
-  async isAvailable() {
-    try {
-      const conn = await getConnection();
-      return conn !== null;
-    } catch {
-      return false;
-    }
-  }
-};
-
-// src/providers/resolver.ts
-var BUILTIN_PROVIDERS = [
-  astProvider,
-  structureProvider,
-  mistakesProvider,
-  gitProvider,
-  mempalaceProvider,
-  context7Provider,
-  obsidianProvider,
-  lspProvider
-];
-var BUILTIN_NAMES = new Set(BUILTIN_PROVIDERS.map((p) => p.name));
-async function getAllProviders() {
-  const { getLoadedPlugins } = await import("./plugin-loader-STTGYIL5.js");
-  const { loaded } = await getLoadedPlugins();
-  const safePlugins = loaded.filter((p) => !BUILTIN_NAMES.has(p.name));
-  return [...BUILTIN_PROVIDERS, ...safePlugins];
-}
-var ALL_PROVIDERS = BUILTIN_PROVIDERS;
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-async function resolveRichPacket(filePath, context, enabledProviders) {
-  const start = Date.now();
-  let allProviders;
-  try {
-    allProviders = await getAllProviders();
-  } catch {
-    allProviders = BUILTIN_PROVIDERS;
-  }
-  const providers = allProviders.filter((p) => {
-    if (enabledProviders && !enabledProviders.includes(p.name)) return false;
-    return true;
-  });
-  const available = await filterAvailable(providers);
-  if (available.length === 0) return null;
-  const settled = await Promise.allSettled(
-    available.map((p) => resolveWithTimeout(p, filePath, context))
-  );
-  const results = [];
-  for (const outcome of settled) {
-    if (outcome.status === "fulfilled" && outcome.value) {
-      results.push(outcome.value);
-    }
-  }
-  if (results.length === 0) return null;
-  const hasAst = results.some((r) => r.provider === "engram:ast");
-  const deduped = hasAst ? results.filter((r) => r.provider !== "engram:structure") : results;
-  const sorted = deduped.sort((a, b) => {
-    const aIdx = PROVIDER_PRIORITY.indexOf(a.provider);
-    const bIdx = PROVIDER_PRIORITY.indexOf(b.provider);
-    return (aIdx === -1 ? 99 : aIdx) - (bIdx === -1 ? 99 : bIdx);
-  });
-  const config = readConfig(context.projectRoot);
-  const budget = config.totalTokenBudget;
-  const sections = [];
-  let totalTokens = 0;
-  for (const result of sorted) {
-    const sectionTokens = estimateTokens(result.content);
-    if (totalTokens + sectionTokens > budget) {
-      break;
-    }
-    const provider = allProviders.find((p) => p.name === result.provider);
-    const label = provider?.label ?? result.provider.toUpperCase();
-    const cacheTag = result.cached ? ", cached" : "";
-    sections.push(`${label} (${result.provider}${cacheTag}):
-${result.content}`);
-    totalTokens += sectionTokens;
-  }
-  if (sections.length === 0) return null;
-  const providerNames = sorted.filter((_, i) => i < sections.length).map((r) => r.provider);
-  const isEnrichment = enabledProviders && !enabledProviders.includes("engram:structure");
-  const header = isEnrichment ? `[engram] Additional context (${providerNames.length} providers, ~${totalTokens} tokens)` : `[engram] Rich context for ${filePath} (${providerNames.length} providers, ~${totalTokens} tokens)`;
-  const text = `${header}
-
-${sections.join("\n\n")}`;
-  return {
-    text,
-    providerCount: providerNames.length,
-    providers: providerNames,
-    estimatedTokens: totalTokens + estimateTokens(header),
-    durationMs: Date.now() - start
-  };
-}
-async function warmAllProviders(projectRoot, enabledProviders) {
-  const start = Date.now();
-  const warmed = [];
-  const tier2 = ALL_PROVIDERS.filter(
-    (p) => p.tier === 2 && p.warmup && (!enabledProviders || enabledProviders.includes(p.name))
-  );
-  const available = await filterAvailable(tier2);
-  const settled = await Promise.allSettled(
-    available.map(async (p) => {
-      try {
-        const result = await withTimeout2(p.warmup(projectRoot), 5e3);
-        if (result && result.entries.length > 0) {
-          const { getStore: getStore2 } = await import("./core-6IY5L6II.js");
-          const store = await getStore2(projectRoot);
-          try {
-            store.warmCache(
-              result.provider,
-              [...result.entries],
-              result.provider === "context7" ? 4 * 3600 : 3600
-            );
-            store.save();
-          } finally {
-            store.close();
-          }
-          warmed.push(p.name);
-        }
-      } catch {
-      }
-    })
-  );
-  return { warmed, durationMs: Date.now() - start };
-}
-var availabilityCache = /* @__PURE__ */ new Map();
-async function filterAvailable(providers) {
-  const checks = providers.map(async (p) => {
-    let available = availabilityCache.get(p.name);
-    if (available === void 0) {
-      try {
-        const timeout = p.tier === 1 ? 200 : 500;
-        available = await withTimeout2(p.isAvailable(), timeout);
-      } catch {
-        available = false;
-      }
-      availabilityCache.set(p.name, available);
-    }
-    return { provider: p, available };
-  });
-  const settled = await Promise.all(checks);
-  return settled.filter((c) => c.available).map((c) => c.provider);
-}
-async function resolveWithTimeout(provider, filePath, context) {
-  try {
-    return await withTimeout2(
-      provider.resolve(filePath, context),
-      provider.timeoutMs
-    );
-  } catch {
-    return null;
-  }
-}
-function withTimeout2(promise, ms) {
-  return new Promise((resolve7, reject) => {
-    const timer = setTimeout(() => reject(new Error("timeout")), ms);
-    promise.then((val) => {
-      clearTimeout(timer);
-      resolve7(val);
-    }).catch((err) => {
-      clearTimeout(timer);
-      reject(err);
-    });
-  });
-}
-
 // src/intercept/handlers/read.ts
 var READ_CONFIDENCE_THRESHOLD = 0.7;
 async function handleRead(payload) {
@@ -1670,27 +540,175 @@ async function handleBash(payload) {
   });
 }
 
+// src/intercept/handlers/mistake-guard.ts
+import { relative as relative3 } from "path";
+function currentGuardMode() {
+  const raw = process.env.ENGRAM_MISTAKE_GUARD;
+  if (raw === "1") return "permissive";
+  if (raw === "2") return "strict";
+  return "off";
+}
+function extractTargetResource(kind, toolInput) {
+  if (!toolInput) return null;
+  if (kind === "edit-write") {
+    const fp = toolInput.file_path;
+    if (typeof fp !== "string" || fp.length === 0) return null;
+    return { kind: "file", filePath: fp };
+  }
+  if (kind === "bash") {
+    const cmd = toolInput.command;
+    if (typeof cmd !== "string" || cmd.length === 0) return null;
+    return { kind: "command", command: cmd };
+  }
+  return null;
+}
+async function findMatchingMistakesAsync(target, projectRoot) {
+  if (!target) return [];
+  const now = Date.now();
+  try {
+    const store = await getStore(projectRoot);
+    try {
+      const matches = [];
+      if (target.kind === "file") {
+        let normalized = target.filePath;
+        try {
+          const rel = relative3(projectRoot, target.filePath);
+          if (rel && !rel.startsWith("..")) {
+            normalized = rel.split(/[\\/]/).join("/");
+          }
+        } catch {
+        }
+        const candidates = [
+          ...store.getNodesByFile(normalized),
+          ...normalized === target.filePath ? [] : store.getNodesByFile(target.filePath)
+        ];
+        const seenIds = /* @__PURE__ */ new Set();
+        for (const m of candidates) {
+          if (seenIds.has(m.id)) continue;
+          seenIds.add(m.id);
+          if (m.kind !== "mistake") continue;
+          if (m.validUntil !== void 0 && m.validUntil <= now) continue;
+          matches.push({
+            label: m.label,
+            sourceFile: m.sourceFile,
+            ageMs: now - m.lastVerified
+          });
+        }
+      } else {
+        const allMistakes = store.getAllNodes().filter((n) => n.kind === "mistake").filter((n) => n.validUntil === void 0 || n.validUntil > now);
+        if (allMistakes.length === 0) return [];
+        const command = target.command.toLowerCase();
+        for (const m of allMistakes) {
+          const pattern = m.metadata?.commandPattern;
+          const patternStr = typeof pattern === "string" ? pattern.toLowerCase() : "";
+          const fileStr = m.sourceFile.toLowerCase();
+          if (patternStr && patternStr.length > 2 && command.includes(patternStr)) {
+            matches.push({
+              label: m.label,
+              sourceFile: m.sourceFile,
+              ageMs: now - m.lastVerified
+            });
+          } else if (fileStr && fileStr.length > 3 && command.includes(fileStr)) {
+            matches.push({
+              label: m.label,
+              sourceFile: m.sourceFile,
+              ageMs: now - m.lastVerified
+            });
+          }
+        }
+      }
+      return matches;
+    } finally {
+      store.close();
+    }
+  } catch {
+    return [];
+  }
+}
+function formatAge(ms) {
+  if (ms < 0) return "unknown";
+  const days = Math.floor(ms / (1e3 * 60 * 60 * 24));
+  if (days === 0) return "today";
+  if (days === 1) return "yesterday";
+  if (days < 30) return `${days}d ago`;
+  return `${Math.floor(days / 30)}mo ago`;
+}
+function formatWarning(matches) {
+  if (matches.length === 0) return "";
+  const lines = matches.slice(0, 5).map((m) => `  \u26A0 ${m.label} (flagged ${formatAge(m.ageMs)}, file: ${m.sourceFile})`);
+  const more = matches.length > 5 ? `
+  \u2026 and ${matches.length - 5} more` : "";
+  return [
+    "\u26D4 engramx pre-mortem \u2014 this target has recurred as a mistake before:",
+    ...lines,
+    more
+  ].filter((s) => s.length > 0).join("\n");
+}
+async function applyMistakeGuard(rawResult, payload, kind) {
+  const mode = currentGuardMode();
+  if (mode === "off") return rawResult;
+  try {
+    const cwd = typeof payload.cwd === "string" ? payload.cwd : "";
+    const projectRoot = findProjectRoot(cwd);
+    if (!projectRoot) return rawResult;
+    const toolInput = payload.tool_input && typeof payload.tool_input === "object" ? payload.tool_input : void 0;
+    const target = extractTargetResource(kind, toolInput);
+    const matches = await findMatchingMistakesAsync(target, projectRoot);
+    if (matches.length === 0) return rawResult;
+    const warning = formatWarning(matches);
+    if (mode === "strict") {
+      return buildDenyResponse(warning);
+    }
+    if (rawResult && typeof rawResult === "object") {
+      const res = rawResult;
+      const hso = res.hookSpecificOutput && typeof res.hookSpecificOutput === "object" ? res.hookSpecificOutput : void 0;
+      const existingContext = typeof hso?.additionalContext === "string" ? hso.additionalContext : "";
+      const merged = existingContext ? `${warning}
+
+${existingContext}` : warning;
+      return {
+        ...res,
+        hookSpecificOutput: {
+          ...hso ?? {},
+          hookEventName: "PreToolUse",
+          permissionDecision: typeof hso?.permissionDecision === "string" ? hso.permissionDecision : "allow",
+          additionalContext: merged
+        }
+      };
+    }
+    return {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "allow",
+        additionalContext: warning
+      }
+    };
+  } catch {
+    return rawResult;
+  }
+}
+
 // src/intercept/handlers/session-start.ts
-import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
-import { execFile as execFile3 } from "child_process";
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { execFile } from "child_process";
 import { promisify } from "util";
-import { basename, dirname as dirname3, join as join5, resolve as resolve2 } from "path";
-var execFileAsync = promisify(execFile3);
+import { basename, dirname as dirname2, join as join3, resolve as resolve2 } from "path";
+var execFileAsync = promisify(execFile);
 var MAX_GOD_NODES = 10;
 var MAX_LANDMINES_IN_BRIEF = 3;
 function readGitBranch(projectRoot) {
   try {
     let current = resolve2(projectRoot);
     for (let depth = 0; depth < 10; depth++) {
-      const headPath = join5(current, ".git", "HEAD");
-      if (existsSync5(headPath)) {
-        const content = readFileSync2(headPath, "utf-8").trim();
+      const headPath = join3(current, ".git", "HEAD");
+      if (existsSync3(headPath)) {
+        const content = readFileSync(headPath, "utf-8").trim();
         const refMatch = content.match(/^ref:\s+refs\/heads\/(.+)$/);
         if (refMatch) return refMatch[1];
         if (/^[0-9a-f]{7,40}$/i.test(content)) return "detached";
         return null;
       }
-      const parent = dirname3(current);
+      const parent = dirname2(current);
       if (parent === current) return null;
       current = parent;
     }
@@ -1969,6 +987,219 @@ ${result.text}`;
   return buildSessionContextResponse("UserPromptSubmit", text);
 }
 
+// src/intercept/handlers/bash-postool.ts
+import { isAbsolute as isAbsolute2, resolve as pathResolve } from "path";
+var MAX_COMMAND_LEN = 500;
+var BASIC_UNSAFE = /[|&;()$`*?[\]{}"']/;
+var SUBSHELL = /\$\(|`|<\(|>\(/;
+function parseFileOps(command, cwd) {
+  if (!command || typeof command !== "string") return [];
+  if (command.length > MAX_COMMAND_LEN) return [];
+  if (SUBSHELL.test(command)) return [];
+  const trimmed = command.trim();
+  if (!trimmed) return [];
+  const redirectMatch = /\s+(>>?)\s+(\S+)\s*$/.exec(trimmed);
+  if (redirectMatch) {
+    const head = trimmed.slice(0, redirectMatch.index);
+    const dest = redirectMatch[2];
+    if (BASIC_UNSAFE.test(head)) return [];
+    if (dest.startsWith("-") || dest.length === 0) return [];
+    return [{ action: "reindex", path: absolutize(dest, cwd) }];
+  }
+  if (BASIC_UNSAFE.test(trimmed)) return [];
+  const tokens = trimmed.split(/\s+/);
+  if (tokens.length === 0) return [];
+  const first = tokens[0];
+  if (first === "git" && tokens.length >= 3) {
+    const sub = tokens[1];
+    if (sub === "rm") return parseRm(tokens.slice(2), cwd);
+    if (sub === "mv") return parseMv(tokens.slice(2), cwd);
+    return [];
+  }
+  if (first === "rm") return parseRm(tokens.slice(1), cwd);
+  if (first === "mv") return parseMv(tokens.slice(1), cwd);
+  if (first === "cp") return parseCp(tokens.slice(1), cwd);
+  return [];
+}
+function absolutize(path2, cwd) {
+  if (isAbsolute2(path2)) return path2;
+  return pathResolve(cwd, path2);
+}
+function isFlagLike(tok) {
+  return tok.startsWith("-");
+}
+function parseRm(args, cwd) {
+  const paths = args.filter((t) => !isFlagLike(t));
+  if (paths.length === 0) return [];
+  return paths.map((p) => ({ action: "prune", path: absolutize(p, cwd) }));
+}
+function parseMv(args, cwd) {
+  const paths = args.filter((t) => !isFlagLike(t));
+  if (paths.length !== 2) return [];
+  const [src, dst] = paths;
+  return [
+    { action: "prune", path: absolutize(src, cwd) },
+    { action: "reindex", path: absolutize(dst, cwd) }
+  ];
+}
+function parseCp(args, cwd) {
+  const paths = args.filter((t) => !isFlagLike(t));
+  if (paths.length !== 2) return [];
+  const [, dst] = paths;
+  return [{ action: "reindex", path: absolutize(dst, cwd) }];
+}
+function handleBashPostTool(payload) {
+  if (payload.tool_name !== "Bash") return { ops: [] };
+  const cmd = payload.tool_input?.command;
+  if (!cmd || typeof cmd !== "string") return { ops: [] };
+  try {
+    const ops = parseFileOps(cmd, payload.cwd);
+    return { ops };
+  } catch {
+    return { ops: [] };
+  }
+}
+
+// src/watcher.ts
+import { watch, existsSync as existsSync4, statSync as statSync2 } from "fs";
+import { resolve as resolve3, relative as relative4, extname } from "path";
+var WATCHABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".c",
+  ".cpp",
+  ".cs",
+  ".rb"
+]);
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  ".engram",
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "__pycache__",
+  ".venv",
+  "target",
+  "vendor"
+]);
+var DEBOUNCE_MS = 300;
+function shouldIgnore(relPath) {
+  const parts = relPath.split(/[/\\]/);
+  return parts.some((p) => IGNORED_DIRS.has(p));
+}
+async function syncFile(absPath, projectRoot) {
+  const ext = extname(absPath).toLowerCase();
+  if (!WATCHABLE_EXTENSIONS.has(ext)) return { action: "skipped", count: 0 };
+  const relPath = toPosixPath(relative4(projectRoot, absPath));
+  if (shouldIgnore(relPath)) return { action: "skipped", count: 0 };
+  if (!existsSync4(absPath)) {
+    const store2 = await getStore(projectRoot);
+    try {
+      const prior = store2.countBySourceFile(relPath);
+      if (prior === 0) return { action: "skipped", count: 0 };
+      store2.deleteBySourceFile(relPath);
+      return { action: "pruned", count: prior };
+    } finally {
+      store2.close();
+    }
+  }
+  try {
+    if (statSync2(absPath).isDirectory()) return { action: "skipped", count: 0 };
+  } catch {
+    return { action: "skipped", count: 0 };
+  }
+  const store = await getStore(projectRoot);
+  try {
+    store.deleteBySourceFile(relPath);
+    const { nodes, edges } = extractFile(absPath, projectRoot);
+    if (nodes.length > 0 || edges.length > 0) {
+      store.bulkUpsert(nodes, edges);
+    }
+    return { action: "indexed", count: nodes.length };
+  } finally {
+    store.close();
+  }
+}
+function formatReindexLine(result, displayPath) {
+  if (result.action === "indexed") {
+    return `engram: reindexed ${displayPath} (${formatThousands(result.count)} nodes)`;
+  }
+  if (result.action === "pruned") {
+    return `engram: pruned ${displayPath} (${formatThousands(result.count)} nodes)`;
+  }
+  return null;
+}
+async function runReindexHook(payload) {
+  try {
+    if (payload === null || typeof payload !== "object") return;
+    const p = payload;
+    const cwd = p.cwd;
+    if (typeof cwd !== "string" || !isValidCwd(cwd)) return;
+    const toolInput = p.tool_input;
+    if (toolInput === null || typeof toolInput !== "object") return;
+    const filePath = toolInput.file_path;
+    if (typeof filePath !== "string" || filePath.length === 0) return;
+    const absPath = resolve3(cwd, filePath);
+    const projectRoot = findProjectRoot(absPath);
+    if (projectRoot === null) return;
+    await syncFile(absPath, projectRoot);
+  } catch {
+  }
+}
+function watchProject(projectRoot, options = {}) {
+  const root = resolve3(projectRoot);
+  const controller = new AbortController();
+  if (!existsSync4(getDbPath(root))) {
+    throw new Error(
+      `engram: no graph found at ${root}. Run 'engram init' first.`
+    );
+  }
+  const debounceTimers = /* @__PURE__ */ new Map();
+  const watcher = watch(root, { recursive: true, signal: controller.signal });
+  const handleEvent = (_eventType, filename) => {
+    if (typeof filename !== "string") return;
+    const absPath = resolve3(root, filename);
+    const relPath = toPosixPath(relative4(root, absPath));
+    if (shouldIgnore(relPath)) return;
+    const ext = extname(filename).toLowerCase();
+    if (!WATCHABLE_EXTENSIONS.has(ext)) return;
+    const existing = debounceTimers.get(absPath);
+    if (existing) clearTimeout(existing);
+    debounceTimers.set(
+      absPath,
+      setTimeout(async () => {
+        debounceTimers.delete(absPath);
+        try {
+          const result = await syncFile(absPath, root);
+          if (result.action === "indexed" && result.count > 0) {
+            options.onReindex?.(relPath, result.count);
+          } else if (result.action === "pruned") {
+            options.onDelete?.(relPath, result.count);
+          }
+        } catch (err) {
+          options.onError?.(
+            err instanceof Error ? err : new Error(String(err))
+          );
+        }
+      }, DEBOUNCE_MS)
+    );
+  };
+  watcher.on("change", handleEvent);
+  watcher.on("rename", handleEvent);
+  watcher.on("error", (err) => {
+    options.onError?.(err instanceof Error ? err : new Error(String(err)));
+  });
+  options.onReady?.();
+  return controller;
+}
+
 // src/intercept/handlers/post-tool.ts
 function extractFilePath(toolName, toolInput) {
   if (!toolInput) return void 0;
@@ -2019,13 +1250,34 @@ async function handlePostTool(payload) {
       outputSize,
       success: !hasError
     });
+    if (toolName === "Bash" && !hasError && process.env.ENGRAM_AUTO_REINDEX === "1") {
+      void reindexBashOps(payload, projectRoot).catch(() => {
+      });
+    }
   } catch {
   }
   return PASSTHROUGH;
 }
+async function reindexBashOps(payload, projectRoot) {
+  const result = handleBashPostTool({
+    tool_name: payload.tool_name ?? "",
+    tool_input: payload.tool_input ?? {},
+    cwd: payload.cwd
+  });
+  if (result.ops.length === 0) return;
+  for (const op of result.ops) {
+    await runOp(op, projectRoot);
+  }
+}
+async function runOp(op, projectRoot) {
+  try {
+    await syncFile(op.path, projectRoot);
+  } catch {
+  }
+}
 
 // src/intercept/handlers/pre-compact.ts
-import { basename as basename2, resolve as resolve3 } from "path";
+import { basename as basename2, resolve as resolve4 } from "path";
 var MAX_GOD_NODES_COMPACT = 5;
 var MAX_LANDMINES_COMPACT = 3;
 function formatCompactBrief(args) {
@@ -2075,7 +1327,7 @@ async function handlePreCompact(payload) {
       }))
     ]);
     if (graphStats.nodes === 0 && gods.length === 0) return PASSTHROUGH;
-    const projectName = basename2(resolve3(projectRoot));
+    const projectName = basename2(resolve4(projectRoot));
     const text = formatCompactBrief({
       projectName,
       nodeCount: graphStats.nodes,
@@ -2097,7 +1349,7 @@ async function handlePreCompact(payload) {
 }
 
 // src/intercept/handlers/cwd-changed.ts
-import { basename as basename3, resolve as resolve4 } from "path";
+import { basename as basename3, resolve as resolve5 } from "path";
 var MAX_GOD_NODES_SWITCH = 5;
 async function handleCwdChanged(payload) {
   if (payload.hook_event_name !== "CwdChanged") return PASSTHROUGH;
@@ -2121,7 +1373,7 @@ async function handleCwdChanged(payload) {
       }))
     ]);
     if (graphStats.nodes === 0) return PASSTHROUGH;
-    const projectName = basename3(resolve4(projectRoot));
+    const projectName = basename3(resolve5(projectRoot));
     const lines = [];
     lines.push(
       `[engram] Project switched to ${projectName} (${graphStats.nodes} nodes, ${graphStats.edges} edges)`
@@ -2198,11 +1450,13 @@ async function dispatchPreToolUse(payload) {
       result = await runHandler(
         () => handleEditOrWrite(handlerPayload)
       );
+      result = await applyMistakeGuard(result, handlerPayload, "edit-write");
       break;
     case "Bash":
       result = await runHandler(
         () => handleBash(handlerPayload)
       );
+      result = await applyMistakeGuard(result, handlerPayload, "bash");
       break;
     default:
       return PASSTHROUGH;
@@ -2238,110 +1492,10 @@ function extractPreToolDecision(result) {
   return "passthrough";
 }
 
-// src/watcher.ts
-import { watch, existsSync as existsSync6, statSync as statSync2 } from "fs";
-import { resolve as resolve5, relative as relative3, extname } from "path";
-var WATCHABLE_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".ts",
-  ".tsx",
-  ".js",
-  ".jsx",
-  ".py",
-  ".go",
-  ".rs",
-  ".java",
-  ".c",
-  ".cpp",
-  ".cs",
-  ".rb"
-]);
-var IGNORED_DIRS = /* @__PURE__ */ new Set([
-  ".engram",
-  "node_modules",
-  ".git",
-  "dist",
-  "build",
-  ".next",
-  "__pycache__",
-  ".venv",
-  "target",
-  "vendor"
-]);
-var DEBOUNCE_MS = 300;
-function shouldIgnore(relPath) {
-  const parts = relPath.split(/[/\\]/);
-  return parts.some((p) => IGNORED_DIRS.has(p));
-}
-async function reindexFile(absPath, projectRoot) {
-  const ext = extname(absPath).toLowerCase();
-  if (!WATCHABLE_EXTENSIONS.has(ext)) return 0;
-  if (!existsSync6(absPath)) return 0;
-  try {
-    if (statSync2(absPath).isDirectory()) return 0;
-  } catch {
-    return 0;
-  }
-  const relPath = toPosixPath(relative3(projectRoot, absPath));
-  if (shouldIgnore(relPath)) return 0;
-  const store = await getStore(projectRoot);
-  try {
-    store.deleteBySourceFile(relPath);
-    const { nodes, edges } = extractFile(absPath, projectRoot);
-    if (nodes.length > 0 || edges.length > 0) {
-      store.bulkUpsert(nodes, edges);
-    }
-    return nodes.length;
-  } finally {
-    store.close();
-  }
-}
-function watchProject(projectRoot, options = {}) {
-  const root = resolve5(projectRoot);
-  const controller = new AbortController();
-  if (!existsSync6(getDbPath(root))) {
-    throw new Error(
-      `engram: no graph found at ${root}. Run 'engram init' first.`
-    );
-  }
-  const debounceTimers = /* @__PURE__ */ new Map();
-  const watcher = watch(root, { recursive: true, signal: controller.signal });
-  watcher.on("change", (_eventType, filename) => {
-    if (typeof filename !== "string") return;
-    const absPath = resolve5(root, filename);
-    const relPath = toPosixPath(relative3(root, absPath));
-    if (shouldIgnore(relPath)) return;
-    const ext = extname(filename).toLowerCase();
-    if (!WATCHABLE_EXTENSIONS.has(ext)) return;
-    const existing = debounceTimers.get(absPath);
-    if (existing) clearTimeout(existing);
-    debounceTimers.set(
-      absPath,
-      setTimeout(async () => {
-        debounceTimers.delete(absPath);
-        try {
-          const count = await reindexFile(absPath, root);
-          if (count > 0) {
-            options.onReindex?.(relPath, count);
-          }
-        } catch (err) {
-          options.onError?.(
-            err instanceof Error ? err : new Error(String(err))
-          );
-        }
-      }, DEBOUNCE_MS)
-    );
-  });
-  watcher.on("error", (err) => {
-    options.onError?.(err instanceof Error ? err : new Error(String(err)));
-  });
-  options.onReady?.();
-  return controller;
-}
-
 // src/dashboard.ts
 import chalk from "chalk";
-import { existsSync as existsSync7, statSync as statSync3 } from "fs";
-import { join as join7, resolve as resolve6, basename as basename4 } from "path";
+import { existsSync as existsSync5, statSync as statSync3 } from "fs";
+import { join as join5, resolve as resolve6, basename as basename4 } from "path";
 var AMBER = chalk.hex("#d97706");
 var DIM = chalk.dim;
 var GREEN = chalk.green;
@@ -2353,9 +1507,7 @@ function bar(pct, width = 20) {
   const empty = width - filled;
   return AMBER("\u2588".repeat(filled)) + DIM("\u2591".repeat(empty));
 }
-function fmt(n) {
-  return n.toLocaleString();
-}
+var fmt = formatThousands;
 function topFiles(entries, n) {
   const counts = /* @__PURE__ */ new Map();
   for (const e of entries) {
@@ -2463,8 +1615,8 @@ function startDashboard(projectRoot, options = {}) {
   const tick = () => {
     if (controller.signal.aborted) return;
     try {
-      const logPath = join7(root, ".engram", "hook-log.jsonl");
-      if (existsSync7(logPath)) {
+      const logPath = join5(root, ".engram", "hook-log.jsonl");
+      if (existsSync5(logPath)) {
         const currentSize = statSync3(logPath).size;
         if (currentSize !== lastSize) {
           cachedEntries = readHookLog(root);
@@ -2522,165 +1674,15 @@ async function handleCursorBeforeReadFile(payload) {
   }
 }
 
-// src/intercept/installer.ts
-var ENGRAM_HOOK_EVENTS = [
-  "PreToolUse",
-  "PostToolUse",
-  "SessionStart",
-  "UserPromptSubmit",
-  "PreCompact",
-  "CwdChanged"
-];
-var ENGRAM_PRETOOL_MATCHER = "Read|Edit|Write|Bash";
-var DEFAULT_ENGRAM_COMMAND = "engram intercept";
-var DEFAULT_HOOK_TIMEOUT_SEC = 5;
-var DEFAULT_STATUSLINE_COMMAND = "engram hud-label";
-function buildEngramHookEntries(command = DEFAULT_ENGRAM_COMMAND, timeout = DEFAULT_HOOK_TIMEOUT_SEC) {
-  const baseCmd = {
-    type: "command",
-    command,
-    timeout
-  };
-  return {
-    PreToolUse: {
-      matcher: ENGRAM_PRETOOL_MATCHER,
-      hooks: [baseCmd]
-    },
-    PostToolUse: {
-      // Match all tools — PostToolUse is an observer for any completion.
-      matcher: ".*",
-      hooks: [baseCmd]
-    },
-    SessionStart: {
-      // No matcher — SessionStart has no tool name.
-      hooks: [baseCmd]
-    },
-    UserPromptSubmit: {
-      // No matcher — UserPromptSubmit has no tool name.
-      hooks: [baseCmd]
-    },
-    PreCompact: {
-      // No matcher — PreCompact has no tool name.
-      hooks: [baseCmd]
-    },
-    CwdChanged: {
-      // No matcher — CwdChanged has no tool name.
-      hooks: [baseCmd]
-    }
-  };
-}
-function isEngramHookEntry(entry) {
-  if (entry === null || typeof entry !== "object") return false;
-  const e = entry;
-  if (!Array.isArray(e.hooks)) return false;
-  for (const h of e.hooks) {
-    if (h === null || typeof h !== "object") continue;
-    const cmd = h.command;
-    if (typeof cmd === "string" && cmd.includes("engram intercept")) {
-      return true;
-    }
-  }
-  return false;
-}
-function installEngramHooks(settings, command = DEFAULT_ENGRAM_COMMAND) {
-  const entries = buildEngramHookEntries(command);
-  const added = [];
-  const alreadyPresent = [];
-  const hooksClone = {};
-  const existingHooks = settings.hooks ?? {};
-  for (const [key, value] of Object.entries(existingHooks)) {
-    if (Array.isArray(value)) {
-      hooksClone[key] = value.map((entry) => ({ ...entry }));
-    }
-  }
-  for (const event of ENGRAM_HOOK_EVENTS) {
-    const eventArr = hooksClone[event] ?? [];
-    const hasEngram = eventArr.some((e) => isEngramHookEntry(e));
-    if (hasEngram) {
-      alreadyPresent.push(event);
-      hooksClone[event] = eventArr;
-      continue;
-    }
-    hooksClone[event] = [...eventArr, entries[event]];
-    added.push(event);
-  }
-  const hasStatusLine = settings.statusLine && typeof settings.statusLine === "object" && typeof settings.statusLine.command === "string" && settings.statusLine.command.length > 0;
-  const statusLineAdded = !hasStatusLine;
-  const statusLine = hasStatusLine ? settings.statusLine : { type: "command", command: DEFAULT_STATUSLINE_COMMAND };
-  return {
-    updated: { ...settings, hooks: hooksClone, statusLine },
-    added,
-    alreadyPresent,
-    statusLineAdded
-  };
-}
-function uninstallEngramHooks(settings) {
-  const removed = [];
-  const existingHooks = settings.hooks ?? {};
-  const hooksClone = {};
-  for (const [event, arr] of Object.entries(existingHooks)) {
-    if (!Array.isArray(arr)) continue;
-    const filtered = arr.filter((entry) => !isEngramHookEntry(entry));
-    if (filtered.length !== arr.length && isKnownEngramEvent(event)) {
-      removed.push(event);
-    }
-    if (filtered.length > 0) {
-      hooksClone[event] = filtered;
-    }
-  }
-  const updatedSettings = { ...settings };
-  if (Object.keys(hooksClone).length === 0) {
-    delete updatedSettings.hooks;
-  } else {
-    updatedSettings.hooks = hooksClone;
-  }
-  const statusLineRemoved = typeof updatedSettings.statusLine?.command === "string" && updatedSettings.statusLine.command.includes("engram hud-label");
-  if (statusLineRemoved) {
-    delete updatedSettings.statusLine;
-  }
-  return { updated: updatedSettings, removed, statusLineRemoved };
-}
-function isKnownEngramEvent(event) {
-  return ENGRAM_HOOK_EVENTS.includes(event);
-}
-function formatInstallDiff(before, after) {
-  const lines = [];
-  const beforeHooks = before.hooks ?? {};
-  const afterHooks = after.hooks ?? {};
-  for (const event of ENGRAM_HOOK_EVENTS) {
-    const beforeArr = beforeHooks[event] ?? [];
-    const afterArr = afterHooks[event] ?? [];
-    if (beforeArr.length === afterArr.length) continue;
-    lines.push(`+ ${event}: ${beforeArr.length} \u2192 ${afterArr.length} entries`);
-    const added = afterArr.filter((entry) => isEngramHookEntry(entry));
-    const beforeHasEngram = beforeArr.some((entry) => isEngramHookEntry(entry));
-    if (!beforeHasEngram && added.length > 0) {
-      for (const entry of added) {
-        const matcher = entry.matcher ? ` matcher=${JSON.stringify(entry.matcher)}` : "";
-        const cmds = entry.hooks.map((h) => h.command).join(", ");
-        lines.push(`    + {${matcher} command="${cmds}"}`);
-      }
-    }
-  }
-  const hadStatusLine = before.statusLine?.command;
-  const hasStatusLineNow = after.statusLine?.command;
-  if (!hadStatusLine && hasStatusLineNow?.includes("engram hud-label")) {
-    lines.push(`+ statusLine: engram hud-label (HUD enabled)`);
-  } else if (hadStatusLine?.includes("engram hud-label") && !hasStatusLineNow) {
-    lines.push(`- statusLine: engram hud-label (HUD removed)`);
-  }
-  return lines.length > 0 ? lines.join("\n") : "(no changes)";
-}
-
 // src/intercept/memory-md.ts
 import {
-  existsSync as existsSync8,
-  readFileSync as readFileSync4,
+  existsSync as existsSync6,
+  readFileSync as readFileSync3,
   writeFileSync,
   renameSync,
   statSync as statSync4
 } from "fs";
-import { join as join8 } from "path";
+import { join as join6 } from "path";
 var ENGRAM_MARKER_START = "<!-- engram:structural-facts:start -->";
 var ENGRAM_MARKER_END = "<!-- engram:structural-facts:end -->";
 var MAX_MEMORY_FILE_BYTES = 1e6;
@@ -2751,15 +1753,15 @@ function writeEngramSectionToMemoryMd(projectRoot, engramSection) {
   if (engramSection.length > MAX_ENGRAM_SECTION_BYTES) {
     return false;
   }
-  const memoryPath = join8(projectRoot, "MEMORY.md");
+  const memoryPath = join6(projectRoot, "MEMORY.md");
   try {
     let existing = "";
-    if (existsSync8(memoryPath)) {
+    if (existsSync6(memoryPath)) {
       const st = statSync4(memoryPath);
       if (st.size > MAX_MEMORY_FILE_BYTES) {
         return false;
       }
-      existing = readFileSync4(memoryPath, "utf-8");
+      existing = readFileSync3(memoryPath, "utf-8");
     }
     const updated = upsertEngramSection(existing, engramSection);
     const tmpPath = memoryPath + ".engram-tmp";
@@ -2773,9 +1775,9 @@ function writeEngramSectionToMemoryMd(projectRoot, engramSection) {
 
 // src/cli.ts
 import { basename as basename5 } from "path";
-import { createRequire as createRequire2 } from "module";
-var require3 = createRequire2(import.meta.url);
-var { version: PKG_VERSION } = require3("../package.json");
+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"
@@ -2786,6 +1788,9 @@ program.command("init").description("Scan codebase and build knowledge graph (ze
 ).option("--from-ccs", "Import .context/index.md (CCS) into graph after init").option(
   "--incremental",
   "Skip unchanged files (mtime-based). Dramatically faster on re-index of large repos."
+).option(
+  "--with-hook",
+  "Also install the Sentinel hook into Claude Code settings.local.json (idempotent)"
 ).action(async (projectPath, opts) => {
   console.log(chalk2.dim(opts.incremental ? "\u{1F50D} Scanning changed files..." : "\u{1F50D} Scanning codebase..."));
   const result = await init(projectPath, {
@@ -2796,7 +1801,7 @@ program.command("init").description("Scan codebase and build knowledge graph (ze
     chalk2.green("\u{1F333} AST extraction complete") + chalk2.dim(` (${result.timeMs}ms, 0 tokens used)`)
   );
   console.log(
-    `   ${chalk2.bold(String(result.nodes))} nodes, ${chalk2.bold(String(result.edges))} edges from ${chalk2.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 (${formatThousands(result.totalLines)} lines)`
   );
   if (result.incremental && result.skippedFiles && result.skippedFiles > 0) {
     console.log(chalk2.dim(`   ${result.skippedFiles} unchanged files skipped (incremental mode)`));
@@ -2813,15 +1818,15 @@ program.command("init").description("Scan codebase and build knowledge graph (ze
 \u{1F4CA} Token savings: ${chalk2.bold(bench.reductionVsRelevant + "x")} fewer tokens vs relevant files (${bench.reductionVsFull}x vs full corpus)`)
     );
     console.log(
-      chalk2.dim(`   Full corpus: ~${bench.naiveFullCorpus.toLocaleString()} tokens | Graph query: ~${bench.avgQueryTokens.toLocaleString()} tokens`)
+      chalk2.dim(`   Full corpus: ~${formatThousands(bench.naiveFullCorpus)} tokens | Graph query: ~${formatThousands(bench.avgQueryTokens)} tokens`)
     );
   }
   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 = join9(resolvedProject, ".claude", "settings.local.json");
-  const projectSettings = join9(resolvedProject, ".claude", "settings.json");
-  const hasHooks = existsSync9(localSettings) && readFileSync5(localSettings, "utf-8").includes("engram intercept") || existsSync9(projectSettings) && readFileSync5(projectSettings, "utf-8").includes("engram intercept");
+  const resolvedProject = pathResolve2(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");
   if (!hasHooks) {
     console.log(
       chalk2.yellow("\n\u{1F4A1} Next step: ") + chalk2.white("engram install-hook") + chalk2.dim(
@@ -2834,9 +1839,59 @@ program.command("init").description("Scan codebase and build knowledge graph (ze
       )
     );
   }
+  if (opts.withHook) {
+    const localSettingsPath = join7(
+      pathResolve2(projectPath),
+      ".claude",
+      "settings.local.json"
+    );
+    let settings = {};
+    if (existsSync7(localSettingsPath)) {
+      try {
+        const raw = readFileSync4(localSettingsPath, "utf-8");
+        settings = raw.trim() ? JSON.parse(raw) : {};
+      } catch {
+        console.log(
+          chalk2.yellow(
+            "\n   \u26A0 --with-hook: settings.local.json is invalid JSON, skipping hook install."
+          )
+        );
+        settings = {};
+      }
+    }
+    const hookResult = installEngramHooks(settings);
+    if (hookResult.added.length > 0 || hookResult.statusLineAdded) {
+      try {
+        mkdirSync(dirname3(localSettingsPath), { recursive: true });
+        writeFileSync2(
+          localSettingsPath,
+          JSON.stringify(hookResult.updated, null, 2) + "\n"
+        );
+        console.log(
+          chalk2.green(
+            `
+   \u2705 --with-hook: installed ${hookResult.added.length} hook event${hookResult.added.length === 1 ? "" : "s"} into .claude/settings.local.json`
+          )
+        );
+      } catch (err) {
+        console.log(
+          chalk2.yellow(
+            `
+   \u26A0 --with-hook: write failed (${err.message})`
+          )
+        );
+      }
+    } else {
+      console.log(
+        chalk2.dim(
+          "\n   --with-hook: Sentinel hook already installed, nothing to do."
+        )
+      );
+    }
+  }
   if (opts.fromCcs) {
-    const { importCcs } = await import("./importer-V62NGZRK.js");
-    const resolvedProjectPath = pathResolve(projectPath);
+    const { importCcs } = await import("./importer-4UWQDH4W.js");
+    const resolvedProjectPath = pathResolve2(projectPath);
     const ccsResult = await importCcs(resolvedProjectPath);
     if (ccsResult.nodesCreated > 0) {
       console.log(
@@ -2850,7 +1905,7 @@ 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);
+  const resolvedPath = pathResolve2(projectPath);
   console.log(
     chalk2.dim("\u{1F441}  Watching ") + chalk2.white(resolvedPath) + chalk2.dim(" for changes...")
   );
@@ -2860,6 +1915,11 @@ program.command("watch").description("Watch project for file changes and re-inde
         chalk2.green("  \u21BB ") + chalk2.white(filePath) + chalk2.dim(` (${nodeCount} nodes)`)
       );
     },
+    onDelete: (filePath, prunedCount) => {
+      console.log(
+        chalk2.yellow("  \xD7 ") + chalk2.white(filePath) + chalk2.dim(` pruned (${prunedCount} nodes)`)
+      );
+    },
     onError: (err) => {
       console.error(chalk2.red("  \u2717 ") + err.message);
     },
@@ -2875,10 +1935,70 @@ program.command("watch").description("Watch project for file changes and re-inde
   await new Promise(() => {
   });
 });
+program.command("reindex").description("Re-index a single file into the knowledge graph").argument("<file>", "File path (absolute or relative to --project)").option("-p, --project <path>", "Project directory", ".").option("--verbose", "Print stack traces on error", false).action(
+  async (file, opts) => {
+    const root = pathResolve2(opts.project);
+    if (!existsSync7(join7(root, ".engram", "graph.db"))) {
+      console.error(
+        `engram: no graph found at ${root}. Run 'engram init' first.`
+      );
+      process.exit(1);
+    }
+    const absFile = pathResolve2(root, file);
+    try {
+      const result = await syncFile(absFile, root);
+      const line = formatReindexLine(result, file);
+      if (line !== null) console.log(line);
+      process.exitCode = 0;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`engram: ${msg}`);
+      if (opts.verbose && err instanceof Error && err.stack) {
+        console.error(err.stack);
+      }
+      process.exit(1);
+    }
+  }
+);
+program.command("reindex-hook").description(
+  "PostToolUse hook entry point: reads JSON from stdin, reindexes tool_input.file_path (always exits 0)"
+).action(async () => {
+  const stdinTimeout = setTimeout(() => {
+    process.exit(0);
+  }, 3e3);
+  stdinTimeout.unref();
+  let input = "";
+  let stdinFailed = false;
+  try {
+    for await (const chunk of process.stdin) {
+      input += chunk;
+      if (input.length > 1e6) break;
+    }
+  } catch {
+    stdinFailed = true;
+  }
+  clearTimeout(stdinTimeout);
+  if (stdinFailed || !input.trim()) {
+    process.exitCode = 0;
+    return;
+  }
+  let payload;
+  try {
+    payload = JSON.parse(input);
+  } catch {
+    process.exitCode = 0;
+    return;
+  }
+  try {
+    await runReindexHook(payload);
+  } catch {
+  }
+  process.exitCode = 0;
+});
 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 = join9(resolvedPath, ".engram", "graph.db");
-  if (!existsSync9(dbPath)) {
+  const resolvedPath = pathResolve2(projectPath);
+  const dbPath = join7(resolvedPath, ".engram", "graph.db");
+  if (!existsSync7(dbPath)) {
     console.error(
       chalk2.red("No engram graph found at ") + chalk2.white(resolvedPath)
     );
@@ -2895,14 +2015,14 @@ program.command("dashboard").alias("hud").description("Live terminal dashboard s
   });
 });
 program.command("hud-label").description("Output JSON label for Claude HUD --extra-cmd (fast, <20ms)").argument("[path]", "Project directory", ".").action(async (projectPath) => {
-  let resolvedPath = pathResolve(projectPath);
+  let resolvedPath = pathResolve2(projectPath);
   let found = false;
   for (let depth = 0; depth < 20; depth++) {
-    if (existsSync9(join9(resolvedPath, ".engram", "graph.db"))) {
+    if (existsSync7(join7(resolvedPath, ".engram", "graph.db"))) {
       found = true;
       break;
     }
-    const parent = dirname4(resolvedPath);
+    const parent = dirname3(resolvedPath);
     if (parent === resolvedPath) break;
     resolvedPath = parent;
   }
@@ -2910,8 +2030,8 @@ program.command("hud-label").description("Output JSON label for Claude HUD --ext
     console.log('{"label":""}');
     return;
   }
-  const logPath = join9(resolvedPath, ".engram", "hook-log.jsonl");
-  if (!existsSync9(logPath)) {
+  const logPath = join7(resolvedPath, ".engram", "hook-log.jsonl");
+  if (!existsSync7(logPath)) {
     console.log('{"label":"\u26A1engram \u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591 ready"}');
     return;
   }
@@ -2991,8 +2111,8 @@ program.command("stats").description("Show knowledge graph statistics and token
   if (bench.naiveFullCorpus > 0) {
     console.log(`
   ${chalk2.cyan("Token savings:")}`);
-    console.log(`    Full corpus:   ~${bench.naiveFullCorpus.toLocaleString()} tokens`);
-    console.log(`    Avg query:     ~${bench.avgQueryTokens.toLocaleString()} tokens`);
+    console.log(`    Full corpus:   ~${formatThousands(bench.naiveFullCorpus)} tokens`);
+    console.log(`    Avg query:     ~${formatThousands(bench.avgQueryTokens)} 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`);
   }
@@ -3036,8 +2156,8 @@ 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(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(`  Full corpus:     ~${formatThousands(result.naiveFullCorpus)} tokens`);
+  console.log(`  Avg graph query: ~${formatThousands(result.avgQueryTokens)} 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
 `);
@@ -3050,22 +2170,28 @@ var hooks = program.command("hooks").description("Manage git hooks");
 hooks.command("install").description("Install post-commit and post-checkout hooks").argument("[path]", "Project directory", ".").action((p) => console.log(install(p)));
 hooks.command("uninstall").description("Remove engram git hooks").argument("[path]", "Project directory", ".").action((p) => console.log(uninstall(p)));
 hooks.command("status").description("Check if hooks are installed").argument("[path]", "Project directory", ".").action((p) => console.log(status(p)));
-program.command("gen").description("Generate CLAUDE.md / .cursorrules section from graph").option("-p, --project <path>", "Project directory", ".").option("-t, --target <type>", "Target file: claude, cursor, agents").option(
+program.command("gen").description(
+  "Generate CLAUDE.md + AGENTS.md (default) or a single file via --target"
+).option("-p, --project <path>", "Project directory", ".").option(
+  "-t, --target <type>",
+  "Single-file target: claude, cursor, agents. Default: emit both CLAUDE.md and AGENTS.md."
+).option(
   "--task <name>",
   "Task-aware view: general (default), bug-fix, feature, refactor"
 ).action(
   async (opts) => {
     const target = opts.target;
     const result = await autogen(opts.project, target, opts.task);
+    const fileList = result.files.map((f) => chalk2.bold(f)).join(", ");
     console.log(
       chalk2.green(
-        `\u2705 Updated ${result.file} (${result.nodesIncluded} nodes, view: ${result.view})`
+        `\u2705 Updated ${fileList} (${result.nodesIncluded} nodes, view: ${result.view})`
       )
     );
   }
 );
 program.command("gen-mdc").description("Generate .cursor/rules/engram-context.mdc from knowledge graph").option("-p, --project <path>", "Project directory", ".").option("--watch", "Regenerate on graph changes").action(async (opts) => {
-  const { generateCursorMdc } = await import("./cursor-mdc-GJ7E5LDD.js");
+  const { generateCursorMdc } = await import("./cursor-mdc-EEO7PYZ3.js");
   const result = await generateCursorMdc(opts.project);
   console.log(
     chalk2.green(
@@ -3073,11 +2199,15 @@ program.command("gen-mdc").description("Generate .cursor/rules/engram-context.md
     )
   );
   if (opts.watch) {
-    watchProject(pathResolve(opts.project), {
+    watchProject(pathResolve2(opts.project), {
       onReindex: async () => {
         const r = await generateCursorMdc(opts.project);
         console.log(chalk2.dim(`  \u21BB Regenerated MDC (${r.nodes} nodes)`));
       },
+      onDelete: async () => {
+        const r = await generateCursorMdc(opts.project);
+        console.log(chalk2.dim(`  \xD7 Regenerated MDC (${r.nodes} nodes)`));
+      },
       onError: (err) => console.error(chalk2.red(err.message)),
       onReady: () => console.log(chalk2.dim("  Watching for changes..."))
     });
@@ -3086,8 +2216,8 @@ program.command("gen-mdc").description("Generate .cursor/rules/engram-context.md
   }
 });
 program.command("gen-ccs").description("Export knowledge graph as .context/index.md (CCS format)").option("-p, --project <path>", "Project directory", ".").action(async (opts) => {
-  const { exportCcs } = await import("./exporter-GWU2GF23.js");
-  const result = await exportCcs(pathResolve(opts.project));
+  const { exportCcs } = await import("./exporter-ZYJ4WM2F.js");
+  const result = await exportCcs(pathResolve2(opts.project));
   console.log(
     chalk2.green(
       `\u2705 Generated ${result.filePath} (${result.sectionsWritten} sections, ${result.nodesExported} nodes)`
@@ -3095,19 +2225,23 @@ program.command("gen-ccs").description("Export knowledge graph as .context/index
   );
 });
 program.command("gen-aider").description("Generate .aider-context.md from knowledge graph").option("-p, --project <path>", "Project directory", ".").option("--watch", "Regenerate on graph changes").action(async (opts) => {
-  const { generateAiderContext } = await import("./aider-context-BC5R2ZTA.js");
-  const result = await generateAiderContext(pathResolve(opts.project));
+  const { generateAiderContext } = await import("./aider-context-6IDE3R7U.js");
+  const result = await generateAiderContext(pathResolve2(opts.project));
   console.log(
     chalk2.green(
       `\u2705 Generated ${result.filePath} (${result.sections} sections, ${result.nodes} nodes)`
     )
   );
   if (opts.watch) {
-    watchProject(pathResolve(opts.project), {
+    watchProject(pathResolve2(opts.project), {
       onReindex: async () => {
         const r = await generateAiderContext(opts.project);
         console.log(chalk2.dim(`  \u21BB Regenerated .aider-context.md (${r.nodes} nodes)`));
       },
+      onDelete: async () => {
+        const r = await generateAiderContext(opts.project);
+        console.log(chalk2.dim(`  \xD7 Regenerated .aider-context.md (${r.nodes} nodes)`));
+      },
       onError: (err) => console.error(chalk2.red(err.message)),
       onReady: () => console.log(chalk2.dim("  Watching for changes..."))
     });
@@ -3116,19 +2250,23 @@ program.command("gen-aider").description("Generate .aider-context.md from knowle
   }
 });
 program.command("gen-windsurfrules").description("Generate .windsurfrules from knowledge graph (Windsurf IDE)").option("-p, --project <path>", "Project directory", ".").option("--watch", "Regenerate on graph changes").action(async (opts) => {
-  const { generateWindsurfRules } = await import("./windsurf-rules-C7SVDHBL.js");
-  const result = await generateWindsurfRules(pathResolve(opts.project));
+  const { generateWindsurfRules } = await import("./windsurf-rules-XF7MYF6J.js");
+  const result = await generateWindsurfRules(pathResolve2(opts.project));
   console.log(
     chalk2.green(
       `\u2705 Generated ${result.filePath} (${result.sections} sections, ${result.nodes} nodes)`
     )
   );
   if (opts.watch) {
-    watchProject(pathResolve(opts.project), {
+    watchProject(pathResolve2(opts.project), {
       onReindex: async () => {
         const r = await generateWindsurfRules(opts.project);
         console.log(chalk2.dim(`  \u21BB Regenerated .windsurfrules (${r.nodes} nodes)`));
       },
+      onDelete: async () => {
+        const r = await generateWindsurfRules(opts.project);
+        console.log(chalk2.dim(`  \xD7 Regenerated .windsurfrules (${r.nodes} nodes)`));
+      },
       onError: (err) => console.error(chalk2.red(err.message)),
       onReady: () => console.log(chalk2.dim("  Watching for changes..."))
     });
@@ -3137,14 +2275,14 @@ program.command("gen-windsurfrules").description("Generate .windsurfrules from k
   }
 });
 function resolveSettingsPath(scope, projectPath) {
-  const absProject = pathResolve(projectPath);
+  const absProject = pathResolve2(projectPath);
   switch (scope) {
     case "local":
-      return join9(absProject, ".claude", "settings.local.json");
+      return join7(absProject, ".claude", "settings.local.json");
     case "project":
-      return join9(absProject, ".claude", "settings.json");
+      return join7(absProject, ".claude", "settings.json");
     case "user":
-      return join9(homedir(), ".claude", "settings.json");
+      return join7(homedir(), ".claude", "settings.json");
     default:
       return null;
   }
@@ -3226,7 +2364,11 @@ program.command("cursor-intercept").description(
   }
   process.exit(0);
 });
-program.command("install-hook").description("Install engram hook entries into Claude Code settings").option("--scope <scope>", "local | project | user", "local").option("--dry-run", "Show diff without writing", false).option("-p, --project <path>", "Project directory", ".").action(
+program.command("install-hook").description("Install engram hook entries into Claude Code settings").option("--scope <scope>", "local | project | user", "local").option("--dry-run", "Show diff without writing", false).option("-p, --project <path>", "Project directory", ".").option(
+  "--auto-reindex",
+  "Also register a PostToolUse Edit|Write|MultiEdit entry calling 'engram reindex-hook' (keeps graph fresh after every edit, #8)",
+  false
+).action(
   async (opts) => {
     const settingsPath = resolveSettingsPath(opts.scope, opts.project);
     if (!settingsPath) {
@@ -3238,9 +2380,9 @@ program.command("install-hook").description("Install engram hook entries into Cl
       process.exit(1);
     }
     let existing = {};
-    if (existsSync9(settingsPath)) {
+    if (existsSync7(settingsPath)) {
       try {
-        const raw = readFileSync5(settingsPath, "utf-8");
+        const raw = readFileSync4(settingsPath, "utf-8");
         existing = raw.trim() ? JSON.parse(raw) : {};
       } catch (err) {
         console.error(
@@ -3256,13 +2398,20 @@ program.command("install-hook").description("Install engram hook entries into Cl
         process.exit(1);
       }
     }
-    const result = installEngramHooks(existing);
+    const result = installEngramHooks(existing, void 0, {
+      autoReindex: opts.autoReindex
+    });
     console.log(
       chalk2.bold(`
 \u{1F4CC} engram install-hook (scope: ${opts.scope})`)
     );
     console.log(chalk2.dim(`   Target: ${settingsPath}`));
-    if (result.added.length === 0 && !result.statusLineAdded) {
+    if (opts.autoReindex) {
+      console.log(
+        chalk2.dim("   Auto-reindex: enabled (engram reindex-hook)")
+      );
+    }
+    if (result.added.length === 0 && !result.statusLineAdded && !result.autoReindexAdded) {
       console.log(
         chalk2.yellow(
           `
@@ -3285,8 +2434,8 @@ program.command("install-hook").description("Install engram hook entries into Cl
       return;
     }
     try {
-      mkdirSync(dirname4(settingsPath), { recursive: true });
-      if (existsSync9(settingsPath)) {
+      mkdirSync(dirname3(settingsPath), { recursive: true });
+      if (existsSync7(settingsPath)) {
         const backupPath = `${settingsPath}.engram-backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.bak`;
         copyFileSync(settingsPath, backupPath);
         console.log(chalk2.dim(`   Backup: ${backupPath}`));
@@ -3317,6 +2466,13 @@ program.command("install-hook").description("Install engram hook entries into Cl
         chalk2.green("   \u2705 StatusLine: engram hud-label (HUD visible in Claude Code)")
       );
     }
+    if (result.autoReindexAdded) {
+      console.log(
+        chalk2.green(
+          "   \u2705 PostToolUse: engram reindex-hook (matcher: Edit|Write|MultiEdit)"
+        )
+      );
+    }
     if (result.alreadyPresent.length > 0) {
       console.log(
         chalk2.dim(
@@ -3337,7 +2493,7 @@ program.command("uninstall-hook").description("Remove engram hook entries from C
     console.error(chalk2.red(`Unknown scope: ${opts.scope}`));
     process.exit(1);
   }
-  if (!existsSync9(settingsPath)) {
+  if (!existsSync7(settingsPath)) {
     console.log(
       chalk2.yellow(`No settings file at ${settingsPath} \u2014 nothing to remove.`)
     );
@@ -3345,7 +2501,7 @@ program.command("uninstall-hook").description("Remove engram hook entries from C
   }
   let existing;
   try {
-    const raw = readFileSync5(settingsPath, "utf-8");
+    const raw = readFileSync4(settingsPath, "utf-8");
     existing = raw.trim() ? JSON.parse(raw) : {};
   } catch (err) {
     console.error(
@@ -3390,7 +2546,7 @@ program.command("uninstall-hook").description("Remove engram hook entries from C
   }
 });
 program.command("hook-stats").description("Summarize hook-log.jsonl for a project").option("-p, --project <path>", "Project directory", ".").option("--json", "Output as JSON", false).action(async (opts) => {
-  const absProject = pathResolve(opts.project);
+  const absProject = pathResolve2(opts.project);
   const projectRoot = findProjectRoot(absProject) ?? absProject;
   const entries = readHookLog(projectRoot);
   const summary = summarizeHookLog(entries);
@@ -3401,8 +2557,8 @@ program.command("hook-stats").description("Summarize hook-log.jsonl for a projec
   console.log(formatStatsSummary(summary));
 });
 program.command("hook-preview").description("Show what the Read handler would do for a file (dry-run)").argument("<file>", "Target file path").option("-p, --project <path>", "Project directory", ".").action(async (file, opts) => {
-  const absProject = pathResolve(opts.project);
-  const absFile = pathResolve(absProject, file);
+  const absProject = pathResolve2(opts.project);
+  const absFile = pathResolve2(absProject, file);
   const payload = {
     hook_event_name: "PreToolUse",
     tool_name: "Read",
@@ -3451,7 +2607,7 @@ program.command("hook-preview").description("Show what the Read handler would do
   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 absProject = pathResolve2(opts.project);
   const projectRoot = findProjectRoot(absProject);
   if (!projectRoot) {
     console.error(
@@ -3460,7 +2616,7 @@ program.command("hook-disable").description("Disable engram hooks via kill switc
     console.error(chalk2.dim("Run 'engram init' first."));
     process.exit(1);
   }
-  const flagPath = join9(projectRoot, ".engram", "hook-disabled");
+  const flagPath = join7(projectRoot, ".engram", "hook-disabled");
   try {
     writeFileSync2(flagPath, (/* @__PURE__ */ new Date()).toISOString());
     console.log(
@@ -3478,14 +2634,14 @@ program.command("hook-disable").description("Disable engram hooks via kill switc
   }
 });
 program.command("hook-enable").description("Re-enable engram hooks (remove kill switch flag)").option("-p, --project <path>", "Project directory", ".").action(async (opts) => {
-  const absProject = pathResolve(opts.project);
+  const absProject = pathResolve2(opts.project);
   const projectRoot = findProjectRoot(absProject);
   if (!projectRoot) {
     console.error(chalk2.red(`Not an engram project: ${absProject}`));
     process.exit(1);
   }
-  const flagPath = join9(projectRoot, ".engram", "hook-disabled");
-  if (!existsSync9(flagPath)) {
+  const flagPath = join7(projectRoot, ".engram", "hook-disabled");
+  if (!existsSync7(flagPath)) {
     console.log(
       chalk2.yellow(`engram hooks already enabled for ${projectRoot}`)
     );
@@ -3507,7 +2663,7 @@ program.command("memory-sync").description(
   "Write engram's structural facts into MEMORY.md (complementary to Anthropic Auto-Dream)"
 ).option("-p, --project <path>", "Project directory", ".").option("--dry-run", "Print what would be written without writing", false).action(
   async (opts) => {
-    const absProject = pathResolve(opts.project);
+    const absProject = pathResolve2(opts.project);
     const projectRoot = findProjectRoot(absProject);
     if (!projectRoot) {
       console.error(
@@ -3527,9 +2683,9 @@ program.command("memory-sync").description(
     }
     let branch = null;
     try {
-      const headPath = join9(projectRoot, ".git", "HEAD");
-      if (existsSync9(headPath)) {
-        const content = readFileSync5(headPath, "utf-8").trim();
+      const headPath = join7(projectRoot, ".git", "HEAD");
+      if (existsSync7(headPath)) {
+        const content = readFileSync4(headPath, "utf-8").trim();
         const m = content.match(/^ref:\s+refs\/heads\/(.+)$/);
         if (m) branch = m[1];
       }
@@ -3555,7 +2711,7 @@ program.command("memory-sync").description(
 \u{1F4DD} engram memory-sync`)
     );
     console.log(
-      chalk2.dim(`   Target: ${join9(projectRoot, "MEMORY.md")}`)
+      chalk2.dim(`   Target: ${join7(projectRoot, "MEMORY.md")}`)
     );
     if (opts.dryRun) {
       console.log(chalk2.cyan("\n   Section to write (dry-run):\n"));
@@ -3590,7 +2746,7 @@ program.command("memory-sync").description(
   }
 );
 program.command("stress-test").description("Run stress tests: memory, concurrency, large-graph, hook-log replay").option("--reads <n>", "Rapid-reads test: call resolveRichPacket N times", parseInt).option("--providers", "Concurrency test: 50 parallel resolveRichPacket calls").option("--large-graph", "Large-graph test: insert N synthetic nodes and query").option("--nodes <n>", "Node count for --large-graph (default 1000)", parseInt).option("--replay <path>", "Hook-log replay: path to hook-log.jsonl").option("--limit <n>", "Entry limit for --replay (default 500)", parseInt).action(async (opts) => {
-  const { execFileSync: execFileSync2 } = await import("child_process");
+  const { execFileSync } = await import("child_process");
   const args = ["bench/stress-test.ts"];
   if (opts.reads) args.push("--reads", String(opts.reads));
   if (opts.providers) args.push("--providers");
@@ -3599,25 +2755,25 @@ program.command("stress-test").description("Run stress tests: memory, concurrenc
   if (opts.replay) args.push("--replay", opts.replay);
   if (opts.limit) args.push("--limit", String(opts.limit));
   try {
-    execFileSync2("npx", ["tsx", ...args], { stdio: "inherit", shell: true, cwd: join9(dirname4(fileURLToPath2(import.meta.url)), "..") });
+    execFileSync("npx", ["tsx", ...args], { stdio: "inherit", shell: true, cwd: join7(dirname3(fileURLToPath(import.meta.url)), "..") });
   } catch {
     process.exit(1);
   }
 });
 program.command("server").description("Start engram HTTP REST server (binds to 127.0.0.1 only)").option("--http", "Enable HTTP server (default)").option("--port <port>", "HTTP port", "7337").option("-p, --project <path>", "Project directory", ".").action(async (opts) => {
-  const { startHttpServer } = await import("./server-KUG7U6SG.js");
-  await startHttpServer(pathResolve(opts.project), parseInt(opts.port, 10));
+  const { startHttpServer } = await import("./server-2ZQKXJ5M.js");
+  await startHttpServer(pathResolve2(opts.project), parseInt(opts.port, 10));
 });
 program.command("ui").description("Open the web dashboard (auto-starts HTTP server if needed)").option("--port <port>", "HTTP port", "7337").option("-p, --project <path>", "Project directory", ".").option("--no-open", "Don't launch browser, just print the URL").action(async (opts) => {
   const port = parseInt(opts.port, 10);
   const publicUrl = `http://127.0.0.1:${port}/ui`;
-  const projectRoot = pathResolve(opts.project);
-  const { existsSync: existsSync10, readFileSync: readFileSync6 } = await import("fs");
-  const pidPath = join9(projectRoot, ".engram", "http-server.pid");
+  const projectRoot = pathResolve2(opts.project);
+  const { existsSync: existsSync8, readFileSync: readFileSync5 } = await import("fs");
+  const pidPath = join7(projectRoot, ".engram", "http-server.pid");
   let alreadyRunning = false;
-  if (existsSync10(pidPath)) {
+  if (existsSync8(pidPath)) {
     try {
-      const pid = parseInt(readFileSync6(pidPath, "utf-8"), 10);
+      const pid = parseInt(readFileSync5(pidPath, "utf-8"), 10);
       process.kill(pid, 0);
       alreadyRunning = true;
     } catch {
@@ -3644,8 +2800,8 @@ program.command("ui").description("Open the web dashboard (auto-starts HTTP serv
     const { platform } = process;
     const opener = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
     try {
-      const { execFile: execFile4 } = await import("child_process");
-      execFile4(opener, [bootUrl], { shell: platform === "win32" }, () => {
+      const { execFile: execFile2 } = await import("child_process");
+      execFile2(opener, [bootUrl], { shell: platform === "win32" }, () => {
       });
     } catch {
       console.log(chalk2.dim(`  Open manually: ${bootUrl}`));
@@ -3653,20 +2809,20 @@ program.command("ui").description("Open the web dashboard (auto-starts HTTP serv
   }
 });
 program.command("context-server").description("Start Zed-compatible context server (JSON-RPC over stdio)").action(async () => {
-  const { execFileSync: execFileSync2 } = await import("child_process");
+  const { execFileSync } = await import("child_process");
   try {
-    execFileSync2("npx", ["tsx", "adapters/zed/index.ts"], {
+    execFileSync("npx", ["tsx", "adapters/zed/index.ts"], {
       stdio: "inherit",
       shell: true,
-      cwd: join9(dirname4(fileURLToPath2(import.meta.url)), "..")
+      cwd: join7(dirname3(fileURLToPath(import.meta.url)), "..")
     });
   } catch {
     process.exit(1);
   }
 });
 program.command("tune").description("Analyze hook-log and propose provider config changes").option("-p, --project <path>", "Project directory", ".").option("--dry-run", "Show proposed changes without applying (default)").option("--apply", "Apply proposed changes to .engram/config.json").action(async (opts) => {
-  const { analyzeTuning, applyTuning } = await import("./tuner-KFNNGKG3.js");
-  const proposal = analyzeTuning(pathResolve(opts.project));
+  const { analyzeTuning, applyTuning } = await import("./tuner-Y2YENAZC.js");
+  const proposal = analyzeTuning(pathResolve2(opts.project));
   if (proposal.changes.length === 0) {
     console.log(
       chalk2.dim(
@@ -3688,7 +2844,7 @@ program.command("tune").description("Analyze hook-log and propose provider confi
     );
   }
   if (opts.apply) {
-    applyTuning(pathResolve(opts.project), proposal);
+    applyTuning(pathResolve2(opts.project), proposal);
     console.log(chalk2.green("\n\u2705 Changes applied to .engram/config.json"));
   } else {
     console.log(chalk2.dim("\nRun with --apply to write these changes."));
@@ -3696,9 +2852,9 @@ program.command("tune").description("Analyze hook-log and propose provider confi
 });
 var dbCmd = program.command("db").description("Database management");
 dbCmd.command("status").description("Show schema version and migration status").option("-p, --project <path>", "Project directory", ".").action(async (opts) => {
-  const { getStore: getStore2 } = await import("./core-6IY5L6II.js");
-  const { CURRENT_SCHEMA_VERSION, getSchemaVersion } = await import("./migrate-UKCO6BUU.js");
-  const store = await getStore2(pathResolve(opts.project));
+  const { getStore: getStore2 } = await import("./core-77F2BVYV.js");
+  const { CURRENT_SCHEMA_VERSION, getSchemaVersion } = await import("./migrate-KJ5K5NWO.js");
+  const store = await getStore2(pathResolve2(opts.project));
   try {
     const version = getSchemaVersion(store.db);
     const pending = CURRENT_SCHEMA_VERSION - version;
@@ -3713,11 +2869,11 @@ dbCmd.command("status").description("Show schema version and migration status").
   }
 });
 dbCmd.command("migrate").description("Run pending schema migrations").option("-p, --project <path>", "Project directory", ".").action(async (opts) => {
-  const { getStore: getStore2 } = await import("./core-6IY5L6II.js");
-  const { runMigrations } = await import("./migrate-UKCO6BUU.js");
-  const store = await getStore2(pathResolve(opts.project));
+  const { getStore: getStore2 } = await import("./core-77F2BVYV.js");
+  const { runMigrations } = await import("./migrate-KJ5K5NWO.js");
+  const store = await getStore2(pathResolve2(opts.project));
   try {
-    const dbPath = join9(pathResolve(opts.project), ".engram", "graph.db");
+    const dbPath = join7(pathResolve2(opts.project), ".engram", "graph.db");
     const result = runMigrations(
       store.db,
       dbPath
@@ -3748,11 +2904,11 @@ dbCmd.command("rollback").description("Roll back to an earlier schema version (D
     console.error(chalk2.red(`Invalid version: ${opts.to}`));
     process.exit(1);
   }
-  const { getStore: getStore2 } = await import("./core-6IY5L6II.js");
-  const { rollback, getSchemaVersion } = await import("./migrate-UKCO6BUU.js");
-  const store = await getStore2(pathResolve(opts.project));
+  const { getStore: getStore2 } = await import("./core-77F2BVYV.js");
+  const { rollback, getSchemaVersion } = await import("./migrate-KJ5K5NWO.js");
+  const store = await getStore2(pathResolve2(opts.project));
   try {
-    const dbPath = join9(pathResolve(opts.project), ".engram", "graph.db");
+    const dbPath = join7(pathResolve2(opts.project), ".engram", "graph.db");
     const current = getSchemaVersion(
       store.db
     );
@@ -3802,7 +2958,7 @@ dbCmd.command("rollback").description("Roll back to an earlier schema version (D
 });
 var pluginCmd = program.command("plugin").description("Manage context provider plugins");
 pluginCmd.command("list").description("List installed provider plugins").action(async () => {
-  const { loadPlugins, getPluginsDir, ensurePluginsDir } = await import("./plugin-loader-STTGYIL5.js");
+  const { loadPlugins, getPluginsDir, ensurePluginsDir } = await import("./plugin-loader-SQQB6V74.js");
   const dir = getPluginsDir();
   ensurePluginsDir(dir);
   const { loaded, failed } = await loadPlugins(dir);
@@ -3835,10 +2991,10 @@ pluginCmd.command("list").description("List installed provider plugins").action(
 pluginCmd.command("install").description("Install a plugin by copying its .mjs file into ~/.engram/plugins/").argument("<file>", "Path to plugin .mjs file").action(async (file) => {
   const { copyFileSync: copyFileSync2, statSync: statSync5 } = await import("fs");
   const { basename: basename6 } = await import("path");
-  const { getPluginsDir, ensurePluginsDir, validatePlugin } = await import("./plugin-loader-STTGYIL5.js");
+  const { getPluginsDir, ensurePluginsDir, validatePlugin } = await import("./plugin-loader-SQQB6V74.js");
   const { pathToFileURL } = await import("url");
-  const absPath = pathResolve(file);
-  if (!existsSync9(absPath)) {
+  const absPath = pathResolve2(file);
+  if (!existsSync7(absPath)) {
     console.error(chalk2.red(`File not found: ${absPath}`));
     process.exit(1);
   }
@@ -3867,15 +3023,15 @@ pluginCmd.command("install").description("Install a plugin by copying its .mjs f
   const pluginsDir = getPluginsDir();
   ensurePluginsDir(pluginsDir);
   const destName = basename6(absPath);
-  const destPath = join9(pluginsDir, destName);
+  const destPath = join7(pluginsDir, destName);
   copyFileSync2(absPath, destPath);
   console.log(chalk2.green(`\u2713 Installed: ${destPath}`));
 });
 pluginCmd.command("remove").description("Remove an installed plugin by filename").argument("<filename>", "Plugin filename (e.g., my-provider.mjs)").action(async (filename) => {
-  const { getPluginsDir } = await import("./plugin-loader-STTGYIL5.js");
+  const { getPluginsDir } = await import("./plugin-loader-SQQB6V74.js");
   const pluginsDir = getPluginsDir();
-  const target = join9(pluginsDir, filename);
-  if (!existsSync9(target)) {
+  const target = join7(pluginsDir, filename);
+  if (!existsSync7(target)) {
     console.error(chalk2.red(`No such plugin: ${filename}`));
     console.log(chalk2.dim(`Plugins directory: ${pluginsDir}`));
     process.exit(1);
@@ -3885,9 +3041,9 @@ pluginCmd.command("remove").description("Remove an installed plugin by filename"
 });
 var cacheCmd = program.command("cache").description("Inspect and manage the context cache");
 cacheCmd.command("stats").description("Show cache hit rate, entries, and LRU sizes").option("-p, --project <path>", "Project directory", ".").action(async (opts) => {
-  const { getStore: getStore2 } = await import("./core-6IY5L6II.js");
+  const { getStore: getStore2 } = await import("./core-77F2BVYV.js");
   const { getContextCache, ContextCache } = await import("./cache-AK6CF3BC.js");
-  const store = await getStore2(pathResolve(opts.project));
+  const store = await getStore2(pathResolve2(opts.project));
   try {
     ContextCache.ensureTables(store);
     const cache = getContextCache();
@@ -3919,9 +3075,9 @@ cacheCmd.command("stats").description("Show cache hit rate, entries, and LRU siz
   }
 });
 cacheCmd.command("clear").description("Flush all cache layers (query, pattern, hot files)").option("-p, --project <path>", "Project directory", ".").action(async (opts) => {
-  const { getStore: getStore2 } = await import("./core-6IY5L6II.js");
+  const { getStore: getStore2 } = await import("./core-77F2BVYV.js");
   const { getContextCache, ContextCache } = await import("./cache-AK6CF3BC.js");
-  const store = await getStore2(pathResolve(opts.project));
+  const store = await getStore2(pathResolve2(opts.project));
   try {
     ContextCache.ensureTables(store);
     const cache = getContextCache();
@@ -3938,14 +3094,14 @@ cacheCmd.command("clear").description("Flush all cache layers (query, pattern, h
   }
 });
 cacheCmd.command("warm").description("Pre-warm hot file cache from access frequency (top-N)").option("-p, --project <path>", "Project directory", ".").option("-n, --limit <n>", "Number of files to warm", "20").action(async (opts) => {
-  const { getStore: getStore2 } = await import("./core-6IY5L6II.js");
+  const { getStore: getStore2 } = await import("./core-77F2BVYV.js");
   const { getContextCache, ContextCache } = await import("./cache-AK6CF3BC.js");
-  const store = await getStore2(pathResolve(opts.project));
+  const store = await getStore2(pathResolve2(opts.project));
   try {
     ContextCache.ensureTables(store);
     const cache = getContextCache();
     const topN = parseInt(opts.limit, 10) || 20;
-    const count = cache.warmHotFiles(store, pathResolve(opts.project), topN);
+    const count = cache.warmHotFiles(store, pathResolve2(opts.project), topN);
     if (count === 0) {
       console.log(
         chalk2.dim(
@@ -3959,4 +3115,133 @@ cacheCmd.command("warm").description("Pre-warm hot file cache from access freque
     store.close();
   }
 });
+program.command("update").description("Check for and install the latest engram release").option("--check", "Check only \u2014 do not install", false).option("--force", "Bypass 7-day throttle cache on registry check", false).option(
+  "--manager <mgr>",
+  "Override package manager detection (npm | pnpm | yarn | bun)"
+).option("--dry-run", "Print the upgrade command without executing", false).action(
+  async (opts) => {
+    const { checkForUpdate } = await import("./check-2Z3MPZEJ.js");
+    const result = await checkForUpdate(PKG_VERSION, { force: opts.force });
+    if (result.skipped) {
+      if (result.fromCache === false) {
+        console.log(
+          chalk2.dim("Skipped (opt-out via ENGRAM_NO_UPDATE_CHECK or $CI).")
+        );
+      } else {
+        console.log(chalk2.dim("Skipped (registry unreachable)."));
+      }
+      return;
+    }
+    const ageMin = result.checkedAt ? Math.round((Date.now() - result.checkedAt) / 6e4) : 0;
+    const freshness = result.fromCache ? chalk2.dim(` (cached ${ageMin}m ago)`) : chalk2.dim(" (live)");
+    console.log(
+      `${chalk2.bold("engram")} ${chalk2.dim("installed:")} v${result.current}   ${chalk2.dim("latest:")} ${result.latest ?? chalk2.yellow("unknown")}${freshness}`
+    );
+    if (!result.updateAvailable) {
+      console.log(chalk2.green("\u2713 You are on the latest release."));
+      return;
+    }
+    console.log(
+      chalk2.yellow(
+        `\u2B06 v${result.latest} is available \u2014 you're on v${result.current}.`
+      )
+    );
+    if (opts.check) {
+      console.log(chalk2.dim("Run `engram update` to install it."));
+      return;
+    }
+    const { runUpgrade, manualCommand } = await import("./install-YVMVCFQW.js");
+    const outcome = runUpgrade({
+      dryRun: opts.dryRun,
+      manager: opts.manager === "npm" || opts.manager === "pnpm" || opts.manager === "yarn" || opts.manager === "bun" ? opts.manager : void 0
+    });
+    if (outcome.ok) {
+      console.log(chalk2.green(`\u2713 ${outcome.message}`));
+      if (!opts.dryRun) {
+        console.log(chalk2.dim("  Run `engram --version` to verify."));
+      }
+    } else {
+      console.error(chalk2.red(`\u2717 ${outcome.message}`));
+      if (outcome.stderrTail) {
+        console.error(chalk2.dim(outcome.stderrTail));
+      }
+      console.error(chalk2.dim(`  Manual: ${manualCommand()}`));
+      process.exitCode = 1;
+    }
+  }
+);
+program.command("doctor").description("Component health report with remediation hints").option("-p, --project <path>", "Project directory", ".").option("-v, --verbose", "Show remediation hints for warn/fail checks", false).option("--json", "Output JSON", false).option(
+  "--export",
+  "Redacted JSON for bug reports (same as --json with --verbose)",
+  false
+).action(
+  async (opts) => {
+    const { buildReport, formatReport, exportReport } = await import("./report-C3GTM3HY.js");
+    const root = pathResolve2(opts.project);
+    const report = buildReport(root, PKG_VERSION);
+    if (opts.json || opts.export) {
+      console.log(exportReport(report));
+    } else {
+      console.log(formatReport(report, opts.verbose));
+    }
+    process.exitCode = report.overallSeverity === "ok" ? 0 : report.overallSeverity === "warn" ? 1 : 2;
+  }
+);
+program.command("setup").description("Zero-friction first-run wizard (init + install-hook + doctor)").option("-p, --project <path>", "Project directory", ".").option("-y, --yes", "Accept all defaults (non-interactive)", false).option("--dry-run", "Print what would happen without touching anything", false).option(
+  "--scope <scope>",
+  "Hook scope for install-hook step (local | project | user)",
+  "local"
+).action(
+  async (opts) => {
+    const { runSetup } = await import("./wizard-UH27IO4I.js");
+    const scope = opts.scope === "local" || opts.scope === "project" || opts.scope === "user" ? opts.scope : "local";
+    const result = await runSetup({
+      projectPath: opts.project,
+      yes: opts.yes,
+      dryRun: opts.dryRun,
+      engramVersion: PKG_VERSION,
+      settingsScope: scope
+    });
+    process.exitCode = result.exitCode;
+  }
+);
+var FIRST_RUN_SILENT_CMDS = /* @__PURE__ */ new Set([
+  "intercept",
+  "cursor-intercept",
+  "hud-label",
+  "setup",
+  "init",
+  "update",
+  "doctor"
+]);
+function maybePrintFirstRunHint() {
+  if (process.env.CI) return;
+  if (process.env.ENGRAM_NO_UPDATE_CHECK === "1") return;
+  const subcommand = process.argv[2];
+  if (!subcommand) return;
+  if (FIRST_RUN_SILENT_CMDS.has(subcommand)) return;
+  try {
+    const cwd = process.cwd();
+    if (existsSync7(join7(cwd, ".engram", "graph.db"))) return;
+    const sentinel = join7(homedir(), ".engram", "first-run-shown");
+    if (existsSync7(sentinel)) return;
+    mkdirSync(dirname3(sentinel), { recursive: true });
+    writeFileSync2(sentinel, (/* @__PURE__ */ new Date()).toISOString(), "utf-8");
+    process.stderr.write(
+      chalk2.dim("\u{1F4A1} ") + chalk2.yellow("First time in this repo?") + chalk2.dim(" Run ") + chalk2.white("engram setup") + chalk2.dim(" for a zero-friction install.\n")
+    );
+  } catch {
+  }
+}
+function maybePrintUpdateHintSafe() {
+  const subcommand = process.argv[2];
+  if (!subcommand || FIRST_RUN_SILENT_CMDS.has(subcommand)) return;
+  try {
+    import("./notify-5POGKMRX.js").then((m) => m.maybePrintUpdateHint(PKG_VERSION)).catch(() => {
+    });
+  } catch {
+  }
+}
+maybePrintFirstRunHint();
+maybePrintUpdateHintSafe();
 program.parse();