engramx 0.4.3 → 0.5.0

package/dist/cli.js

@@ -4,7 +4,7 @@ import {
   install,
   status,
   uninstall
-} from "./chunk-ESPAWLH6.js";
+} from "./chunk-LH2ZID5Z.js";
 import {
   benchmark,
   computeKeywordIDF,
@@ -18,9 +18,10 @@ import {
   mistakes,
   path,
   query,
+  renderFileStructure,
   stats,
   toPosixPath
-} from "./chunk-R46DNLNR.js";
+} from "./chunk-V5VQQ3SF.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -79,6 +80,9 @@ function isHookDisabled(projectRoot) {
   }
 }
 
+// src/intercept/handlers/read.ts
+import { relative } from "path";
+
 // src/intercept/context.ts
 import { existsSync as existsSync2, realpathSync, statSync } from "fs";
 import { dirname, isAbsolute, join as join2, resolve, sep } from "path";
@@ -336,6 +340,739 @@ function buildSessionContextResponse(eventName, additionalContext) {
   };
 }
 
+// src/providers/types.ts
+var PROVIDER_PRIORITY = [
+  "engram:structure",
+  "engram:mistakes",
+  "mempalace",
+  "context7",
+  "engram:git",
+  "obsidian"
+];
+var DEFAULT_CACHE_TTL_SEC = 3600;
+
+// 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/resolver.ts
+var ALL_PROVIDERS = [
+  structureProvider,
+  mistakesProvider,
+  gitProvider,
+  mempalaceProvider,
+  context7Provider,
+  obsidianProvider
+];
+var TOTAL_TOKEN_BUDGET = 600;
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+async function resolveRichPacket(filePath, context, enabledProviders) {
+  const start = Date.now();
+  const providers = ALL_PROVIDERS.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 sorted = results.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 sections = [];
+  let totalTokens = 0;
+  for (const result of sorted) {
+    const sectionTokens = estimateTokens(result.content);
+    if (totalTokens + sectionTokens > TOTAL_TOKEN_BUDGET) {
+      break;
+    }
+    const provider = ALL_PROVIDERS.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-VUVXLXZN.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) {
@@ -356,11 +1093,81 @@ async function handleRead(payload) {
   if (!fileCtx.found || fileCtx.codeNodeCount === 0) return PASSTHROUGH;
   if (fileCtx.isStale) return PASSTHROUGH;
   if (fileCtx.confidence < READ_CONFIDENCE_THRESHOLD) return PASSTHROUGH;
+  const relPath = relative(ctx.projectRoot, ctx.absPath).replaceAll("\\", "/");
+  try {
+    const nodeContext = await buildNodeContext(
+      ctx.projectRoot,
+      relPath,
+      fileCtx
+    );
+    const enrichmentProviders = [
+      "engram:mistakes",
+      "engram:git",
+      "mempalace",
+      "context7",
+      "obsidian"
+    ];
+    const richPacket = await withRichTimeout(
+      resolveRichPacket(relPath, nodeContext, enrichmentProviders),
+      1500
+    );
+    if (richPacket && richPacket.providerCount > 0) {
+      const enrichedText = `${fileCtx.summary}
+
+${richPacket.text}`;
+      return buildDenyResponse(enrichedText);
+    }
+  } catch {
+  }
   return buildDenyResponse(fileCtx.summary);
 }
+async function buildNodeContext(projectRoot, relPath, fileCtx) {
+  const store = await getStore(projectRoot);
+  try {
+    const nodes = store.getNodesByFile(relPath);
+    const edges = store.getEdgesForNodes(nodes.map((n) => n.id));
+    const imports = edges.filter((e) => e.relation === "imports").map((e) => {
+      const parts = e.target.split("::");
+      return parts[parts.length - 1];
+    }).filter((name) => name && !name.startsWith(".") && !name.startsWith("/"));
+    const baseName = relPath.replace(/\.\w+$/, "");
+    const testPatterns = [
+      `${baseName}.test`,
+      `${baseName}.spec`,
+      `tests/${baseName.split("/").pop()}`
+    ];
+    const hasTests = testPatterns.some(
+      (pattern) => store.searchNodes(pattern, 1).length > 0
+    );
+    const fileNode = nodes.find((n) => n.kind === "file");
+    const churnRate = fileNode?.metadata?.churn_rate ?? 0;
+    return {
+      filePath: relPath,
+      projectRoot,
+      nodeIds: nodes.map((n) => n.id),
+      imports: [...new Set(imports)],
+      hasTests,
+      churnRate
+    };
+  } finally {
+    store.close();
+  }
+}
+function withRichTimeout(promise, ms) {
+  return new Promise((resolve7) => {
+    const timer = setTimeout(() => resolve7(null), ms);
+    promise.then((val) => {
+      clearTimeout(timer);
+      resolve7(val);
+    }).catch(() => {
+      clearTimeout(timer);
+      resolve7(null);
+    });
+  });
+}
 
 // src/intercept/handlers/edit-write.ts
-import { relative, resolve as resolvePath } from "path";
+import { relative as relative2, resolve as resolvePath } from "path";
 var MAX_LANDMINES_IN_WARNING = 5;
 function formatLandmineWarning(projectRelativeFile, mistakeList) {
   const header = `[engram landmines] ${mistakeList.length} past mistake${mistakeList.length === 1 ? "" : "s"} recorded for ${projectRelativeFile}:`;
@@ -383,7 +1190,7 @@ async function handleEditOrWrite(payload) {
   if (isContentUnsafeForIntercept(ctx.absPath)) return PASSTHROUGH;
   if (isHookDisabled(ctx.projectRoot)) return PASSTHROUGH;
   const relPath = toPosixPath(
-    relative(resolvePath(ctx.projectRoot), ctx.absPath)
+    relative2(resolvePath(ctx.projectRoot), ctx.absPath)
   );
   if (!relPath || relPath.startsWith("..")) return PASSTHROUGH;
   let found;
@@ -443,10 +1250,10 @@ async function handleBash(payload) {
 
 // src/intercept/handlers/session-start.ts
 import { existsSync as existsSync3, readFileSync } from "fs";
-import { execFile } from "child_process";
+import { execFile as execFile3 } from "child_process";
 import { promisify } from "util";
 import { basename, dirname as dirname2, join as join3, resolve as resolve2 } from "path";
-var execFileAsync = promisify(execFile);
+var execFileAsync = promisify(execFile3);
 var MAX_GOD_NODES = 10;
 var MAX_LANDMINES_IN_BRIEF = 3;
 function readGitBranch(projectRoot) {
@@ -588,6 +1395,8 @@ async function handleSessionStart(payload) {
       }))
     });
     const fullText = mempalaceContext ? text + "\n\n" + mempalaceContext : text;
+    warmAllProviders(projectRoot).catch(() => {
+    });
     return buildSessionContextResponse("SessionStart", fullText);
   } catch {
     return PASSTHROUGH;
@@ -1064,7 +1873,7 @@ function extractPreToolDecision(result) {
 
 // src/watcher.ts
 import { watch, existsSync as existsSync5, statSync as statSync3 } from "fs";
-import { resolve as resolve5, relative as relative2, extname } from "path";
+import { resolve as resolve5, relative as relative3, extname } from "path";
 var WATCHABLE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
@@ -1105,7 +1914,7 @@ async function reindexFile(absPath, projectRoot) {
   } catch {
     return 0;
   }
-  const relPath = toPosixPath(relative2(projectRoot, absPath));
+  const relPath = toPosixPath(relative3(projectRoot, absPath));
   if (shouldIgnore(relPath)) return 0;
   const store = await getStore(projectRoot);
   try {
@@ -1132,7 +1941,7 @@ function watchProject(projectRoot, options = {}) {
   watcher.on("change", (_eventType, filename) => {
     if (typeof filename !== "string") return;
     const absPath = resolve5(root, filename);
-    const relPath = toPosixPath(relative2(root, absPath));
+    const relPath = toPosixPath(relative3(root, absPath));
     if (shouldIgnore(relPath)) return;
     const ext = extname(filename).toLowerCase();
     if (!WATCHABLE_EXTENSIONS.has(ext)) return;
@@ -1450,6 +2259,7 @@ var ENGRAM_HOOK_EVENTS = [
 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",
@@ -1519,10 +2329,14 @@ function installEngramHooks(settings, command = DEFAULT_ENGRAM_COMMAND) {
     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 },
+    updated: { ...settings, hooks: hooksClone, statusLine },
     added,
-    alreadyPresent
+    alreadyPresent,
+    statusLineAdded
   };
 }
 function uninstallEngramHooks(settings) {
@@ -1545,7 +2359,11 @@ function uninstallEngramHooks(settings) {
   } else {
     updatedSettings.hooks = hooksClone;
   }
-  return { updated: updatedSettings, removed };
+  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);
@@ -1569,6 +2387,13 @@ function formatInstallDiff(before, after) {
       }
     }
   }
+  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)";
 }
 
@@ -1774,12 +2599,22 @@ 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) => {
-  const resolvedPath = pathResolve(projectPath);
-  const logPath = join8(resolvedPath, ".engram", "hook-log.jsonl");
-  if (!existsSync8(join8(resolvedPath, ".engram", "graph.db"))) {
+  let resolvedPath = pathResolve(projectPath);
+  let found = false;
+  for (let depth = 0; depth < 20; depth++) {
+    if (existsSync8(join8(resolvedPath, ".engram", "graph.db"))) {
+      found = true;
+      break;
+    }
+    const parent = dirname3(resolvedPath);
+    if (parent === resolvedPath) break;
+    resolvedPath = parent;
+  }
+  if (!found) {
     console.log('{"label":""}');
     return;
   }
+  const logPath = join8(resolvedPath, ".engram", "hook-log.jsonl");
   if (!existsSync8(logPath)) {
     console.log('{"label":"\u26A1engram \u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591 ready"}');
     return;
@@ -2056,7 +2891,7 @@ program.command("install-hook").description("Install engram hook entries into Cl
 \u{1F4CC} engram install-hook (scope: ${opts.scope})`)
     );
     console.log(chalk2.dim(`   Target: ${settingsPath}`));
-    if (result.added.length === 0) {
+    if (result.added.length === 0 && !result.statusLineAdded) {
       console.log(
         chalk2.yellow(
           `
@@ -2098,12 +2933,19 @@ program.command("install-hook").description("Install engram hook entries into Cl
       );
       process.exit(1);
     }
-    console.log(
-      chalk2.green(
-        `
+    if (result.added.length > 0) {
+      console.log(
+        chalk2.green(
+          `
    \u2705 Installed ${result.added.length} hook event${result.added.length === 1 ? "" : "s"}: ${result.added.join(", ")}`
-      )
-    );
+        )
+      );
+    }
+    if (result.statusLineAdded) {
+      console.log(
+        chalk2.green("   \u2705 StatusLine: engram hud-label (HUD visible in Claude Code)")
+      );
+    }
     if (result.alreadyPresent.length > 0) {
       console.log(
         chalk2.dim(
@@ -2141,7 +2983,7 @@ program.command("uninstall-hook").description("Remove engram hook entries from C
     process.exit(1);
   }
   const result = uninstallEngramHooks(existing);
-  if (result.removed.length === 0) {
+  if (result.removed.length === 0 && !result.statusLineRemoved) {
     console.log(
       chalk2.yellow(`
    No engram hooks found in ${settingsPath}.`)
@@ -2154,12 +2996,19 @@ program.command("uninstall-hook").description("Remove engram hook entries from C
     const tmpPath = settingsPath + ".engram-tmp";
     writeFileSync2(tmpPath, JSON.stringify(result.updated, null, 2) + "\n");
     renameSync3(tmpPath, settingsPath);
-    console.log(
-      chalk2.green(
-        `
+    if (result.removed.length > 0) {
+      console.log(
+        chalk2.green(
+          `
    \u2705 Removed engram hooks from ${result.removed.length} event${result.removed.length === 1 ? "" : "s"}: ${result.removed.join(", ")}`
-      )
-    );
+        )
+      );
+    }
+    if (result.statusLineRemoved) {
+      console.log(
+        chalk2.green("   \u2705 Removed engram statusLine (HUD)")
+      );
+    }
     console.log(chalk2.dim(`   Backup: ${backupPath}`));
   } catch (err) {
     console.error(