@unerr-ai/unerr 0.2.2 → 0.2.3

package/dist/cli.js

@@ -1803,6 +1803,163 @@ var init_git_review = __esm({
   }
 });
 
+// src/intelligence/local-snapshot.ts
+var local_snapshot_exports = {};
+__export(local_snapshot_exports, {
+  getSnapshotMeta: () => getSnapshotMeta,
+  loadLocalSnapshot: () => loadLocalSnapshot,
+  persistLocalSnapshot: () => persistLocalSnapshot,
+  shouldReindex: () => shouldReindex,
+  snapshotPath: () => snapshotPath
+});
+import {
+  existsSync as existsSync2,
+  mkdirSync,
+  readFileSync as readFileSync2,
+  readdirSync as readdirSync2,
+  statSync,
+  writeFileSync
+} from "fs";
+import { join as join2 } from "path";
+function snapshotPath(projectRoot) {
+  return join2(projectRoot, ".unerr", "snapshots", SNAPSHOT_FILENAME);
+}
+function getSnapshotMeta(projectRoot) {
+  const path7 = snapshotPath(projectRoot);
+  return { path: path7, exists: existsSync2(path7) };
+}
+function shouldReindex(projectRoot) {
+  const dbPath = join2(projectRoot, ".unerr", "graph.db");
+  const snPath = snapshotPath(projectRoot);
+  let referenceMtime = null;
+  if (existsSync2(dbPath)) {
+    try {
+      referenceMtime = statSync(dbPath).mtimeMs;
+    } catch {
+    }
+  }
+  if (referenceMtime === null && existsSync2(snPath)) {
+    try {
+      referenceMtime = statSync(snPath).mtimeMs;
+    } catch {
+    }
+  }
+  if (referenceMtime === null) return true;
+  return hasNewerSource(projectRoot, referenceMtime);
+}
+async function persistLocalSnapshot(projectRoot, repoId, entities, edges) {
+  const snapshotsDir = join2(projectRoot, ".unerr", "snapshots");
+  mkdirSync(snapshotsDir, { recursive: true });
+  const envelope = {
+    version: 1,
+    repoId,
+    orgId: "local",
+    entities,
+    edges,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const { pack } = await import("msgpackr");
+  const { gzipSync: gzipSync3 } = await import("zlib");
+  const packed = pack(envelope);
+  const compressed = gzipSync3(packed);
+  const path7 = snapshotPath(projectRoot);
+  writeFileSync(path7, compressed);
+  return path7;
+}
+async function loadLocalSnapshot(projectRoot, graphStore) {
+  const path7 = snapshotPath(projectRoot);
+  if (!existsSync2(path7)) return false;
+  try {
+    const { unpack } = await import("msgpackr");
+    const { gunzipSync: gunzipSync2 } = await import("zlib");
+    const raw = readFileSync2(path7);
+    const buffer = gunzipSync2(raw);
+    const envelope = unpack(buffer);
+    await graphStore.loadSnapshot(envelope);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasNewerSource(projectRoot, snapshotMtime) {
+  return scanDirForNewer(projectRoot, snapshotMtime);
+}
+function scanDirForNewer(dir, threshold) {
+  let entries;
+  try {
+    entries = readdirSync2(dir);
+  } catch {
+    return false;
+  }
+  for (const entry of entries) {
+    if (EXCLUDED_DIRS.has(entry)) continue;
+    if (entry.startsWith(".") && entry !== ".") continue;
+    const fullPath = join2(dir, entry);
+    let stat2;
+    try {
+      stat2 = statSync(fullPath);
+    } catch {
+      continue;
+    }
+    if (stat2.isDirectory()) {
+      if (scanDirForNewer(fullPath, threshold)) return true;
+    } else if (stat2.isFile()) {
+      const ext = fullPath.slice(fullPath.lastIndexOf(".")).toLowerCase();
+      if (SOURCE_EXTENSIONS.has(ext) && stat2.mtimeMs > threshold) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var SNAPSHOT_FILENAME, SOURCE_EXTENSIONS, EXCLUDED_DIRS;
+var init_local_snapshot = __esm({
+  "src/intelligence/local-snapshot.ts"() {
+    "use strict";
+    SNAPSHOT_FILENAME = "graph.msgpack.gz";
+    SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".ts",
+      ".tsx",
+      ".js",
+      ".jsx",
+      ".mjs",
+      ".cjs",
+      ".py",
+      ".go",
+      ".java",
+      ".rs",
+      ".c",
+      ".h",
+      ".cpp",
+      ".cc",
+      ".cxx",
+      ".hpp"
+    ]);
+    EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      "dist",
+      "build",
+      "out",
+      ".git",
+      ".hg",
+      ".svn",
+      "coverage",
+      "__pycache__",
+      ".mypy_cache",
+      ".pytest_cache",
+      "vendor",
+      "target",
+      ".next",
+      ".nuxt",
+      ".output",
+      ".unerr",
+      ".cache",
+      ".turbo",
+      ".parcel-cache"
+    ]);
+  }
+});
+
 // src/intelligence/indexer/test-detector.ts
 import { basename } from "path";
 function isTestFile(filePath) {
@@ -3050,8 +3207,8 @@ var local_graph_exports = {};
 __export(local_graph_exports, {
   CozoGraphStore: () => CozoGraphStore
 });
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
 function matchGlob(filePath, glob) {
   const regex = glob.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{GLOBSTAR\}\}/g, ".*");
   return new RegExp(`^${regex}$`).test(filePath);
@@ -3063,8 +3220,8 @@ var init_local_graph = __esm({
     init_community_detection();
     init_cozo_schema();
     init_search_index();
-    QUERY_TIMEOUT_MS = 2e3;
-    WRITE_TIMEOUT_MS = 1e4;
+    QUERY_TIMEOUT_MS = 12e3;
+    WRITE_TIMEOUT_MS = 6e4;
     CozoGraphStore = class _CozoGraphStore {
       db;
       loaded = false;
@@ -3123,10 +3280,10 @@ var init_local_graph = __esm({
        */
       static async create(db, projectRoot) {
         if (projectRoot) {
-          const pidPath2 = join2(projectRoot, ".unerr", "state", "proxy.pid");
-          if (existsSync2(pidPath2)) {
+          const pidPath2 = join3(projectRoot, ".unerr", "state", "proxy.pid");
+          if (existsSync3(pidPath2)) {
             try {
-              const raw = readFileSync2(pidPath2, "utf-8").trim();
+              const raw = readFileSync3(pidPath2, "utf-8").trim();
               let ownerPid;
               if (raw.startsWith("{")) {
                 const data = JSON.parse(raw);
@@ -5305,13 +5462,13 @@ var init_local_graph = __esm({
 });
 
 // src/intelligence/facts-schema.ts
-import { existsSync as existsSync3, mkdirSync } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
+import { join as join4 } from "path";
 async function openFactsDb(projectRoot) {
-  const unerrDir2 = join3(projectRoot, ".unerr");
-  mkdirSync(unerrDir2, { recursive: true });
-  const dbPath = join3(unerrDir2, FACTS_DB_FILENAME);
-  const isNew = !existsSync3(dbPath);
+  const unerrDir2 = join4(projectRoot, ".unerr");
+  mkdirSync2(unerrDir2, { recursive: true });
+  const dbPath = join4(unerrDir2, FACTS_DB_FILENAME);
+  const isNew = !existsSync4(dbPath);
   const cozoModule = await import("cozo-node");
   const CozoDbConstructor = cozoModule.default ? cozoModule.default.CozoDb : cozoModule.CozoDb;
   const db = new CozoDbConstructor("sqlite", dbPath);
@@ -6174,16 +6331,16 @@ var init_temporal_facts = __esm({
 });
 
 // src/intelligence/cochange-index.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync } from "fs";
-import { dirname as dirname2, join as join4 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join5 } from "path";
 function cochangeIndexPath(unerrDir2) {
-  return join4(unerrDir2, "state", "cochange-index.json");
+  return join5(unerrDir2, "state", "cochange-index.json");
 }
 function readCoChangeIndex(unerrDir2) {
   const path7 = cochangeIndexPath(unerrDir2);
-  if (!existsSync4(path7)) return {};
+  if (!existsSync5(path7)) return {};
   try {
-    const raw = readFileSync3(path7, "utf-8");
+    const raw = readFileSync4(path7, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
@@ -6198,7 +6355,7 @@ function recordCoChangeGroup(unerrDir2, anchors) {
   if (filePaths.length < 2) return;
   const path7 = cochangeIndexPath(unerrDir2);
   try {
-    mkdirSync2(dirname2(path7), { recursive: true });
+    mkdirSync3(dirname2(path7), { recursive: true });
   } catch {
   }
   const index = readCoChangeIndex(unerrDir2);
@@ -6213,7 +6370,7 @@ function recordCoChangeGroup(unerrDir2, anchors) {
     index[file] = merged;
   }
   try {
-    writeFileSync(path7, JSON.stringify(index), "utf-8");
+    writeFileSync2(path7, JSON.stringify(index), "utf-8");
   } catch {
   }
 }
@@ -6464,7 +6621,7 @@ __export(notes_store_exports, {
   NotesStore: () => NotesStore
 });
 import { createHash } from "crypto";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 function rowToStoredNote(row) {
   return {
     note_id: row[0],
@@ -6501,7 +6658,7 @@ var init_notes_store = __esm({
     init_cochange_index();
     init_note_dsl();
     init_topic_shift();
-    UNERR_DIR_FOR_COCHANGE = join5(process.cwd(), ".unerr");
+    UNERR_DIR_FOR_COCHANGE = join6(process.cwd(), ".unerr");
     SESSION_SAVE_CAP = 15;
     NotesStore = class {
       constructor(db) {
@@ -6870,8 +7027,8 @@ __export(git_attribution_exports, {
   writeGitNote: () => writeGitNote,
   writeReviewVerdictNote: () => writeReviewVerdictNote
 });
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { join as join9 } from "path";
 async function writeReviewVerdictNote(cwd, commitSha, note2) {
   await writeNote(
     cwd,
@@ -6929,10 +7086,10 @@ async function writeGitNote(dir, _gitdir, commitSha, payload) {
   await writeNote(dir, "unerr", commitSha, noteContent);
 }
 function readAttributionFromManifest(cwd) {
-  const manifestPath = join8(cwd, ".unerr", "manifest.json");
-  if (!existsSync6(manifestPath)) return null;
+  const manifestPath = join9(cwd, ".unerr", "manifest.json");
+  if (!existsSync7(manifestPath)) return null;
   try {
-    const raw = readFileSync5(manifestPath, "utf-8");
+    const raw = readFileSync6(manifestPath, "utf-8");
     const manifest = JSON.parse(raw);
     if (!manifest.sessionId || !manifest.attributions?.length) return null;
     const allEntryIds = [];
@@ -7485,18 +7642,18 @@ __export(mcp_config_writer_exports, {
 });
 import { execSync } from "child_process";
 import {
-  existsSync as existsSync9,
-  mkdirSync as mkdirSync5,
-  readFileSync as readFileSync8,
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync9,
   rmdirSync,
   unlinkSync,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "fs";
 import { homedir } from "os";
-import { basename as basename2, dirname as dirname3, join as join11 } from "path";
+import { basename as basename2, dirname as dirname3, join as join12 } from "path";
 function resolveUnerrCommand() {
   const entryScript = process.argv[1];
-  if (entryScript && existsSync9(entryScript)) {
+  if (entryScript && existsSync10(entryScript)) {
     const base = basename2(entryScript);
     if (base === "unerr" || base.startsWith("unerr.")) {
       return entryScript;
@@ -7509,7 +7666,7 @@ function resolveUnerrCommand() {
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
     }).trim().split(/\r?\n/)[0];
-    if (resolved && existsSync9(resolved)) {
+    if (resolved && existsSync10(resolved)) {
       return resolved;
     }
   } catch {
@@ -7552,10 +7709,10 @@ function writeMcpConfig(cwd, ide) {
   if (!agent) {
     return { path: "", action: "skipped" };
   }
-  const configPath2 = agent.configScope === "global" ? join11(homedir(), agent.projectConfigPath) : join11(cwd, agent.projectConfigPath);
+  const configPath2 = agent.configScope === "global" ? join12(homedir(), agent.projectConfigPath) : join12(cwd, agent.projectConfigPath);
   const dir = dirname3(configPath2);
-  if (!existsSync9(dir)) {
-    mkdirSync5(dir, { recursive: true });
+  if (!existsSync10(dir)) {
+    mkdirSync6(dir, { recursive: true });
   }
   switch (agent.configFormat) {
     case "mcp-json":
@@ -7579,10 +7736,10 @@ function writeAllMcpConfigs(cwd, agents) {
 function removeMcpConfig(cwd, ide) {
   const agent = getAgent(ide);
   if (!agent) return false;
-  const configPath2 = agent.configScope === "global" ? join11(homedir(), agent.projectConfigPath) : join11(cwd, agent.projectConfigPath);
-  if (!existsSync9(configPath2)) return false;
+  const configPath2 = agent.configScope === "global" ? join12(homedir(), agent.projectConfigPath) : join12(cwd, agent.projectConfigPath);
+  if (!existsSync10(configPath2)) return false;
   try {
-    const existing = JSON.parse(readFileSync8(configPath2, "utf-8"));
+    const existing = JSON.parse(readFileSync9(configPath2, "utf-8"));
     if (agent.configFormat === "continue-config") {
       if (!Array.isArray(existing.mcpServers)) return false;
       existing.mcpServers = existing.mcpServers.filter(
@@ -7602,7 +7759,7 @@ function removeMcpConfig(cwd, ide) {
       unlinkSync(configPath2);
       tryRmdir(dirname3(configPath2));
     } else {
-      writeFileSync3(configPath2, JSON.stringify(existing, null, 2), "utf-8");
+      writeFileSync4(configPath2, JSON.stringify(existing, null, 2), "utf-8");
     }
     return true;
   } catch {
@@ -7630,10 +7787,10 @@ function tryRmdir(dir) {
 function isConfigured(cwd, ide) {
   const agent = getAgent(ide);
   if (!agent) return false;
-  const configPath2 = agent.configScope === "global" ? join11(homedir(), agent.projectConfigPath) : join11(cwd, agent.projectConfigPath);
-  if (!existsSync9(configPath2)) return false;
+  const configPath2 = agent.configScope === "global" ? join12(homedir(), agent.projectConfigPath) : join12(cwd, agent.projectConfigPath);
+  if (!existsSync10(configPath2)) return false;
   try {
-    const existing = JSON.parse(readFileSync8(configPath2, "utf-8"));
+    const existing = JSON.parse(readFileSync9(configPath2, "utf-8"));
     if (agent.configFormat === "continue-config") {
       return Array.isArray(existing.mcpServers) && existing.mcpServers.some(
         (s) => s.name === UNERR_SERVER_KEY
@@ -7692,10 +7849,10 @@ function getConfigInfo(ide) {
   };
 }
 function writeMcpJsonFormat(configPath2, ide) {
-  if (existsSync9(configPath2)) {
+  if (existsSync10(configPath2)) {
     try {
       const existing = JSON.parse(
-        readFileSync8(configPath2, "utf-8")
+        readFileSync9(configPath2, "utf-8")
       );
       const current = existing.mcpServers?.[UNERR_SERVER_KEY];
       const desired = createUnerrServerEntry(ide);
@@ -7704,7 +7861,7 @@ function writeMcpJsonFormat(configPath2, ide) {
       }
       existing.mcpServers = existing.mcpServers ?? {};
       existing.mcpServers[UNERR_SERVER_KEY] = desired;
-      writeFileSync3(configPath2, JSON.stringify(existing, null, 2), "utf-8");
+      writeFileSync4(configPath2, JSON.stringify(existing, null, 2), "utf-8");
       return { path: configPath2, action: "updated" };
     } catch {
       return { path: configPath2, action: "skipped" };
@@ -7713,13 +7870,13 @@ function writeMcpJsonFormat(configPath2, ide) {
   const config = {
     mcpServers: { [UNERR_SERVER_KEY]: createUnerrServerEntry(ide) }
   };
-  writeFileSync3(configPath2, JSON.stringify(config, null, 2), "utf-8");
+  writeFileSync4(configPath2, JSON.stringify(config, null, 2), "utf-8");
   return { path: configPath2, action: "created" };
 }
 function writeSettingsJsonFormat(configPath2, ide) {
-  if (existsSync9(configPath2)) {
+  if (existsSync10(configPath2)) {
     try {
-      const existing = JSON.parse(readFileSync8(configPath2, "utf-8"));
+      const existing = JSON.parse(readFileSync9(configPath2, "utf-8"));
       const mcp = existing.mcp ?? {};
       const servers = mcp.servers ?? {};
       const current = servers[UNERR_SERVER_KEY];
@@ -7730,7 +7887,7 @@ function writeSettingsJsonFormat(configPath2, ide) {
       servers[UNERR_SERVER_KEY] = desired;
       mcp.servers = servers;
       existing.mcp = mcp;
-      writeFileSync3(configPath2, JSON.stringify(existing, null, 2), "utf-8");
+      writeFileSync4(configPath2, JSON.stringify(existing, null, 2), "utf-8");
       return { path: configPath2, action: "updated" };
     } catch {
       return { path: configPath2, action: "skipped" };
@@ -7739,14 +7896,14 @@ function writeSettingsJsonFormat(configPath2, ide) {
   const config = {
     mcp: { servers: { [UNERR_SERVER_KEY]: createUnerrServerEntry(ide) } }
   };
-  writeFileSync3(configPath2, JSON.stringify(config, null, 2), "utf-8");
+  writeFileSync4(configPath2, JSON.stringify(config, null, 2), "utf-8");
   return { path: configPath2, action: "created" };
 }
 function writeContinueFormat(configPath2, ide) {
   const entry = { name: UNERR_SERVER_KEY, ...createUnerrServerEntry(ide) };
-  if (existsSync9(configPath2)) {
+  if (existsSync10(configPath2)) {
     try {
-      const existing = JSON.parse(readFileSync8(configPath2, "utf-8"));
+      const existing = JSON.parse(readFileSync9(configPath2, "utf-8"));
       const servers = existing.mcpServers ?? [];
       const idx = servers.findIndex((s) => s.name === UNERR_SERVER_KEY);
       if (idx >= 0 && entryMatches(servers[idx], entry)) {
@@ -7758,21 +7915,21 @@ function writeContinueFormat(configPath2, ide) {
         servers.push(entry);
       }
       existing.mcpServers = servers;
-      writeFileSync3(configPath2, JSON.stringify(existing, null, 2), "utf-8");
+      writeFileSync4(configPath2, JSON.stringify(existing, null, 2), "utf-8");
       return { path: configPath2, action: "updated" };
     } catch {
       return { path: configPath2, action: "skipped" };
     }
   }
   const config = { mcpServers: [entry] };
-  writeFileSync3(configPath2, JSON.stringify(config, null, 2), "utf-8");
+  writeFileSync4(configPath2, JSON.stringify(config, null, 2), "utf-8");
   return { path: configPath2, action: "created" };
 }
 function writeCopilotJsonFormat(configPath2, ide) {
-  if (existsSync9(configPath2)) {
+  if (existsSync10(configPath2)) {
     try {
       const existing = JSON.parse(
-        readFileSync8(configPath2, "utf-8")
+        readFileSync9(configPath2, "utf-8")
       );
       const current = existing.mcpServers?.[UNERR_SERVER_KEY];
       const desired = createCopilotServerEntry(ide);
@@ -7781,7 +7938,7 @@ function writeCopilotJsonFormat(configPath2, ide) {
       }
       existing.mcpServers = existing.mcpServers ?? {};
       existing.mcpServers[UNERR_SERVER_KEY] = desired;
-      writeFileSync3(configPath2, JSON.stringify(existing, null, 2), "utf-8");
+      writeFileSync4(configPath2, JSON.stringify(existing, null, 2), "utf-8");
       return { path: configPath2, action: "updated" };
     } catch {
       return { path: configPath2, action: "skipped" };
@@ -7790,7 +7947,7 @@ function writeCopilotJsonFormat(configPath2, ide) {
   const config = {
     mcpServers: { [UNERR_SERVER_KEY]: createCopilotServerEntry(ide) }
   };
-  writeFileSync3(configPath2, JSON.stringify(config, null, 2), "utf-8");
+  writeFileSync4(configPath2, JSON.stringify(config, null, 2), "utf-8");
   return { path: configPath2, action: "created" };
 }
 var UNERR_SERVER_KEY, _resolvedCommand;
@@ -7813,8 +7970,8 @@ __export(detect_exports, {
   ideDisplayName: () => ideDisplayName,
   isGitRepo: () => isGitRepo2
 });
-import { existsSync as existsSync10 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { join as join13 } from "path";
 function classifyHost(remote) {
   const lower = remote.toLowerCase();
   if (lower.includes("github.com")) return "github";
@@ -7876,15 +8033,15 @@ async function detectIde(cwd) {
     }
   } catch {
   }
-  if (existsSync10(join12(cwd, ".cursor"))) return "cursor";
-  if (existsSync10(join12(cwd, ".windsurf"))) return "windsurf";
+  if (existsSync11(join13(cwd, ".cursor"))) return "cursor";
+  if (existsSync11(join13(cwd, ".windsurf"))) return "windsurf";
   if (termProgram === "vscode") return "vscode";
-  if (existsSync10(join12(cwd, ".vscode"))) return "vscode";
-  if (process.env.ZED_TERM === "true" || existsSync10(join12(cwd, ".zed")))
+  if (existsSync11(join13(cwd, ".vscode"))) return "vscode";
+  if (process.env.ZED_TERM === "true" || existsSync11(join13(cwd, ".zed")))
     return "zed";
   if (process.env.ANTIGRAVITY_PROJECT_DIR || process.env.ANTIGRAVITY_VERSION)
     return "antigravity";
-  if (existsSync10(join12(cwd, ".antigravity"))) return "antigravity";
+  if (existsSync11(join13(cwd, ".antigravity"))) return "antigravity";
   return "unknown";
 }
 function detectAgentNameFromEnv() {
@@ -8210,8 +8367,8 @@ var init_config_verify = __esm({
 
 // src/utils/log-paths.ts
 import { randomBytes } from "crypto";
-import { existsSync as existsSync12, readdirSync as readdirSync3, statSync as statSync2, unlinkSync as unlinkSync2 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync4, statSync as statSync3, unlinkSync as unlinkSync2 } from "fs";
+import { join as join15 } from "path";
 function getOrCreateSid() {
   if (_sid) return _sid;
   const fromEnv = process.env[ENV_VAR];
@@ -8224,10 +8381,10 @@ function getOrCreateSid() {
   return _sid;
 }
 function repoLogsDir(repoRoot) {
-  return join14(repoRoot, ".unerr", "logs");
+  return join15(repoRoot, ".unerr", "logs");
 }
 function globalLogsDir(globalRoot) {
-  return join14(globalRoot, "logs");
+  return join15(globalRoot, "logs");
 }
 function isLegacyTimestampedSession(name) {
   return /^session-\d{4}-\d{2}-\d{2}-\d{6}\.log(?:\.\d+)?$/.test(name);
@@ -8240,14 +8397,14 @@ function isLegacyName(name) {
   return false;
 }
 function cleanupLegacyLogs(dir) {
-  if (!existsSync12(dir)) return 0;
+  if (!existsSync13(dir)) return 0;
   let removed = 0;
   try {
-    for (const name of readdirSync3(dir)) {
+    for (const name of readdirSync4(dir)) {
       if (!isLegacyName(name)) continue;
-      const full = join14(dir, name);
+      const full = join15(dir, name);
       try {
-        if (!statSync2(full).isFile()) continue;
+        if (!statSync3(full).isFile()) continue;
         unlinkSync2(full);
         removed++;
       } catch {
@@ -8265,14 +8422,14 @@ var init_log_paths = __esm({
     SID_RE = /^[a-f0-9]{6}$/;
     _sid = null;
     repoLog = {
-      proxy: (repoRoot) => join14(repoLogsDir(repoRoot), "proxy.log"),
-      bridge: (repoRoot) => join14(repoLogsDir(repoRoot), "bridge.log"),
-      session: (repoRoot) => join14(repoLogsDir(repoRoot), "session.log"),
-      events: (repoRoot) => join14(repoLogsDir(repoRoot), "events.jsonl")
+      proxy: (repoRoot) => join15(repoLogsDir(repoRoot), "proxy.log"),
+      bridge: (repoRoot) => join15(repoLogsDir(repoRoot), "bridge.log"),
+      session: (repoRoot) => join15(repoLogsDir(repoRoot), "session.log"),
+      events: (repoRoot) => join15(repoLogsDir(repoRoot), "events.jsonl")
     };
     globalLog = {
-      unerrd: (globalRoot) => join14(globalLogsDir(globalRoot), "unerrd.log"),
-      events: (globalRoot) => join14(globalLogsDir(globalRoot), "events.jsonl")
+      unerrd: (globalRoot) => join15(globalLogsDir(globalRoot), "unerrd.log"),
+      events: (globalRoot) => join15(globalLogsDir(globalRoot), "events.jsonl")
     };
     LEGACY_PREFIXES = ["mcp-", "child-"];
     LEGACY_EXACT = /* @__PURE__ */ new Set([
@@ -8294,9 +8451,9 @@ __export(startup_log_exports, {
 });
 import {
   appendFileSync as appendFileSync4,
-  mkdirSync as mkdirSync7,
-  readFileSync as readFileSync10,
-  writeFileSync as writeFileSync5
+  mkdirSync as mkdirSync8,
+  readFileSync as readFileSync11,
+  writeFileSync as writeFileSync6
 } from "fs";
 import { dirname as dirname5 } from "path";
 function stripAnsi(s) {
@@ -8307,10 +8464,10 @@ function stripAnsi(s) {
 }
 function rotateIfNeeded(filePath, maxLines, keepLines) {
   try {
-    const content = readFileSync10(filePath, "utf-8");
+    const content = readFileSync11(filePath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     if (lines.length > maxLines) {
-      writeFileSync5(filePath, `${lines.slice(-keepLines).join("\n")}
+      writeFileSync6(filePath, `${lines.slice(-keepLines).join("\n")}
 `);
     }
   } catch {
@@ -8318,7 +8475,7 @@ function rotateIfNeeded(filePath, maxLines, keepLines) {
 }
 function initFileLog(cwd) {
   _fileLogPath = repoLog.events(cwd);
-  mkdirSync7(dirname5(_fileLogPath), { recursive: true });
+  mkdirSync8(dirname5(_fileLogPath), { recursive: true });
   rotateIfNeeded(_fileLogPath, 2e3, 1e3);
 }
 function writeToFile(level, message, meta) {
@@ -8903,9 +9060,9 @@ __export(settings_exports, {
   resolveEmbeddingEndpoint: () => resolveEmbeddingEndpoint,
   resolveInferenceEndpoint: () => resolveInferenceEndpoint
 });
-import { existsSync as existsSync16, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync15 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 import { z } from "zod";
 function resolveEmbeddingEndpoint(config) {
   const e = config.embedding;
@@ -8926,18 +9083,18 @@ function resolveInferenceEndpoint(config) {
   };
 }
 function loadJsonFile(filePath) {
-  if (!existsSync16(filePath)) return {};
+  if (!existsSync17(filePath)) return {};
   try {
-    return JSON.parse(readFileSync14(filePath, "utf-8"));
+    return JSON.parse(readFileSync15(filePath, "utf-8"));
   } catch {
     return {};
   }
 }
 function loadSettings(cwd) {
   const projectDir = cwd ?? process.cwd();
-  const userSettings = loadJsonFile(join18(homedir5(), ".unerr", "settings.json"));
+  const userSettings = loadJsonFile(join19(homedir5(), ".unerr", "settings.json"));
   const projectSettings = loadJsonFile(
-    join18(projectDir, ".unerr", "settings.json")
+    join19(projectDir, ".unerr", "settings.json")
   );
   const envOverrides = {};
   if (process.env.ANTHROPIC_API_KEY)
@@ -9067,24 +9224,24 @@ __export(persistent_db_exports, {
   hasPersistedGraph: () => hasPersistedGraph,
   openPersistentDb: () => openPersistentDb
 });
-import { existsSync as existsSync17, mkdirSync as mkdirSync9, statSync as statSync4 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync10, statSync as statSync5 } from "fs";
+import { join as join20 } from "path";
 async function openPersistentDb(projectRoot) {
-  const unerrDir2 = join19(projectRoot, UNERR_DIR2);
-  mkdirSync9(unerrDir2, { recursive: true });
-  const dbPath = join19(unerrDir2, GRAPH_DB_FILENAME);
-  const isNew = !existsSync17(dbPath);
+  const unerrDir2 = join20(projectRoot, UNERR_DIR2);
+  mkdirSync10(unerrDir2, { recursive: true });
+  const dbPath = join20(unerrDir2, GRAPH_DB_FILENAME);
+  const isNew = !existsSync18(dbPath);
   const db = await createSqliteDb(dbPath);
   return { db, isNew, dbPath };
 }
 function getDbPath(projectRoot) {
-  return join19(projectRoot, UNERR_DIR2, GRAPH_DB_FILENAME);
+  return join20(projectRoot, UNERR_DIR2, GRAPH_DB_FILENAME);
 }
 function hasPersistedGraph(projectRoot) {
   const dbPath = getDbPath(projectRoot);
-  if (!existsSync17(dbPath)) return false;
+  if (!existsSync18(dbPath)) return false;
   try {
-    const stat2 = statSync4(dbPath);
+    const stat2 = statSync5(dbPath);
     return stat2.size > 5e4;
   } catch {
     return false;
@@ -9093,7 +9250,7 @@ function hasPersistedGraph(projectRoot) {
 function getDbMtime(projectRoot) {
   const dbPath = getDbPath(projectRoot);
   try {
-    return statSync4(dbPath).mtimeMs;
+    return statSync5(dbPath).mtimeMs;
   } catch {
     return 0;
   }
@@ -9574,8 +9731,8 @@ var init_local_chat_provider = __esm({
 });
 
 // src/proxy/nudge-state.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync10, readFileSync as readFileSync15, writeFileSync as writeFileSync6 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync16, writeFileSync as writeFileSync7 } from "fs";
+import { join as join21 } from "path";
 function defaultState() {
   return {
     tier0_emitted: false,
@@ -9600,13 +9757,13 @@ function defaultState() {
 }
 function statePath(cwd) {
   const sessionId = process.env.UNERR_SESSION_ID ?? `pid-${process.pid}`;
-  return join20(cwd, ".unerr", "state", `nudge-${sessionId}.flags`);
+  return join21(cwd, ".unerr", "state", `nudge-${sessionId}.flags`);
 }
 function readNudgeState(cwd) {
   try {
     const path7 = statePath(cwd);
-    if (!existsSync18(path7)) return defaultState();
-    const raw = readFileSync15(path7, "utf8");
+    if (!existsSync19(path7)) return defaultState();
+    const raw = readFileSync16(path7, "utf8");
     const parsed = JSON.parse(raw);
     return {
       tier0_emitted: Boolean(parsed.tier0_emitted),
@@ -9639,8 +9796,8 @@ function writeNudgeState(cwd, state) {
   try {
     const path7 = statePath(cwd);
     const dir = path7.slice(0, path7.lastIndexOf("/"));
-    if (!existsSync18(dir)) mkdirSync10(dir, { recursive: true });
-    writeFileSync6(path7, JSON.stringify(state), "utf8");
+    if (!existsSync19(dir)) mkdirSync11(dir, { recursive: true });
+    writeFileSync7(path7, JSON.stringify(state), "utf8");
   } catch {
   }
 }
@@ -9664,8 +9821,8 @@ __export(metrics_store_exports, {
   closeMetricsStore: () => closeMetricsStore,
   openMetricsStore: () => openMetricsStore
 });
-import { mkdirSync as mkdirSync11 } from "fs";
-import { join as join21 } from "path";
+import { mkdirSync as mkdirSync12 } from "fs";
+import { join as join22 } from "path";
 import Database from "better-sqlite3";
 function reconcileAdditiveColumns(db) {
   for (const { table: table2, column, decl } of ADDITIVE_COLUMNS) {
@@ -9678,8 +9835,8 @@ function reconcileAdditiveColumns(db) {
 function openMetricsStore(unerrDir2) {
   let store = instances.get(unerrDir2);
   if (!store) {
-    mkdirSync11(unerrDir2, { recursive: true });
-    store = new MetricsStore(join21(unerrDir2, "metrics.db"));
+    mkdirSync12(unerrDir2, { recursive: true });
+    store = new MetricsStore(join22(unerrDir2, "metrics.db"));
     instances.set(unerrDir2, store);
   }
   return store;
@@ -10520,14 +10677,14 @@ __export(shell_compression_log_exports, {
   readRecentCompressionLogs: () => readRecentCompressionLogs,
   readRecentFileReadLogs: () => readRecentFileReadLogs
 });
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 function parseTs(ts) {
   const n = Date.parse(ts);
   return Number.isNaN(n) ? Date.now() : n;
 }
 function appendCompressionLog(cwd, entry) {
   try {
-    const store = openMetricsStore(join22(cwd, ".unerr"));
+    const store = openMetricsStore(join23(cwd, ".unerr"));
     store.insertCompression({
       ts: parseTs(entry.ts),
       ts_iso: entry.ts,
@@ -10545,7 +10702,7 @@ function appendCompressionLog(cwd, entry) {
 }
 function appendFileReadLog(cwd, entry) {
   try {
-    const store = openMetricsStore(join22(cwd, ".unerr"));
+    const store = openMetricsStore(join23(cwd, ".unerr"));
     store.insertFileRead({
       ts: parseTs(entry.ts),
       ts_iso: entry.ts,
@@ -10562,7 +10719,7 @@ function appendFileReadLog(cwd, entry) {
 }
 function readRecentFileReadLogs(cwd, limit = 10) {
   try {
-    const store = openMetricsStore(join22(cwd, ".unerr"));
+    const store = openMetricsStore(join23(cwd, ".unerr"));
     return store.recentFileReads(limit).map((r) => ({
       ts: r.ts_iso,
       file: r.file,
@@ -10579,7 +10736,7 @@ function readRecentFileReadLogs(cwd, limit = 10) {
 }
 function readRecentCompressionLogs(cwd, limit = 10) {
   try {
-    const store = openMetricsStore(join22(cwd, ".unerr"));
+    const store = openMetricsStore(join23(cwd, ".unerr"));
     return store.recentCompression(limit).map((r) => ({
       ts: r.ts_iso,
       command: r.command,
@@ -10609,16 +10766,16 @@ __export(shell_stats_exports, {
   readShellCompressionAggregate: () => readShellCompressionAggregate,
   recordShellCompressionEvent: () => recordShellCompressionEvent
 });
-import { existsSync as existsSync19, mkdirSync as mkdirSync12, readFileSync as readFileSync16, writeFileSync as writeFileSync7 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync13, readFileSync as readFileSync17, writeFileSync as writeFileSync8 } from "fs";
+import { join as join24 } from "path";
 function estimateRoughTokens(s) {
   return Math.max(1, estimateTokenCount(s));
 }
 function recordShellCompressionEvent(cwd, category, original, compressed) {
   try {
-    const dir = join23(cwd, ".unerr", "state");
-    mkdirSync12(dir, { recursive: true });
-    const path7 = join23(dir, "shell_compression_stats.json");
+    const dir = join24(cwd, ".unerr", "state");
+    mkdirSync13(dir, { recursive: true });
+    const path7 = join24(dir, "shell_compression_stats.json");
     const origT = estimateRoughTokens(original);
     const outT = estimateRoughTokens(compressed);
     const saved = Math.max(0, origT - outT);
@@ -10628,11 +10785,11 @@ function recordShellCompressionEvent(cwd, category, original, compressed) {
       byCategory: {},
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    if (existsSync19(path7)) {
+    if (existsSync20(path7)) {
       agg = {
         ...agg,
         ...JSON.parse(
-          readFileSync16(path7, "utf-8")
+          readFileSync17(path7, "utf-8")
         )
       };
     }
@@ -10644,15 +10801,15 @@ function recordShellCompressionEvent(cwd, category, original, compressed) {
       savedApprox: prev.savedApprox + saved
     };
     agg.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    writeFileSync7(path7, JSON.stringify(agg));
+    writeFileSync8(path7, JSON.stringify(agg));
   } catch {
   }
 }
 function readShellCompressionAggregate(cwd) {
   try {
-    const path7 = join23(cwd, ".unerr", "state", "shell_compression_stats.json");
-    if (!existsSync19(path7)) return null;
-    return JSON.parse(readFileSync16(path7, "utf-8"));
+    const path7 = join24(cwd, ".unerr", "state", "shell_compression_stats.json");
+    if (!existsSync20(path7)) return null;
+    return JSON.parse(readFileSync17(path7, "utf-8"));
   } catch {
     return null;
   }
@@ -10674,14 +10831,14 @@ __export(session_edit_log_exports, {
 });
 import {
   appendFileSync as appendFileSync6,
-  existsSync as existsSync22,
-  mkdirSync as mkdirSync14,
-  readFileSync as readFileSync20,
+  existsSync as existsSync23,
+  mkdirSync as mkdirSync15,
+  readFileSync as readFileSync21,
   rmSync as rmSync2
 } from "fs";
-import { dirname as dirname7, join as join27 } from "path";
+import { dirname as dirname7, join as join28 } from "path";
 function editLogPath(unerrDir2) {
-  return join27(unerrDir2, "state", EDIT_LOG_FILE);
+  return join28(unerrDir2, "state", EDIT_LOG_FILE);
 }
 function cap(content) {
   if (content === null) return null;
@@ -10691,7 +10848,7 @@ function recordEdit(unerrDir2, event) {
   try {
     const path7 = editLogPath(unerrDir2);
     const dir = dirname7(path7);
-    if (!existsSync22(dir)) mkdirSync14(dir, { recursive: true });
+    if (!existsSync23(dir)) mkdirSync15(dir, { recursive: true });
     const line = `${JSON.stringify({
       ts: event.ts,
       file_path: event.file_path,
@@ -10708,8 +10865,8 @@ function recordEdit(unerrDir2, event) {
 function readEditLog(unerrDir2) {
   try {
     const path7 = editLogPath(unerrDir2);
-    if (!existsSync22(path7)) return [];
-    const raw = readFileSync20(path7, "utf-8");
+    if (!existsSync23(path7)) return [];
+    const raw = readFileSync21(path7, "utf-8");
     const events = [];
     for (const line of raw.split("\n")) {
       const trimmed = line.trim();
@@ -10748,11 +10905,11 @@ __export(blast_radius_protocol_exports, {
   handleBlastRadiusRequest: () => handleBlastRadiusRequest,
   recordBlastRadiusTelemetry: () => recordBlastRadiusTelemetry
 });
-import { isAbsolute, relative } from "path";
+import { isAbsolute, relative as relative2 } from "path";
 async function handleBlastRadiusRequest(graph, params, projectRoot = process.cwd()) {
   const rawPath = params?.file_path;
   if (!rawPath || !graph) return { warnings: [], boundary_violations: [] };
-  const filePath = isAbsolute(rawPath) ? relative(projectRoot, rawPath) : rawPath;
+  const filePath = isAbsolute(rawPath) ? relative2(projectRoot, rawPath) : rawPath;
   const warnings = await computeEditImpact(
     graph,
     filePath,
@@ -11029,12 +11186,12 @@ __export(review_protocol_exports, {
   REVIEW_EDIT_METHOD: () => REVIEW_EDIT_METHOD,
   handleReviewEditRequest: () => handleReviewEditRequest
 });
-import { isAbsolute as isAbsolute2, relative as relative2 } from "path";
+import { isAbsolute as isAbsolute2, relative as relative3 } from "path";
 async function handleReviewEditRequest(graph, params, deps = {}) {
   const rawPath = params?.file_path;
   if (!rawPath || !graph) return EMPTY_RESULT;
   const projectRoot = deps.projectRoot ?? process.cwd();
-  const filePath = isAbsolute2(rawPath) ? relative2(projectRoot, rawPath) : rawPath;
+  const filePath = isAbsolute2(rawPath) ? relative3(projectRoot, rawPath) : rawPath;
   const reviewGraph = graph;
   const oldContent = params?.old_content ?? null;
   const newContent = params?.new_content ?? null;
@@ -11110,13 +11267,13 @@ var init_capability = __esm({
 });
 
 // src/tracking/agent-transcript/config-flag.ts
-import { existsSync as existsSync26, readFileSync as readFileSync22 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync23 } from "fs";
+import { join as join32 } from "path";
 function readAgentTranscriptsFlag(cwd) {
   try {
-    const configPath2 = join31(cwd, ".unerr", "config.json");
-    if (!existsSync26(configPath2)) return false;
-    const raw = JSON.parse(readFileSync22(configPath2, "utf-8"));
+    const configPath2 = join32(cwd, ".unerr", "config.json");
+    if (!existsSync27(configPath2)) return false;
+    const raw = JSON.parse(readFileSync23(configPath2, "utf-8"));
     return raw[READ_AGENT_TRANSCRIPTS_KEY] === true;
   } catch {
     return false;
@@ -11131,17 +11288,17 @@ var init_config_flag = __esm({
 });
 
 // src/tracking/agent-transcript/claude-jsonl.ts
-import { createReadStream, existsSync as existsSync27 } from "fs";
+import { createReadStream, existsSync as existsSync28 } from "fs";
 import { readdir } from "fs/promises";
 import { homedir as homedir8 } from "os";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 import { createInterface as createInterface2 } from "readline";
 function mangleCwd(cwd) {
   const trimmed = cwd.replace(/\/+$/, "");
   return trimmed.replace(/\//g, "-");
 }
 function claudeProjectDir(repoCwd, home = homedir8()) {
-  return join32(home, ".claude", "projects", mangleCwd(repoCwd));
+  return join33(home, ".claude", "projects", mangleCwd(repoCwd));
 }
 function num(v) {
   return typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
@@ -11306,14 +11463,14 @@ async function readClaudeTranscript(opts) {
   const projectDir = opts.projectDirOverride ?? claudeProjectDir(opts.repoCwd, opts.home);
   try {
     if (opts.sessionId) {
-      const file = join32(projectDir, `${opts.sessionId}.jsonl`);
-      if (!existsSync27(file)) return [];
+      const file = join33(projectDir, `${opts.sessionId}.jsonl`);
+      if (!existsSync28(file)) return [];
       const nodes = await parseFile(file);
       return buildTurns(nodes, opts.sessionId);
     }
-    if (!existsSync27(projectDir)) return [];
+    if (!existsSync28(projectDir)) return [];
     const entries = await readdir(projectDir, { withFileTypes: true });
-    const jsonlFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => join32(projectDir, e.name));
+    const jsonlFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => join33(projectDir, e.name));
     const all = [];
     for (const file of jsonlFiles) {
       const nodes = await parseFile(file);
@@ -11361,27 +11518,27 @@ var init_claude_jsonl = __esm({
 });
 
 // src/tracking/agent-transcript/cursor-sqlite.ts
-import { existsSync as existsSync28, readdirSync as readdirSync6, readFileSync as readFileSync23 } from "fs";
+import { existsSync as existsSync29, readdirSync as readdirSync7, readFileSync as readFileSync24 } from "fs";
 import { homedir as homedir9, platform as platform2 } from "os";
-import { join as join33, normalize as normalize3 } from "path";
+import { join as join34, normalize as normalize3 } from "path";
 function cursorTelemetryDbPath(home = homedir9()) {
-  return join33(home, ".cursor", "ai-tracking", "ai-code-tracking.db");
+  return join34(home, ".cursor", "ai-tracking", "ai-code-tracking.db");
 }
 function cursorUserDataDir(home = homedir9()) {
   const p = platform2();
   if (p === "darwin")
-    return join33(home, "Library", "Application Support", "Cursor", "User");
+    return join34(home, "Library", "Application Support", "Cursor", "User");
   if (p === "win32") {
-    const appData = process.env.APPDATA ?? join33(home, "AppData", "Roaming");
-    return join33(appData, "Cursor", "User");
+    const appData = process.env.APPDATA ?? join34(home, "AppData", "Roaming");
+    return join34(appData, "Cursor", "User");
   }
-  return join33(home, ".config", "Cursor", "User");
+  return join34(home, ".config", "Cursor", "User");
 }
 function cursorGlobalVscdbPath(home = homedir9()) {
-  return join33(cursorUserDataDir(home), "globalStorage", "state.vscdb");
+  return join34(cursorUserDataDir(home), "globalStorage", "state.vscdb");
 }
 async function openReadOnly(path7) {
-  if (!existsSync28(path7)) return null;
+  if (!existsSync29(path7)) return null;
   try {
     const mod = await import("better-sqlite3");
     const Database2 = mod.default ?? mod;
@@ -11480,18 +11637,18 @@ async function readCursorTranscript(opts) {
   }
 }
 function findWorkspaceHashesForRepo(repoCwd, home = homedir9()) {
-  const wsRoot = join33(cursorUserDataDir(home), "workspaceStorage");
-  if (!existsSync28(wsRoot)) return [];
+  const wsRoot = join34(cursorUserDataDir(home), "workspaceStorage");
+  if (!existsSync29(wsRoot)) return [];
   const normalizedCwd = normalize3(repoCwd).replace(/\/+$/, "");
   const hashes = [];
   try {
-    const entries = readdirSync6(wsRoot, { withFileTypes: true });
+    const entries = readdirSync7(wsRoot, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const wsJsonPath = join33(wsRoot, entry.name, "workspace.json");
-      if (!existsSync28(wsJsonPath)) continue;
+      const wsJsonPath = join34(wsRoot, entry.name, "workspace.json");
+      if (!existsSync29(wsJsonPath)) continue;
       try {
-        const raw = JSON.parse(readFileSync23(wsJsonPath, "utf-8"));
+        const raw = JSON.parse(readFileSync24(wsJsonPath, "utf-8"));
         const uri = raw.folder ?? raw.workspace ?? "";
         const decoded = uri.startsWith("file://") ? decodeURIComponent(uri.slice(7)) : uri;
         if (normalize3(decoded).replace(/\/+$/, "") === normalizedCwd) {
@@ -11601,7 +11758,7 @@ async function readCursorStateVscdb(opts) {
       if (hashes.length === 0) return [];
       composerIds = [];
       for (const hash2 of hashes) {
-        const wsDbPath = join33(
+        const wsDbPath = join34(
           cursorUserDataDir(home),
           "workspaceStorage",
           hash2,
@@ -11718,13 +11875,13 @@ var init_transcript_materializer = __esm({
 
 // src/hooks/prompt-capture.ts
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync29, readFileSync as readFileSync24 } from "fs";
-import { join as join34 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync25 } from "fs";
+import { join as join35 } from "path";
 function readCapturePromptsFlag(cwd) {
   try {
-    const configPath2 = join34(cwd, ".unerr", "config.json");
-    if (!existsSync29(configPath2)) return false;
-    const raw = JSON.parse(readFileSync24(configPath2, "utf-8"));
+    const configPath2 = join35(cwd, ".unerr", "config.json");
+    if (!existsSync30(configPath2)) return false;
+    const raw = JSON.parse(readFileSync25(configPath2, "utf-8"));
     return raw.capture_prompts === true;
   } catch {
     return false;
@@ -11734,8 +11891,8 @@ function readProxySessionId(unerrDir2) {
   const fromEnv = process.env.UNERR_SESSION_ID;
   if (fromEnv && fromEnv.length > 0) return fromEnv;
   try {
-    const id = readFileSync24(
-      join34(unerrDir2, "state", "session.id"),
+    const id = readFileSync25(
+      join35(unerrDir2, "state", "session.id"),
       "utf-8"
     ).trim();
     return id.length > 0 ? id : null;
@@ -11920,8 +12077,8 @@ __export(session_summary_writer_exports, {
   readLastSession: () => readLastSession,
   writeSessionSummary: () => writeSessionSummary
 });
-import { existsSync as existsSync31, mkdirSync as mkdirSync16, readFileSync as readFileSync26, writeFileSync as writeFileSync10 } from "fs";
-import { join as join36 } from "path";
+import { existsSync as existsSync32, mkdirSync as mkdirSync17, readFileSync as readFileSync27, writeFileSync as writeFileSync11 } from "fs";
+import { join as join37 } from "path";
 function writeSessionSummary(unerrDir2, ctx) {
   if (ctx.entries.length === 0) return null;
   try {
@@ -11998,9 +12155,9 @@ function writeSessionSummary(unerrDir2, ctx) {
 }
 function readLastSession(unerrDir2) {
   try {
-    const pointerPath = join36(unerrDir2, "state", "last_session.json");
-    if (!existsSync31(pointerPath)) return null;
-    const content = readFileSync26(pointerPath, "utf-8");
+    const pointerPath = join37(unerrDir2, "state", "last_session.json");
+    if (!existsSync32(pointerPath)) return null;
+    const content = readFileSync27(pointerPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -12008,12 +12165,12 @@ function readLastSession(unerrDir2) {
 }
 function writeLastSessionPointer(unerrDir2, sessionId, record) {
   try {
-    const stateDir = join36(unerrDir2, "state");
-    if (!existsSync31(stateDir)) {
-      mkdirSync16(stateDir, { recursive: true });
+    const stateDir = join37(unerrDir2, "state");
+    if (!existsSync32(stateDir)) {
+      mkdirSync17(stateDir, { recursive: true });
     }
-    const pointerPath = join36(stateDir, "last_session.json");
-    writeFileSync10(pointerPath, JSON.stringify(record, null, 2), "utf-8");
+    const pointerPath = join37(stateDir, "last_session.json");
+    writeFileSync11(pointerPath, JSON.stringify(record, null, 2), "utf-8");
   } catch {
   }
 }
@@ -12341,8 +12498,8 @@ var incomplete_work_exports = {};
 __export(incomplete_work_exports, {
   IncompleteWorkDetector: () => IncompleteWorkDetector
 });
-import { existsSync as existsSync32, mkdirSync as mkdirSync17, readFileSync as readFileSync27, writeFileSync as writeFileSync11 } from "fs";
-import { join as join37 } from "path";
+import { existsSync as existsSync33, mkdirSync as mkdirSync18, readFileSync as readFileSync28, writeFileSync as writeFileSync12 } from "fs";
+import { join as join38 } from "path";
 function severityRank(severity) {
   switch (severity) {
     case "high":
@@ -12463,10 +12620,10 @@ var init_incomplete_work = __esm({
       persistItems(items) {
         if (!this.unerrDir) return false;
         try {
-          const stateDir = join37(this.unerrDir, "state");
-          if (!existsSync32(stateDir)) mkdirSync17(stateDir, { recursive: true });
-          const filePath = join37(stateDir, PERSISTENCE_FILE);
-          writeFileSync11(
+          const stateDir = join38(this.unerrDir, "state");
+          if (!existsSync33(stateDir)) mkdirSync18(stateDir, { recursive: true });
+          const filePath = join38(stateDir, PERSISTENCE_FILE);
+          writeFileSync12(
             filePath,
             JSON.stringify({
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -12485,9 +12642,9 @@ var init_incomplete_work = __esm({
        */
       static readPersistedItems(unerrDir2) {
         try {
-          const filePath = join37(unerrDir2, "state", PERSISTENCE_FILE);
-          if (!existsSync32(filePath)) return [];
-          const data = JSON.parse(readFileSync27(filePath, "utf-8"));
+          const filePath = join38(unerrDir2, "state", PERSISTENCE_FILE);
+          if (!existsSync33(filePath)) return [];
+          const data = JSON.parse(readFileSync28(filePath, "utf-8"));
           return data.items ?? [];
         } catch {
           return [];
@@ -12709,163 +12866,6 @@ var init_session_persistence = __esm({
   }
 });
 
-// src/intelligence/local-snapshot.ts
-var local_snapshot_exports = {};
-__export(local_snapshot_exports, {
-  getSnapshotMeta: () => getSnapshotMeta,
-  loadLocalSnapshot: () => loadLocalSnapshot,
-  persistLocalSnapshot: () => persistLocalSnapshot,
-  shouldReindex: () => shouldReindex,
-  snapshotPath: () => snapshotPath
-});
-import {
-  existsSync as existsSync33,
-  mkdirSync as mkdirSync18,
-  readFileSync as readFileSync29,
-  readdirSync as readdirSync7,
-  statSync as statSync6,
-  writeFileSync as writeFileSync12
-} from "fs";
-import { join as join39 } from "path";
-function snapshotPath(projectRoot) {
-  return join39(projectRoot, ".unerr", "snapshots", SNAPSHOT_FILENAME);
-}
-function getSnapshotMeta(projectRoot) {
-  const path7 = snapshotPath(projectRoot);
-  return { path: path7, exists: existsSync33(path7) };
-}
-function shouldReindex(projectRoot) {
-  const dbPath = join39(projectRoot, ".unerr", "graph.db");
-  const snPath = snapshotPath(projectRoot);
-  let referenceMtime = null;
-  if (existsSync33(dbPath)) {
-    try {
-      referenceMtime = statSync6(dbPath).mtimeMs;
-    } catch {
-    }
-  }
-  if (referenceMtime === null && existsSync33(snPath)) {
-    try {
-      referenceMtime = statSync6(snPath).mtimeMs;
-    } catch {
-    }
-  }
-  if (referenceMtime === null) return true;
-  return hasNewerSource(projectRoot, referenceMtime);
-}
-async function persistLocalSnapshot(projectRoot, repoId, entities, edges) {
-  const snapshotsDir = join39(projectRoot, ".unerr", "snapshots");
-  mkdirSync18(snapshotsDir, { recursive: true });
-  const envelope = {
-    version: 1,
-    repoId,
-    orgId: "local",
-    entities,
-    edges,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  const { pack } = await import("msgpackr");
-  const { gzipSync: gzipSync3 } = await import("zlib");
-  const packed = pack(envelope);
-  const compressed = gzipSync3(packed);
-  const path7 = snapshotPath(projectRoot);
-  writeFileSync12(path7, compressed);
-  return path7;
-}
-async function loadLocalSnapshot(projectRoot, graphStore) {
-  const path7 = snapshotPath(projectRoot);
-  if (!existsSync33(path7)) return false;
-  try {
-    const { unpack } = await import("msgpackr");
-    const { gunzipSync: gunzipSync3 } = await import("zlib");
-    const raw = readFileSync29(path7);
-    const buffer = gunzipSync3(raw);
-    const envelope = unpack(buffer);
-    await graphStore.loadSnapshot(envelope);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function hasNewerSource(projectRoot, snapshotMtime) {
-  return scanDirForNewer(projectRoot, snapshotMtime);
-}
-function scanDirForNewer(dir, threshold) {
-  let entries;
-  try {
-    entries = readdirSync7(dir);
-  } catch {
-    return false;
-  }
-  for (const entry of entries) {
-    if (EXCLUDED_DIRS.has(entry)) continue;
-    if (entry.startsWith(".") && entry !== ".") continue;
-    const fullPath = join39(dir, entry);
-    let stat2;
-    try {
-      stat2 = statSync6(fullPath);
-    } catch {
-      continue;
-    }
-    if (stat2.isDirectory()) {
-      if (scanDirForNewer(fullPath, threshold)) return true;
-    } else if (stat2.isFile()) {
-      const ext = fullPath.slice(fullPath.lastIndexOf(".")).toLowerCase();
-      if (SOURCE_EXTENSIONS.has(ext) && stat2.mtimeMs > threshold) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-var SNAPSHOT_FILENAME, SOURCE_EXTENSIONS, EXCLUDED_DIRS;
-var init_local_snapshot = __esm({
-  "src/intelligence/local-snapshot.ts"() {
-    "use strict";
-    SNAPSHOT_FILENAME = "graph.msgpack.gz";
-    SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
-      ".ts",
-      ".tsx",
-      ".js",
-      ".jsx",
-      ".mjs",
-      ".cjs",
-      ".py",
-      ".go",
-      ".java",
-      ".rs",
-      ".c",
-      ".h",
-      ".cpp",
-      ".cc",
-      ".cxx",
-      ".hpp"
-    ]);
-    EXCLUDED_DIRS = /* @__PURE__ */ new Set([
-      "node_modules",
-      "dist",
-      "build",
-      "out",
-      ".git",
-      ".hg",
-      ".svn",
-      "coverage",
-      "__pycache__",
-      ".mypy_cache",
-      ".pytest_cache",
-      "vendor",
-      "target",
-      ".next",
-      ".nuxt",
-      ".output",
-      ".unerr",
-      ".cache",
-      ".turbo",
-      ".parcel-cache"
-    ]);
-  }
-});
-
 // src/utils/format-error.ts
 function formatUnknownError(err2) {
   if (err2 instanceof Error) return err2.stack ?? err2.message;
@@ -58513,58 +58513,44 @@ function registerBranchesCommand(program2) {
 init_git_review();
 import {
   appendFileSync as appendFileSync2,
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync6,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync7,
   rmSync,
-  writeFileSync as writeFileSync2
+  writeFileSync as writeFileSync3
 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import pc2 from "picocolors";
 
 // src/review/standalone-load.ts
+init_local_snapshot();
 init_git_review();
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import { join as join6 } from "path";
-import { gunzipSync } from "zlib";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { join as join7 } from "path";
 async function loadStandaloneGraph(cwd) {
-  const configPath2 = join6(cwd, ".unerr", "config.json");
-  if (!existsSync5(configPath2)) return null;
-  let repoId;
+  const configPath2 = join7(cwd, ".unerr", "config.json");
+  if (!existsSync6(configPath2)) return null;
   try {
-    const config = JSON.parse(readFileSync4(configPath2, "utf-8"));
+    const config = JSON.parse(readFileSync5(configPath2, "utf-8"));
     if (!config.repoId) return null;
-    repoId = config.repoId;
   } catch {
     return null;
   }
-  const snapshotsDir = join6(cwd, ".unerr", "snapshots");
-  const manifestsDir = join6(cwd, ".unerr", "manifests");
-  const manifestPath = join6(manifestsDir, `${repoId}.json`);
-  if (!existsSync5(manifestPath)) return null;
-  let snapshotPath2 = join6(snapshotsDir, `${repoId}.msgpack.gz`);
-  if (!existsSync5(snapshotPath2)) {
-    snapshotPath2 = join6(snapshotsDir, `${repoId}.msgpack`);
-  }
-  if (!existsSync5(snapshotPath2)) return null;
   try {
-    const { default: CozoDbConstructor } = await import("cozo-node");
+    const cozoModule = await import("cozo-node");
     const { CozoGraphStore: CozoGraphStore2 } = await Promise.resolve().then(() => (init_local_graph(), local_graph_exports));
-    const { unpack } = await import("msgpackr");
+    const CozoDbConstructor = cozoModule.default ? cozoModule.default.CozoDb : cozoModule.CozoDb;
     const db = new CozoDbConstructor();
     const graph = await CozoGraphStore2.create(db);
-    const raw = readFileSync4(snapshotPath2);
-    const buffer = snapshotPath2.endsWith(".gz") ? gunzipSync(raw) : raw;
-    const envelope = unpack(buffer);
-    await graph.loadSnapshot(envelope);
-    return graph;
+    const loaded = await loadLocalSnapshot(cwd, graph);
+    return loaded ? graph : null;
   } catch {
     return null;
   }
 }
 async function loadStandaloneNotes(cwd, sessionId = "review") {
-  const factsDbPath = join6(cwd, ".unerr", "facts.db");
-  if (!existsSync5(factsDbPath)) return null;
+  const factsDbPath = join7(cwd, ".unerr", "facts.db");
+  if (!existsSync6(factsDbPath)) return null;
   try {
     const { TemporalFactStore: TemporalFactStore2 } = await Promise.resolve().then(() => (init_temporal_facts(), temporal_facts_exports));
     const { NotesStore: NotesStore2 } = await Promise.resolve().then(() => (init_notes_store(), notes_store_exports));
@@ -58580,8 +58566,8 @@ init_types();
 init_git();
 
 // src/utils/log.ts
-import { appendFileSync, mkdirSync as mkdirSync3 } from "fs";
-import { join as join7 } from "path";
+import { appendFileSync, mkdirSync as mkdirSync4 } from "fs";
+import { join as join8 } from "path";
 var logFilePath = null;
 function timestamp() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -58642,24 +58628,24 @@ function registerCheckCommitCommand(program2) {
         return;
       }
       let blockingMode = opts.blocking ?? false;
-      const settingsPath = join9(cwd, ".unerr", "settings.json");
-      if (!blockingMode && existsSync7(settingsPath)) {
+      const settingsPath = join10(cwd, ".unerr", "settings.json");
+      if (!blockingMode && existsSync8(settingsPath)) {
         try {
           const settings = JSON.parse(
-            readFileSync6(settingsPath, "utf-8")
+            readFileSync7(settingsPath, "utf-8")
           );
           blockingMode = settings.hooks?.precommit?.blocking ?? false;
         } catch {
         }
       }
       logInfo("check-commit invoked", { blocking: blockingMode });
-      const configPath2 = join9(cwd, ".unerr", "config.json");
-      if (!existsSync7(configPath2)) {
+      const configPath2 = join10(cwd, ".unerr", "config.json");
+      if (!existsSync8(configPath2)) {
         logInfo("check-commit: no .unerr/config.json, skipping");
         return;
       }
       try {
-        const config = JSON.parse(readFileSync6(configPath2, "utf-8"));
+        const config = JSON.parse(readFileSync7(configPath2, "utf-8"));
         if (!config.repoId) {
           logInfo("check-commit: no repoId in config, skipping");
           return;
@@ -58753,7 +58739,7 @@ function renderFinding(f, verbose) {
   detail(`  \u2192 ${f.action}`);
 }
 function verdictStatePath(cwd) {
-  return join9(cwd, ".unerr", "state", "review-verdict.json");
+  return join10(cwd, ".unerr", "state", "review-verdict.json");
 }
 function persistVerdict(cwd, report, blocking, verdict) {
   const pending = {
@@ -58765,16 +58751,16 @@ function persistVerdict(cwd, report, blocking, verdict) {
     staged_at: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
-    const stateDir = join9(cwd, ".unerr", "state");
-    mkdirSync4(stateDir, { recursive: true });
-    writeFileSync2(verdictStatePath(cwd), JSON.stringify(pending), "utf-8");
+    const stateDir = join10(cwd, ".unerr", "state");
+    mkdirSync5(stateDir, { recursive: true });
+    writeFileSync3(verdictStatePath(cwd), JSON.stringify(pending), "utf-8");
   } catch {
   }
   try {
-    const logsDir = join9(cwd, ".unerr", "logs");
-    mkdirSync4(logsDir, { recursive: true });
+    const logsDir = join10(cwd, ".unerr", "logs");
+    mkdirSync5(logsDir, { recursive: true });
     appendFileSync2(
-      join9(logsDir, "review-verdicts.jsonl"),
+      join10(logsDir, "review-verdicts.jsonl"),
       `${JSON.stringify(pending)}
 `,
       "utf-8"
@@ -58784,10 +58770,10 @@ function persistVerdict(cwd, report, blocking, verdict) {
 }
 async function recordPendingVerdict(cwd) {
   const statePath2 = verdictStatePath(cwd);
-  if (!existsSync7(statePath2)) return;
+  if (!existsSync8(statePath2)) return;
   let pending;
   try {
-    pending = JSON.parse(readFileSync6(statePath2, "utf-8"));
+    pending = JSON.parse(readFileSync7(statePath2, "utf-8"));
   } catch {
     try {
       rmSync(statePath2, { force: true });
@@ -58823,19 +58809,19 @@ async function recordPendingVerdict(cwd) {
 
 // src/commands/compress-output.ts
 init_output_compressor();
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
+import { join as join11 } from "path";
 function loadEntityRiskMap(cwd) {
   const riskMap = /* @__PURE__ */ new Map();
   try {
-    const unerrDir2 = join10(cwd, ".unerr");
-    const configPath2 = join10(unerrDir2, "config.json");
-    if (!existsSync8(configPath2)) return riskMap;
-    const config = JSON.parse(readFileSync7(configPath2, "utf-8"));
+    const unerrDir2 = join11(cwd, ".unerr");
+    const configPath2 = join11(unerrDir2, "config.json");
+    if (!existsSync9(configPath2)) return riskMap;
+    const config = JSON.parse(readFileSync8(configPath2, "utf-8"));
     if (!config.repoId) return riskMap;
-    const riskCachePath = join10(unerrDir2, "state", "entity_risk_cache.json");
-    if (!existsSync8(riskCachePath)) return riskMap;
-    const data = JSON.parse(readFileSync7(riskCachePath, "utf-8"));
+    const riskCachePath = join11(unerrDir2, "state", "entity_risk_cache.json");
+    if (!existsSync9(riskCachePath)) return riskMap;
+    const data = JSON.parse(readFileSync8(riskCachePath, "utf-8"));
     for (const [key, info2] of Object.entries(data)) {
       riskMap.set(key, info2);
     }
@@ -58872,13 +58858,13 @@ init_config_verify();
 init_exec();
 init_git();
 init_startup_log();
-import { existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync12 } from "fs";
+import { join as join16 } from "path";
 function readServerJson(cwd) {
-  const p = join15(cwd, ".unerr", "state", "server.json");
-  if (!existsSync13(p)) return null;
+  const p = join16(cwd, ".unerr", "state", "server.json");
+  if (!existsSync14(p)) return null;
   try {
-    const raw = readFileSync11(p, "utf-8");
+    const raw = readFileSync12(p, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -58917,10 +58903,10 @@ function registerDashboardCommand(program2) {
 
 // src/commands/debug.ts
 init_git();
-import { existsSync as existsSync14, readFileSync as readFileSync12, readdirSync as readdirSync4, statSync as statSync3 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync13, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
 import { arch, homedir as homedir3, platform, release } from "os";
-import { join as join16 } from "path";
-var UNERR_DIR = join16(homedir3(), ".unerr");
+import { join as join17 } from "path";
+var UNERR_DIR = join17(homedir3(), ".unerr");
 function registerDebugCommand(program2) {
   program2.command("debug").description("Diagnostics dump for support").action(async () => {
     const sections = [];
@@ -58931,11 +58917,11 @@ function registerDebugCommand(program2) {
     sections.push("  CLI:      0.1.0");
     sections.push("");
     sections.push("## Settings");
-    const settingsPath = join16(UNERR_DIR, "settings.json");
-    if (existsSync14(settingsPath)) {
+    const settingsPath = join17(UNERR_DIR, "settings.json");
+    if (existsSync15(settingsPath)) {
       try {
         const settings = JSON.parse(
-          readFileSync12(settingsPath, "utf-8")
+          readFileSync13(settingsPath, "utf-8")
         );
         for (const [key, value] of Object.entries(settings)) {
           if (key === "anthropicApiKey" && typeof value === "string") {
@@ -58959,11 +58945,11 @@ function registerDebugCommand(program2) {
     sections.push(`  Branch:   ${branch ?? "(detached)"}`);
     sections.push("");
     sections.push("## Project Config (.unerr/config.json)");
-    const configPath2 = join16(process.cwd(), ".unerr", "config.json");
-    if (existsSync14(configPath2)) {
+    const configPath2 = join17(process.cwd(), ".unerr", "config.json");
+    if (existsSync15(configPath2)) {
       try {
         const config = JSON.parse(
-          readFileSync12(configPath2, "utf-8")
+          readFileSync13(configPath2, "utf-8")
         );
         for (const [key, value] of Object.entries(config)) {
           sections.push(`  ${key}: ${String(value)}`);
@@ -58976,11 +58962,11 @@ function registerDebugCommand(program2) {
     }
     sections.push("");
     sections.push("## Proxy Status");
-    const pidPath2 = join16(process.cwd(), ".unerr", "state", "proxy.pid");
-    if (existsSync14(pidPath2)) {
+    const pidPath2 = join17(process.cwd(), ".unerr", "state", "proxy.pid");
+    if (existsSync15(pidPath2)) {
       try {
         const pid = Number.parseInt(
-          readFileSync12(pidPath2, "utf-8").trim(),
+          readFileSync13(pidPath2, "utf-8").trim(),
           10
         );
         let alive = false;
@@ -58998,23 +58984,23 @@ function registerDebugCommand(program2) {
     }
     sections.push("");
     sections.push("## .unerr/ Directory (repo-local)");
-    const localUnerrDir = join16(process.cwd(), ".unerr");
-    if (existsSync14(localUnerrDir)) {
+    const localUnerrDir = join17(process.cwd(), ".unerr");
+    if (existsSync15(localUnerrDir)) {
       listDir(localUnerrDir, "  ", sections, 0, 2);
     } else {
       sections.push("  (not found)");
     }
     sections.push("");
     sections.push("## Snapshots");
-    const snapshotsDir = join16(localUnerrDir, "snapshots");
-    if (existsSync14(snapshotsDir)) {
-      const files = readdirSync4(snapshotsDir);
+    const snapshotsDir = join17(localUnerrDir, "snapshots");
+    if (existsSync15(snapshotsDir)) {
+      const files = readdirSync5(snapshotsDir);
       if (files.length === 0) {
         sections.push("  (empty)");
       }
       for (const file of files) {
-        const filePath = join16(snapshotsDir, file);
-        const stat2 = statSync3(filePath);
+        const filePath = join17(snapshotsDir, file);
+        const stat2 = statSync4(filePath);
         sections.push(`  ${file}: ${formatBytes(stat2.size)}`);
       }
     } else {
@@ -59023,10 +59009,10 @@ function registerDebugCommand(program2) {
     sections.push("");
     sections.push("## MCP Config Locations");
     const mcpLocations = [
-      join16(process.cwd(), ".cursor", "mcp.json"),
-      join16(process.cwd(), ".vscode", "mcp.json"),
-      join16(homedir3(), ".claude", "claude_desktop_config.json"),
-      join16(
+      join17(process.cwd(), ".cursor", "mcp.json"),
+      join17(process.cwd(), ".vscode", "mcp.json"),
+      join17(homedir3(), ".claude", "claude_desktop_config.json"),
+      join17(
         homedir3(),
         "Library",
         "Application Support",
@@ -59038,20 +59024,20 @@ function registerDebugCommand(program2) {
       )
     ];
     for (const loc of mcpLocations) {
-      const exists = existsSync14(loc);
+      const exists = existsSync15(loc);
       sections.push(
         `  ${exists ? "[x]" : "[ ]"} ${loc.replace(homedir3(), "~")}`
       );
     }
     sections.push("");
     sections.push("## Recent Log (last 20 lines)");
-    const logsDir = join16(process.cwd(), ".unerr", "logs");
-    if (existsSync14(logsDir)) {
-      const logFiles = readdirSync4(logsDir).filter((f) => f.endsWith(".log")).sort().reverse();
+    const logsDir = join17(process.cwd(), ".unerr", "logs");
+    if (existsSync15(logsDir)) {
+      const logFiles = readdirSync5(logsDir).filter((f) => f.endsWith(".log")).sort().reverse();
       if (logFiles.length > 0 && logFiles[0]) {
-        const logPath = join16(logsDir, logFiles[0]);
+        const logPath = join17(logsDir, logFiles[0]);
         try {
-          const content = readFileSync12(logPath, "utf-8");
+          const content = readFileSync13(logPath, "utf-8");
           const lines = content.split("\n").filter(Boolean);
           const last20 = lines.slice(-20);
           for (const line of last20) {
@@ -59077,19 +59063,19 @@ function formatBytes(bytes) {
 function listDir(dirPath, indent, out, depth, maxDepth) {
   if (depth > maxDepth) return;
   try {
-    const entries = readdirSync4(dirPath, { withFileTypes: true });
+    const entries = readdirSync5(dirPath, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         out.push(`${indent}${entry.name}/`);
         listDir(
-          join16(dirPath, entry.name),
+          join17(dirPath, entry.name),
           `${indent}  `,
           out,
           depth + 1,
           maxDepth
         );
       } else {
-        const size = formatBytes(statSync3(join16(dirPath, entry.name)).size);
+        const size = formatBytes(statSync4(join17(dirPath, entry.name)).size);
         out.push(`${indent}${entry.name} (${size})`);
       }
     }
@@ -59104,14 +59090,14 @@ import { execSync as execSync2 } from "child_process";
 import {
   accessSync,
   appendFileSync as appendFileSync5,
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   constants as fsConstants,
-  mkdirSync as mkdirSync8,
-  readFileSync as readFileSync13
+  mkdirSync as mkdirSync9,
+  readFileSync as readFileSync14
 } from "fs";
 import { createServer } from "net";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname6, join as join17, normalize } from "path";
+import { dirname as dirname6, join as join18, normalize } from "path";
 import { createInterface } from "readline";
 var hasTTY = !!process.stderr.isTTY;
 var W = hasTTY ? "\x1B[33m" : "";
@@ -59145,7 +59131,7 @@ function getGlobalBin() {
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    return isWin ? prefix : join17(prefix, "bin");
+    return isWin ? prefix : join18(prefix, "bin");
   } catch {
     return "";
   }
@@ -59163,30 +59149,30 @@ function getRcPath(shell) {
   const home = homedir4();
   switch (shell) {
     case "zsh":
-      return join17(home, ".zshrc");
+      return join18(home, ".zshrc");
     case "fish":
-      return join17(home, ".config", "fish", "config.fish");
+      return join18(home, ".config", "fish", "config.fish");
     case "bash":
-      return join17(home, ".bashrc");
+      return join18(home, ".bashrc");
     case "powershell": {
-      const docs = process.env.USERPROFILE ? join17(process.env.USERPROFILE, "Documents") : join17(home, "Documents");
-      const ps7Profile = join17(
+      const docs = process.env.USERPROFILE ? join18(process.env.USERPROFILE, "Documents") : join18(home, "Documents");
+      const ps7Profile = join18(
         docs,
         "PowerShell",
         "Microsoft.PowerShell_profile.ps1"
       );
-      const ps5Profile = join17(
+      const ps5Profile = join18(
         docs,
         "WindowsPowerShell",
         "Microsoft.PowerShell_profile.ps1"
       );
-      if (existsSync15(dirname6(ps7Profile))) return ps7Profile;
+      if (existsSync16(dirname6(ps7Profile))) return ps7Profile;
       return ps5Profile;
     }
     case "cmd":
-      return join17(home, ".unerr-path.cmd");
+      return join18(home, ".unerr-path.cmd");
     default:
-      return join17(home, ".bashrc");
+      return join18(home, ".bashrc");
   }
 }
 function getRcDisplayName(shell) {
@@ -59300,8 +59286,8 @@ function getFixPayload(shell, globalBin) {
   };
 }
 function isAlreadyInRc(rcPath, fix) {
-  if (!existsSync15(rcPath)) return false;
-  const content = readFileSync13(rcPath, "utf-8");
+  if (!existsSync16(rcPath)) return false;
+  const content = readFileSync14(rcPath, "utf-8");
   const meaningful = fix.lines.filter(
     (l) => l.trim() && !l.trim().startsWith("#") && !l.trim().startsWith("::")
   );
@@ -59345,8 +59331,8 @@ function applyFix(shell, rcPath, rcName, fix, globalBin) {
       );
     } else {
       const dir = dirname6(rcPath);
-      if (!existsSync15(dir)) {
-        mkdirSync8(dir, { recursive: true });
+      if (!existsSync16(dir)) {
+        mkdirSync9(dir, { recursive: true });
       }
       appendFileSync5(rcPath, `${fix.lines.join("\n")}
 `, "utf-8");
@@ -59672,9 +59658,9 @@ Recommended: open a shell using your default node, then \`npm i -g @unerr-ai/une
   };
 }
 function checkUnerrDirAccess() {
-  const dir = join17(homedir4(), ".unerr");
+  const dir = join18(homedir4(), ".unerr");
   try {
-    mkdirSync8(dir, { recursive: true });
+    mkdirSync9(dir, { recursive: true });
   } catch (err2) {
     const msg = err2 instanceof Error ? err2.message : String(err2);
     return {
@@ -60120,7 +60106,7 @@ init_nudge_state();
 // src/proxy/shell-compressor.ts
 init_token_flow();
 init_detect();
-import { readFileSync as readFileSync18 } from "fs";
+import { readFileSync as readFileSync19 } from "fs";
 
 // src/proxy/shell-classifier.ts
 var COMMAND_HINTS = {
@@ -61496,10 +61482,10 @@ async function tryLoadGraphForShellBoost(cwd) {
   }
   let buffer;
   try {
-    const { gunzipSync: gunzipSync3 } = await import("zlib");
+    const { gunzipSync: gunzipSync2 } = await import("zlib");
     const raw = readFileSync89(snapshotPath2);
     try {
-      buffer = gunzipSync3(raw);
+      buffer = gunzipSync2(raw);
     } catch {
       buffer = raw;
     }
@@ -62562,15 +62548,15 @@ function compressErrorDiagnostic(raw, command) {
 }
 
 // src/proxy/shell-strategies/filter-dsl.ts
-import { existsSync as existsSync20, readFileSync as readFileSync17 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync18 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 var cachedFilters = null;
 var cacheKey = "";
 function readFile(path7) {
   try {
-    if (!existsSync20(path7)) return null;
-    return readFileSync17(path7, "utf8");
+    if (!existsSync21(path7)) return null;
+    return readFileSync18(path7, "utf8");
   } catch {
     return null;
   }
@@ -62750,8 +62736,8 @@ function compileOne(name, raw) {
   };
 }
 function loadFilters(cwd) {
-  const repoPath = join24(cwd, ".unerr", "filters.toml");
-  const userPath = join24(homedir6(), ".config", "unerr", "filters.toml");
+  const repoPath = join25(cwd, ".unerr", "filters.toml");
+  const userPath = join25(homedir6(), ".config", "unerr", "filters.toml");
   const key = `${repoPath}|${userPath}`;
   if (cachedFilters && cacheKey === key) return cachedFilters;
   const sources = [readFile(repoPath), readFile(userPath)].filter(
@@ -64848,13 +64834,13 @@ ${clipped}`;
 
 // src/proxy/shell-tee.ts
 import {
-  mkdirSync as mkdirSync13,
-  readdirSync as readdirSync5,
-  statSync as statSync5,
+  mkdirSync as mkdirSync14,
+  readdirSync as readdirSync6,
+  statSync as statSync6,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync8
+  writeFileSync as writeFileSync9
 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 var MAX_TEE_FILES = 50;
 var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 function commandSlug(cmd) {
@@ -64863,15 +64849,15 @@ function commandSlug(cmd) {
 function teeShellOutput(cwd, command, raw, compressed) {
   const ratio2 = 1 - compressed.length / raw.length;
   if (ratio2 < 0.3 || raw.length < 1024) return null;
-  const teeDir = join25(cwd, ".unerr", "tee");
+  const teeDir = join26(cwd, ".unerr", "tee");
   try {
-    mkdirSync13(teeDir, { recursive: true });
+    mkdirSync14(teeDir, { recursive: true });
   } catch {
   }
   const slug = commandSlug(command);
   const ts = Date.now();
   const filename = `${ts}-${slug}.txt`;
-  const filePath = join25(teeDir, filename);
+  const filePath = join26(teeDir, filename);
   const header = [
     "# unerr tee \u2014 full shell output",
     `# command: ${command}`,
@@ -64882,7 +64868,7 @@ function teeShellOutput(cwd, command, raw, compressed) {
   ].join("\n");
   const content = header + raw;
   try {
-    writeFileSync8(filePath, content, "utf8");
+    writeFileSync9(filePath, content, "utf8");
   } catch {
     return null;
   }
@@ -64893,10 +64879,10 @@ function cleanupOldTees(teeDir, maxAgeMs = MAX_AGE_MS) {
   let deleted = 0;
   let entries = [];
   try {
-    entries = readdirSync5(teeDir).filter((f) => f.endsWith(".txt")).map((name) => {
-      const p = join25(teeDir, name);
+    entries = readdirSync6(teeDir).filter((f) => f.endsWith(".txt")).map((name) => {
+      const p = join26(teeDir, name);
       try {
-        const { mtimeMs } = statSync5(p);
+        const { mtimeMs } = statSync6(p);
         return { name, mtime: mtimeMs, path: p };
       } catch {
         return { name, mtime: 0, path: p };
@@ -65289,7 +65275,7 @@ function recordShellTokenFlow(cwd, command, category, raw, compressed, strategy)
     const unerrDir2 = `${cwd}/.unerr`;
     if (!sessionId) {
       try {
-        sessionId = readFileSync18(
+        sessionId = readFileSync19(
           `${unerrDir2}/state/session.id`,
           "utf-8"
         ).trim();
@@ -65497,8 +65483,8 @@ function registerExecCommand(program2) {
 }
 
 // src/commands/gain.ts
-import { existsSync as existsSync21, readFileSync as readFileSync19 } from "fs";
-import { join as join26 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync20 } from "fs";
+import { join as join27 } from "path";
 var PALETTE = {
   reset: "\x1B[0m",
   violet: "\x1B[38;2;139;92;246m",
@@ -65510,9 +65496,9 @@ var PALETTE = {
   bold: "\x1B[1m"
 };
 function loadFlow(cwd) {
-  const path7 = join26(cwd, ".unerr", "token-flow.jsonl");
-  if (!existsSync21(path7)) return [];
-  const raw = readFileSync19(path7, "utf8");
+  const path7 = join27(cwd, ".unerr", "token-flow.jsonl");
+  if (!existsSync22(path7)) return [];
+  const raw = readFileSync20(path7, "utf8");
   const events = [];
   for (const line of raw.split("\n")) {
     if (!line.trim()) continue;
@@ -65636,11 +65622,11 @@ function registerDiscoverCommand(program2) {
 }
 
 // src/commands/hook.ts
-import { readFileSync as readFileSync28 } from "fs";
+import { readFileSync as readFileSync29 } from "fs";
 
 // src/hooks/navigation-hooks.ts
 init_cochange_index();
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 
 // src/review/format.ts
 init_types();
@@ -65671,17 +65657,17 @@ init_session_edit_log();
 
 // src/hooks/blast-radius-client.ts
 init_blast_radius_protocol();
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import { connect } from "net";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 var DEFAULT_BLAST_RADIUS_TIMEOUT_MS = 300;
 function defaultProxySockPath(cwd = process.cwd()) {
-  return join28(cwd, ".unerr", "state", "proxy.sock");
+  return join29(cwd, ".unerr", "state", "proxy.sock");
 }
 function queryBlastRadius(params, options = {}) {
   const sockPath2 = options.sockPath ?? defaultProxySockPath();
   const timeoutMs = options.timeoutMs ?? DEFAULT_BLAST_RADIUS_TIMEOUT_MS;
-  if (!existsSync23(sockPath2)) return Promise.resolve(null);
+  if (!existsSync24(sockPath2)) return Promise.resolve(null);
   return new Promise((resolve8) => {
     let settled = false;
     let buffer = "";
@@ -65735,15 +65721,15 @@ function queryBlastRadius(params, options = {}) {
 }
 
 // src/hooks/hook-dedup.ts
-import { existsSync as existsSync24, mkdirSync as mkdirSync15, readFileSync as readFileSync21, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname8, join as join29 } from "path";
-var STATE_FILE = join29(".unerr", "state", "hook-recent.json");
+import { existsSync as existsSync25, mkdirSync as mkdirSync16, readFileSync as readFileSync22, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname8, join as join30 } from "path";
+var STATE_FILE = join30(".unerr", "state", "hook-recent.json");
 var DEFAULT_TTL_MS = 3e4;
 var PRUNE_FACTOR = 10;
 function readMap(file) {
   try {
-    if (!existsSync24(file)) return {};
-    const raw = readFileSync21(file, "utf8");
+    if (!existsSync25(file)) return {};
+    const raw = readFileSync22(file, "utf8");
     const obj = JSON.parse(raw);
     if (obj && typeof obj === "object") return obj;
   } catch {
@@ -65753,8 +65739,8 @@ function readMap(file) {
 function writeMap(file, map) {
   try {
     const dir = dirname8(file);
-    if (!existsSync24(dir)) mkdirSync15(dir, { recursive: true });
-    writeFileSync9(file, JSON.stringify(map));
+    if (!existsSync25(dir)) mkdirSync16(dir, { recursive: true });
+    writeFileSync10(file, JSON.stringify(map));
   } catch {
   }
 }
@@ -65816,7 +65802,8 @@ var claudeCodeAdapter = {
         hookSpecificOutput: {
           hookEventName: "PreToolUse",
           permissionDecision: "allow",
-          systemMessage: result.message
+          systemMessage: result.message,
+          additionalContext: result.message
         }
       });
     }
@@ -66163,13 +66150,13 @@ ${existing}` : prefix
 
 // src/hooks/review-client.ts
 init_review_protocol();
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 import { connect as connect2 } from "net";
 var DEFAULT_REVIEW_TIMEOUT_MS = 500;
 function queryReviewEdit(params, options = {}) {
   const sockPath2 = options.sockPath ?? defaultProxySockPath();
   const timeoutMs = options.timeoutMs ?? DEFAULT_REVIEW_TIMEOUT_MS;
-  if (!existsSync25(sockPath2)) return Promise.resolve(null);
+  if (!existsSync26(sockPath2)) return Promise.resolve(null);
   return new Promise((resolve8) => {
     let settled = false;
     let buffer = "";
@@ -66228,7 +66215,7 @@ function queryReviewEdit(params, options = {}) {
 var DENY_ONCE_TTL_MS = 5 * 60 * 1e3;
 function appendCoChangeClause(base, filePath) {
   try {
-    const unerrDir2 = join30(process.cwd(), ".unerr");
+    const unerrDir2 = join31(process.cwd(), ".unerr");
     const partners = lookupCoChangePartners(unerrDir2, filePath, 3);
     if (partners.length === 0) return base;
     return `${base}; commonly co-changed with: ${partners.join(", ")}`;
@@ -66346,7 +66333,7 @@ function formatCascadeNudge(warnings, filePath, readPrereq) {
   const head = readPrereq.trimEnd();
   if (head) lines.push(head);
   lines.push(
-    `Editing "${filePath}" changes ${warnings.length} signature(s) with callers that must be updated in the same change:`
+    `\u26A1 unerr \xB7 cascade guard: editing "${filePath}" changes ${warnings.length} signature(s) with callers that must be updated in the same change:`
   );
   for (const w of warnings) {
     const direct = w.blast_radius.direct_callers.length;
@@ -66455,7 +66442,7 @@ var postEditHandlerAsync = async (normalized) => {
   if (!filePath || !isCodeFile(filePath)) return passthrough();
   const oldContent = input.old_string ?? null;
   const newContent = input.new_string ?? null;
-  recordEdit(join30(process.cwd(), ".unerr"), {
+  recordEdit(join31(process.cwd(), ".unerr"), {
     ts: (/* @__PURE__ */ new Date()).toISOString(),
     file_path: filePath,
     old_content: oldContent,
@@ -66512,8 +66499,8 @@ function runPostEditHookAsync(stdinJson) {
 // src/hooks/prompt-hooks.ts
 init_topic_shift();
 init_nudge_state();
-import { existsSync as existsSync30, readFileSync as readFileSync25 } from "fs";
-import { join as join35 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync26 } from "fs";
+import { join as join36 } from "path";
 init_prompt_capture();
 var VERB_CLUSTERS = [
   {
@@ -66739,9 +66726,9 @@ function buildSkillCatalog() {
 }
 function readShadowLedgerSync(cwd) {
   try {
-    const path7 = join35(cwd, ".unerr", "ledger", "shadow.jsonl");
-    if (!existsSync30(path7)) return [];
-    const raw = readFileSync25(path7, "utf8");
+    const path7 = join36(cwd, ".unerr", "ledger", "shadow.jsonl");
+    if (!existsSync31(path7)) return [];
+    const raw = readFileSync26(path7, "utf8");
     const out = [];
     for (const line of raw.split("\n")) {
       const trimmed = line.trim();
@@ -66828,10 +66815,10 @@ var promptSubmitHandler = (normalized) => {
   if (message.length < 10) return passthrough();
   try {
     const cwd = process.cwd();
-    const sessionId = readProxySessionId(join35(cwd, ".unerr")) ?? raw.session_id ?? "unknown";
+    const sessionId = readProxySessionId(join36(cwd, ".unerr")) ?? raw.session_id ?? "unknown";
     const cluster = classifyVerbCluster(message);
     recordUserPromptReceived({
-      unerrDir: join35(cwd, ".unerr"),
+      unerrDir: join36(cwd, ".unerr"),
       cwd,
       sessionId,
       message,
@@ -66917,13 +66904,13 @@ function runUserPromptSubmitHook(stdinJson) {
 
 // src/hooks/session-hooks.ts
 init_session_persistence();
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 var sessionStartHandler = (_normalized) => {
   return passthrough();
 };
 async function runSessionStartHookAsync(stdinJson) {
   try {
-    const unerrDir2 = join38(process.cwd(), ".unerr");
+    const unerrDir2 = join39(process.cwd(), ".unerr");
     const payload = await generateSessionResumePayload(unerrDir2);
     if (!payload) return runSessionStartHook(stdinJson, sessionStartHandler);
     const block = formatSessionResumeBlock(payload);
@@ -66989,7 +66976,7 @@ function runPreWebFetchHook(stdinJson) {
 function safeHookAction(handler) {
   return () => {
     try {
-      const stdin = readFileSync28(0, "utf-8");
+      const stdin = readFileSync29(0, "utf-8");
       process.stdout.write(handler(stdin));
     } catch (e) {
       process.stderr.write(`[unerr] hook error: ${e}
@@ -67001,7 +66988,7 @@ function safeHookAction(handler) {
 function safeAsyncHookAction(handler) {
   return async () => {
     try {
-      const stdin = readFileSync28(0, "utf-8");
+      const stdin = readFileSync29(0, "utf-8");
       process.stdout.write(await handler(stdin));
     } catch (e) {
       process.stderr.write(`[unerr] hook error: ${e}
@@ -68453,7 +68440,7 @@ function ensureGitignore(cwd) {
 init_correction_detector();
 import { existsSync as existsSync48 } from "fs";
 import { join as join55 } from "path";
-import { gunzipSync as gunzipSync2 } from "zlib";
+import { gunzipSync } from "zlib";
 import pc3 from "picocolors";
 function registerLearnCommand(program2) {
   program2.command("learn").description(
@@ -68551,7 +68538,7 @@ async function persistPatterns(patterns, _unerrDir) {
     const store = await CozoGraphStore2.create(db);
     const { unpack } = await import("msgpackr");
     const raw = readFileSync89(snapshotPath2);
-    const buffer = gunzipSync2(raw);
+    const buffer = gunzipSync(raw);
     const envelope = unpack(buffer);
     await store.loadSnapshot(envelope);
     store.persistCorrections(patterns);
@@ -70704,27 +70691,6 @@ function registerStatusCommand(program2) {
       }
     }
     let graphInfo = "No local graph";
-    const manifestsDir = join73(localDataDir, "manifests");
-    if (repoId && existsSync66(join73(manifestsDir, `${repoId}.json`))) {
-      try {
-        const manifest = JSON.parse(
-          readFileSync57(join73(manifestsDir, `${repoId}.json`), "utf-8")
-        );
-        const entityCount = manifest.entityCount ?? 0;
-        const edgeCount = manifest.edgeCount ?? 0;
-        const pulledAt = manifest.pulledAt;
-        let ageStr = "";
-        if (pulledAt) {
-          const ageMs = Date.now() - new Date(pulledAt).getTime();
-          const ageHours = Math.floor(ageMs / 36e5);
-          if (ageHours < 1) ageStr = "indexed <1h ago";
-          else if (ageHours < 24) ageStr = `indexed ${ageHours}h ago`;
-          else ageStr = `indexed ${Math.floor(ageHours / 24)}d ago`;
-        }
-        graphInfo = `${entityCount.toLocaleString()} entities, ${edgeCount.toLocaleString()} edges${ageStr ? ` (${ageStr})` : ""}`;
-      } catch {
-      }
-    }
     let drift;
     const driftSummaryPath = join73(unerrDir2, "drift", "drift_summary.json");
     if (existsSync66(driftSummaryPath)) {
@@ -70760,14 +70726,15 @@ function registerStatusCommand(program2) {
           snapshotPath2 = join73(snapshotsDir, "graph.msgpack");
         }
         if (existsSync66(snapshotPath2)) {
-          const { gunzipSync: gunzipSync3 } = await import("zlib");
+          const { gunzipSync: gunzipSync2 } = await import("zlib");
           const { unpack } = await import("msgpackr");
-          const { default: CozoDbConstructor } = await import("cozo-node");
+          const cozoModule = await import("cozo-node");
           const { CozoGraphStore: CozoGraphStore2 } = await Promise.resolve().then(() => (init_local_graph(), local_graph_exports));
+          const CozoDbConstructor = cozoModule.default ? cozoModule.default.CozoDb : cozoModule.CozoDb;
           const raw = readFileSync57(snapshotPath2);
           let buffer;
           try {
-            buffer = gunzipSync3(raw);
+            buffer = gunzipSync2(raw);
           } catch {
             buffer = raw;
           }
@@ -70776,6 +70743,17 @@ function registerStatusCommand(program2) {
           const envelope = unpack(buffer);
           await graph.loadSnapshot(envelope);
           ruleHealth = await graph.getRuleHealthSummary();
+          const entityCount = envelope?.entities?.length ?? 0;
+          const edgeCount = envelope?.edges?.length ?? 0;
+          let ageStr = "";
+          if (typeof envelope?.generatedAt === "string") {
+            const ageMs = Date.now() - new Date(envelope.generatedAt).getTime();
+            const ageHours = Math.floor(ageMs / 36e5);
+            if (ageHours < 1) ageStr = "indexed <1h ago";
+            else if (ageHours < 24) ageStr = `indexed ${ageHours}h ago`;
+            else ageStr = `indexed ${Math.floor(ageHours / 24)}d ago`;
+          }
+          graphInfo = `${entityCount.toLocaleString()} entities, ${edgeCount.toLocaleString()} edges${ageStr ? ` (${ageStr})` : ""}`;
         }
       } catch {
       }