@unerr-ai/unerr 0.0.0-beta.7 → 0.0.0-beta.9

package/dist/cli.js

@@ -750,7 +750,7 @@ async function getParser(language) {
     const langFile = `tree-sitter-${language}.wasm`;
     try {
       const { join: join68 } = await import("path");
-      const { existsSync: existsSync63 } = await import("fs");
+      const { existsSync: existsSync64 } = await import("fs");
       const possiblePaths = [
         join68(
           process.cwd(),
@@ -762,7 +762,7 @@ async function getParser(language) {
       ];
       let wasmPath = null;
       for (const p of possiblePaths) {
-        if (existsSync63(p)) {
+        if (existsSync64(p)) {
           wasmPath = p;
           break;
         }
@@ -1656,8 +1656,21 @@ async function createIfMissing(db, existing, name, schema) {
   if (existing.has(name)) return;
   await db.run(schema);
 }
+async function dropIfStale(db, existing, name, requiredColumns) {
+  if (!existing.has(name)) return;
+  try {
+    const colList = ["key", ...requiredColumns].join(", ");
+    await db.run(
+      `?[] := *${name}{${colList}}, key = '__schema_probe__'`
+    );
+  } catch {
+    await db.run(`::remove ${name}`);
+    existing.delete(name);
+  }
+}
 async function initSchema(db) {
   const existing = await getExistingRelations(db);
+  await dropIfStale(db, existing, "entities", ["end_line", "is_test"]);
   await createIfMissing(
     db,
     existing,
@@ -1681,32 +1694,6 @@ async function initSchema(db) {
     }
   `
   );
-  if (existing.has("entities")) {
-    try {
-      await db.run(
-        `?[key, kind, name, file_path, start_line, end_line, signature, body, fan_in, fan_out, risk_level, community, is_test] :=
-           *entities{key, kind, name, file_path, start_line, signature, body, fan_in, fan_out, risk_level, community, is_test},
-           end_line = 0
-         :replace entities {
-           key: String
-           =>
-           kind: String,
-           name: String,
-           file_path: String,
-           start_line: Int default 0,
-           end_line: Int default 0,
-           signature: String default "",
-           body: String default "",
-           fan_in: Int default 0,
-           fan_out: Int default 0,
-           risk_level: String default "normal",
-           community: Int default -1,
-           is_test: Bool default false
-         }`
-      );
-    } catch {
-    }
-  }
   await createIfMissing(
     db,
     existing,
@@ -7240,9 +7227,9 @@ function extractTSEntities(node, lines, entities) {
             const nameNode = child.childForFieldName("name");
             const valueNode = child.childForFieldName("value");
             if (!nameNode || !valueNode) continue;
+            const startLine = n.startPosition.row + 1;
+            const endLine = n.endPosition.row + 1;
             if (valueNode.type === "arrow_function" || valueNode.type === "function_expression" || valueNode.type === "function") {
-              const startLine = n.startPosition.row + 1;
-              const endLine = n.endPosition.row + 1;
               entities.push({
                 name: nameNode.text,
                 kind: "function",
@@ -7251,11 +7238,53 @@ function extractTSEntities(node, lines, entities) {
                 line_end: endLine,
                 content_hash: hashLines(lines, startLine, endLine)
               });
+            } else if (valueNode.type === "object" || valueNode.type === "array" || valueNode.type === "as_expression" || valueNode.type === "satisfies_expression" || valueNode.type === "new_expression" || valueNode.type === "call_expression" || valueNode.type === "template_string" || valueNode.type === "string" || valueNode.type === "number" || valueNode.type === "true" || valueNode.type === "false" || valueNode.type === "regex") {
+              const isTopLevel = !n.parent || n.parent.type === "program" || n.parent.type === "export_statement";
+              if (isTopLevel) {
+                entities.push({
+                  name: nameNode.text,
+                  kind: "variable",
+                  signature: "",
+                  line_start: startLine,
+                  line_end: endLine,
+                  content_hash: hashLines(lines, startLine, endLine)
+                });
+              }
             }
           }
         }
         break;
       }
+      case "type_alias_declaration": {
+        const name = n.childForFieldName("name");
+        if (!name) return;
+        const startLine = n.startPosition.row + 1;
+        const endLine = n.endPosition.row + 1;
+        entities.push({
+          name: name.text,
+          kind: "interface",
+          signature: "",
+          line_start: startLine,
+          line_end: endLine,
+          content_hash: hashLines(lines, startLine, endLine)
+        });
+        break;
+      }
+      case "enum_declaration": {
+        const name = n.childForFieldName("name");
+        if (!name) return;
+        const startLine = n.startPosition.row + 1;
+        const endLine = n.endPosition.row + 1;
+        entities.push({
+          name: name.text,
+          kind: "class",
+          signature: "",
+          line_start: startLine,
+          line_end: endLine,
+          content_hash: hashLines(lines, startLine, endLine)
+        });
+        break;
+      }
     }
   });
 }
@@ -9383,6 +9412,42 @@ var init_downloader = __esm({
         archiveType: "gz",
         archiveBinaryPath: null,
         manualInstall: "rustup component add rust-analyzer"
+      },
+      ruby: {
+        language: "ruby",
+        binaryName: "scip-ruby",
+        repo: "sourcegraph/scip-ruby",
+        tag: "latest",
+        // Verified assets: scip-ruby-arm64-darwin, scip-ruby-x86_64-linux (raw binaries)
+        // No darwin-x86_64 or linux-arm64 builds available
+        resolveAssetName: (p) => {
+          if (p.os === "windows") return null;
+          if (p.os === "darwin" && p.nodeArch !== "arm64") return null;
+          if (p.os === "linux" && p.nodeArch !== "x64") return null;
+          const arch2 = p.os === "darwin" ? "arm64" : "x86_64";
+          return `scip-ruby-${arch2}-${p.os}`;
+        },
+        archiveType: "raw",
+        archiveBinaryPath: null,
+        manualInstall: "Download from https://github.com/sourcegraph/scip-ruby/releases"
+      },
+      cpp: {
+        language: "cpp",
+        binaryName: "scip-clang",
+        repo: "sourcegraph/scip-clang",
+        tag: "latest",
+        // Verified assets: scip-clang-arm64-darwin, scip-clang-x86_64-linux (raw binaries)
+        // No darwin-x86_64 or linux-arm64 builds available
+        resolveAssetName: (p) => {
+          if (p.os === "windows") return null;
+          if (p.os === "darwin" && p.nodeArch !== "arm64") return null;
+          if (p.os === "linux" && p.nodeArch !== "x64") return null;
+          const arch2 = p.os === "darwin" ? "arm64" : "x86_64";
+          return `scip-clang-${arch2}-${p.os}`;
+        },
+        archiveType: "raw",
+        archiveBinaryPath: null,
+        manualInstall: "Download from https://github.com/sourcegraph/scip-clang/releases (requires compile_commands.json)"
       }
     };
   }
@@ -9464,7 +9529,7 @@ async function detectScipBinary(language) {
     path: null
   };
 }
-function detectPrimaryLanguage(files) {
+function detectProjectLanguages(files) {
   const counts = {};
   for (const file of files) {
     const dotIdx = file.lastIndexOf(".");
@@ -9475,15 +9540,7 @@ function detectPrimaryLanguage(files) {
       counts[lang] = (counts[lang] ?? 0) + 1;
     }
   }
-  let maxLang = null;
-  let maxCount = 0;
-  for (const [lang, count] of Object.entries(counts)) {
-    if (count > maxCount) {
-      maxCount = count;
-      maxLang = lang;
-    }
-  }
-  return maxLang;
+  return Object.entries(counts).map(([language, fileCount]) => ({ language, fileCount })).sort((a, b) => b.fileCount - a.fileCount);
 }
 var BUNDLED_SCIP, EXTERNAL_SCIP, EXT_TO_SCIP_LANG;
 var init_detector = __esm({
@@ -9504,7 +9561,10 @@ var init_detector = __esm({
     EXTERNAL_SCIP = {
       go: ["scip-go"],
       java: ["scip-java"],
-      rust: ["rust-analyzer"]
+      rust: ["rust-analyzer"],
+      ruby: ["scip-ruby"],
+      cpp: ["scip-clang"],
+      csharp: ["scip-dotnet"]
     };
     EXT_TO_SCIP_LANG = {
       // TypeScript / JavaScript (scip-typescript handles all)
@@ -9529,7 +9589,19 @@ var init_detector = __esm({
       ".scala": "java",
       ".sc": "java",
       // Rust
-      ".rs": "rust"
+      ".rs": "rust",
+      // Ruby
+      ".rb": "ruby",
+      // C / C++ (scip-clang handles both)
+      ".c": "cpp",
+      ".cpp": "cpp",
+      ".cc": "cpp",
+      ".cxx": "cpp",
+      ".h": "cpp",
+      ".hpp": "cpp",
+      ".hxx": "cpp",
+      // C#
+      ".cs": "csharp"
     };
   }
 });
@@ -9636,6 +9708,9 @@ async function runScipIndexer(options) {
   }
   const outputPath = join22(outputDir, "index.scip");
   const args = buildScipArgs(language, binaryPath, projectRoot, outputPath);
+  if (options.extraArgs?.length) {
+    args.push(...options.extraArgs);
+  }
   try {
     log4.info(`Running SCIP indexer: ${args[0]} for ${language}`);
     const result = await exec(args[0], args.slice(1), {
@@ -9644,6 +9719,12 @@ async function runScipIndexer(options) {
     });
     const durationMs = performance.now() - start;
     if (result.exitCode !== 0) {
+      if (existsSync17(outputPath)) {
+        log4.warn(
+          `SCIP indexer exited with code ${result.exitCode} but output file was created \u2014 treating as success`
+        );
+        return { success: true, outputPath, durationMs, error: null };
+      }
       log4.warn(
         `SCIP indexer failed (exit ${result.exitCode}): ${result.stderr.slice(0, 500)}`
       );
@@ -9690,6 +9771,12 @@ function buildScipArgs(language, binaryPath, projectRoot, outputPath) {
       return [binaryPath, "index", "--output", outputPath];
     case "rust":
       return [binaryPath, "scip", projectRoot, "--output", outputPath];
+    case "ruby":
+      return [binaryPath, "--output", outputPath];
+    case "cpp":
+      return [binaryPath, "--output", outputPath];
+    case "csharp":
+      return [binaryPath, "index", "--output", outputPath];
     default:
       return [binaryPath, "--output", outputPath];
   }
@@ -9705,83 +9792,266 @@ var init_runner = __esm({
 });
 
 // src/intelligence/indexer/scip/orchestrator.ts
+import { existsSync as existsSync18, readFileSync as readFileSync18, writeFileSync as writeFileSync9 } from "fs";
 import { join as join23 } from "path";
-async function enrichWithScip(files, projectRoot, existingEdges, entities) {
-  const language = detectPrimaryLanguage(files);
-  if (!language) {
+async function enrichWithScip(files, projectRoot, existingEdges, entities, options) {
+  const languages = detectProjectLanguages(files);
+  if (languages.length === 0) {
     return skipResult(existingEdges, "No supported language detected");
   }
-  let binaryInfo = await detectScipBinary(language);
-  if (!binaryInfo.available && isAutoDownloadSupported(language)) {
-    log5.info(`SCIP binary not found for ${language}, downloading...`);
-    const downloadResult = await downloadScipBinary(language, (msg) => {
-      log5.info(msg);
-    });
-    if (downloadResult.success && downloadResult.binaryPath) {
-      binaryInfo = await detectScipBinary(language);
-    } else {
-      const manualInstr = getManualInstallInstructions(language);
-      return skipResult(
-        existingEdges,
-        `SCIP auto-download failed for ${language}: ${downloadResult.error}${manualInstr ? `
+  let currentEdges = markAsStructural(existingEdges);
+  let lastRunResult = null;
+  let lastDecodeResult = null;
+  let lastMergeResult = null;
+  let anySucceeded = false;
+  const processedLanguages = [];
+  for (const { language, fileCount } of languages) {
+    log5.info(`SCIP: processing ${language} (${fileCount} files)`);
+    let binaryInfo = await detectScipBinary(language);
+    if (!binaryInfo.available) {
+      if (language === "csharp") {
+        const installed = await installScipDotnet();
+        if (installed) {
+          binaryInfo = await detectScipBinary(language);
+        } else {
+          continue;
+        }
+      } else if (isAutoDownloadSupported(language)) {
+        log5.info(`SCIP binary not found for ${language}, downloading...`);
+        const downloadResult = await downloadScipBinary(language, (msg) => {
+          log5.info(msg);
+        });
+        if (downloadResult.success && downloadResult.binaryPath) {
+          binaryInfo = await detectScipBinary(language);
+        } else {
+          const manualInstr = getManualInstallInstructions(language);
+          log5.warn(
+            `SCIP auto-download failed for ${language}: ${downloadResult.error}${manualInstr ? `
   Manual install: ${manualInstr}` : ""}`
+          );
+          continue;
+        }
+      }
+    }
+    if (!binaryInfo.available) {
+      log5.info(
+        `SCIP binary not available for ${language}, skipping`
       );
+      continue;
+    }
+    log5.info(
+      `SCIP enrichment: ${language} (${binaryInfo.bundled ? "bundled" : "external"}: ${binaryInfo.binaryName})`
+    );
+    const outputDir = join23(projectRoot, ".unerr", "scip");
+    const binaryPath = binaryInfo.path ?? binaryInfo.binaryName;
+    let extraArgs;
+    if (language === "typescript") {
+      if (!existsSync18(join23(projectRoot, "tsconfig.json")) && !existsSync18(join23(projectRoot, "jsconfig.json"))) {
+        log5.info(
+          `SCIP skipping TypeScript: no tsconfig.json or jsconfig.json found in project root. Create one to enable SCIP indexing.`
+        );
+        continue;
+      }
     }
+    if (language === "java") {
+      const buildToolResult = await resolveJavaBuildTool(projectRoot, options);
+      if (buildToolResult) {
+        extraArgs = buildToolResult.extraArgs;
+      }
+    }
+    if (language === "cpp") {
+      const compdbPath = resolveCompileCommandsJson(projectRoot);
+      if (!compdbPath) {
+        log5.info(
+          `SCIP skipping C/C++: no compile_commands.json found. Generate one with CMake (-DCMAKE_EXPORT_COMPILE_COMMANDS=ON), Bear, or your build system.`
+        );
+        continue;
+      }
+      extraArgs = [`--compdb-path=${compdbPath}`];
+    }
+    const runResult = await runScipIndexer({
+      language,
+      binaryPath,
+      projectRoot,
+      outputDir,
+      timeoutMs: 3e4,
+      extraArgs
+    });
+    lastRunResult = runResult;
+    if (!runResult.success || !runResult.outputPath) {
+      log5.warn(`SCIP indexer failed for ${language}: ${runResult.error}`);
+      continue;
+    }
+    const decodeResult = await decodeScipOutput(runResult.outputPath);
+    lastDecodeResult = decodeResult;
+    const indexedEdges = currentEdges.map((e) => ({
+      from_key: e.from_key,
+      to_key: e.to_key,
+      type: e.type,
+      file_path: e.file_path,
+      line: e.line
+    }));
+    const { edges: enrichedEdges, result: mergeResult } = mergeScipResults(
+      indexedEdges,
+      decodeResult,
+      entities
+    );
+    currentEdges = enrichedEdges;
+    lastMergeResult = mergeResult;
+    anySucceeded = true;
+    processedLanguages.push(language);
+    log5.info(
+      `SCIP ${language}: ${mergeResult.edgesUpgraded} edges upgraded to compiler-verified (${Math.round(runResult.durationMs)}ms)`
+    );
   }
-  if (!binaryInfo.available) {
+  if (!anySucceeded) {
     return skipResult(
       existingEdges,
-      `SCIP binary not available for ${language} (not bundled, not on PATH, no auto-download)`
+      `No SCIP binary available for any detected language (${languages.map((l) => l.language).join(", ")})`
     );
   }
-  log5.info(
-    `SCIP enrichment: ${language} (${binaryInfo.bundled ? "bundled" : "external"}: ${binaryInfo.binaryName})`
-  );
-  const outputDir = join23(projectRoot, ".unerr", "scip");
-  const binaryPath = binaryInfo.path ?? binaryInfo.binaryName;
-  const runResult = await runScipIndexer({
-    language,
-    binaryPath,
-    projectRoot,
-    outputDir,
-    timeoutMs: 3e4
-    // 30s max for inline indexing
-  });
-  if (!runResult.success || !runResult.outputPath) {
-    log5.warn(`SCIP indexer failed for ${language}: ${runResult.error}`);
-    return {
-      language,
-      binaryAvailable: true,
-      bundled: binaryInfo.bundled,
-      runResult,
-      decodeResult: null,
-      mergeResult: null,
-      enrichedEdges: markAsStructural(existingEdges),
-      skipped: false,
-      skipReason: null
-    };
-  }
-  const decodeResult = await decodeScipOutput(runResult.outputPath);
-  const { edges: enrichedEdges, result: mergeResult } = mergeScipResults(
-    existingEdges,
-    decodeResult,
-    entities
-  );
-  log5.info(
-    `SCIP enrichment complete: ${mergeResult.edgesUpgraded} edges upgraded to compiler-verified (${Math.round(runResult.durationMs)}ms)`
-  );
   return {
-    language,
+    language: processedLanguages.join("+"),
     binaryAvailable: true,
-    bundled: binaryInfo.bundled,
-    runResult,
-    decodeResult,
-    mergeResult,
-    enrichedEdges,
+    bundled: false,
+    runResult: lastRunResult,
+    decodeResult: lastDecodeResult,
+    mergeResult: lastMergeResult,
+    enrichedEdges: currentEdges,
     skipped: false,
     skipReason: null
   };
 }
+function detectJavaBuildTools(projectRoot) {
+  const detected = [];
+  for (const [tool, files] of Object.entries(BUILD_TOOL_FILES)) {
+    if (files.some((f) => existsSync18(join23(projectRoot, f)))) {
+      detected.push(tool);
+    }
+  }
+  return detected;
+}
+function getStoredBuildTool(projectRoot) {
+  try {
+    const configPath = join23(projectRoot, ".unerr", "config.json");
+    const config = JSON.parse(readFileSync18(configPath, "utf-8"));
+    return config.javaBuildTool ?? null;
+  } catch {
+    return null;
+  }
+}
+function storeBuildTool(projectRoot, tool) {
+  try {
+    const configPath = join23(projectRoot, ".unerr", "config.json");
+    let config = {};
+    try {
+      config = JSON.parse(readFileSync18(configPath, "utf-8"));
+    } catch {
+    }
+    config.javaBuildTool = tool;
+    writeFileSync9(configPath, `${JSON.stringify(config, null, 2)}
+`);
+  } catch {
+  }
+}
+async function promptBuildTool(tools, options) {
+  if (!process.stdin.isTTY) {
+    return null;
+  }
+  try {
+    options?.onPromptStart?.();
+    const clack2 = await import("@clack/prompts");
+    const result = await clack2.select({
+      message: "Multiple Java build tools detected. Which one should SCIP use?",
+      options: tools.map((t) => ({
+        value: t,
+        label: t.charAt(0).toUpperCase() + t.slice(1)
+      }))
+    });
+    options?.onPromptEnd?.();
+    if (clack2.isCancel(result)) return null;
+    return result;
+  } catch {
+    options?.onPromptEnd?.();
+    return null;
+  }
+}
+async function resolveJavaBuildTool(projectRoot, options) {
+  const detected = detectJavaBuildTools(projectRoot);
+  if (detected.length === 0) {
+    return null;
+  }
+  if (detected.length === 1) {
+    log5.info(`Java build tool: ${detected[0]} (auto-detected)`);
+    return { tool: detected[0], extraArgs: [`--build-tool=${detected[0]}`] };
+  }
+  const stored = getStoredBuildTool(projectRoot);
+  if (stored && detected.includes(stored)) {
+    log5.info(`Java build tool: ${stored} (from config)`);
+    return { tool: stored, extraArgs: [`--build-tool=${stored}`] };
+  }
+  const chosen = await promptBuildTool(detected, options);
+  if (chosen) {
+    storeBuildTool(projectRoot, chosen);
+    log5.info(`Java build tool: ${chosen} (user selected, saved to config)`);
+    return { tool: chosen, extraArgs: [`--build-tool=${chosen}`] };
+  }
+  const fallback = detected[0];
+  log5.warn(
+    `Multiple Java build tools detected (${detected.join(", ")}), using ${fallback}. Set "javaBuildTool" in .unerr/config.json to change.`
+  );
+  return { tool: fallback, extraArgs: [`--build-tool=${fallback}`] };
+}
+function resolveCompileCommandsJson(projectRoot) {
+  for (const relPath of COMPDB_SEARCH_PATHS) {
+    const absPath = join23(projectRoot, relPath);
+    if (existsSync18(absPath)) {
+      log5.info(`Found compile_commands.json at ${relPath}`);
+      return absPath;
+    }
+  }
+  return null;
+}
+async function installScipDotnet() {
+  try {
+    const dotnetCheck = await exec("which", ["dotnet"]);
+    if (dotnetCheck.exitCode !== 0) {
+      log5.warn(
+        `SCIP skipping C#: dotnet CLI not found on PATH. Install the .NET SDK to enable SCIP indexing for C#.`
+      );
+      return false;
+    }
+  } catch {
+    log5.warn(
+      `SCIP skipping C#: dotnet CLI not found on PATH. Install the .NET SDK to enable SCIP indexing for C#.`
+    );
+    return false;
+  }
+  log5.info("Installing scip-dotnet via dotnet tool install...");
+  try {
+    const result = await exec("dotnet", [
+      "tool",
+      "install",
+      "--global",
+      "scip-dotnet"
+    ]);
+    if (result.exitCode === 0) {
+      log5.info("scip-dotnet installed successfully");
+      return true;
+    }
+    if (result.stderr.includes("already installed")) {
+      log5.info("scip-dotnet already installed");
+      return true;
+    }
+    log5.warn(`scip-dotnet install failed: ${result.stderr.slice(0, 300)}`);
+    return false;
+  } catch (err) {
+    log5.warn(
+      `scip-dotnet install failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return false;
+  }
+}
 function skipResult(existingEdges, reason) {
   log5.info(`SCIP skipped: ${reason}`);
   return {
@@ -9803,10 +10073,11 @@ function markAsStructural(edges) {
     scipVerified: false
   }));
 }
-var log5;
+var log5, BUILD_TOOL_FILES, COMPDB_SEARCH_PATHS;
 var init_orchestrator = __esm({
   "src/intelligence/indexer/scip/orchestrator.ts"() {
     "use strict";
+    init_exec();
     init_logger();
     init_decoder();
     init_detector();
@@ -9814,6 +10085,19 @@ var init_orchestrator = __esm({
     init_merger();
     init_runner();
     log5 = createModuleLogger("scip-orchestrator");
+    BUILD_TOOL_FILES = {
+      Maven: ["pom.xml"],
+      Gradle: ["build.gradle", "build.gradle.kts", "settings.gradle", "settings.gradle.kts"],
+      Bazel: ["BUILD", "BUILD.bazel", "WORKSPACE", "WORKSPACE.bazel"],
+      Sbt: ["build.sbt"]
+    };
+    COMPDB_SEARCH_PATHS = [
+      "compile_commands.json",
+      "build/compile_commands.json",
+      "cmake-build-debug/compile_commands.json",
+      "cmake-build-release/compile_commands.json",
+      "out/compile_commands.json"
+    ];
   }
 });
 
@@ -10333,7 +10617,7 @@ __export(local_indexer_exports, {
   runCommunityDetection: () => runCommunityDetection,
   runConventionDetection: () => runConventionDetection
 });
-import { readFileSync as readFileSync18, readdirSync as readdirSync6, statSync as statSync6 } from "fs";
+import { readFileSync as readFileSync19, readdirSync as readdirSync6, statSync as statSync6 } from "fs";
 import { basename as basename2, extname as extname2, join as join24, relative } from "path";
 async function indexLocalProject(projectRoot, graphStore, repoId, opts) {
   const startTime = Date.now();
@@ -10361,7 +10645,7 @@ async function indexLocalProject(projectRoot, graphStore, repoId, opts) {
     });
     let content;
     try {
-      content = readFileSync18(absPath, "utf-8");
+      content = readFileSync19(absPath, "utf-8");
     } catch {
       filesProcessed++;
       continue;
@@ -10472,10 +10756,18 @@ async function indexLocalProject(projectRoot, graphStore, repoId, opts) {
     ...coChangeCompactEdges
   ];
   await populateCozoDB(graphStore, allEntities, allEdges);
+  progress?.({
+    processed: filesProcessed,
+    total: files.length,
+    phase: "documents",
+    currentFile: null
+  });
+  const docKeys = await indexDocumentFiles(projectRoot, graphStore);
   for (const e of allEntities) indexedEntityKeys.add(e.key);
   for (const e of allEntities) {
     if (e.file_path) indexedEntityKeys.add(`file:${e.file_path}`);
   }
+  for (const dk of docKeys) indexedEntityKeys.add(dk);
   await removeOrphanedEntities(graphStore, indexedEntityKeys);
   await materializeL1Edges(graphStore);
   progress?.({
@@ -10511,7 +10803,7 @@ async function indexLocalProject(projectRoot, graphStore, repoId, opts) {
   await persistLocalSnapshot(projectRoot, repoId, allEntities, resolvedEdges);
   const elapsedMs = Date.now() - startTime;
   log6.info(
-    `Indexed ${files.length} files \u2192 ${allEntities.length} entities, ${resolvedEdges.length} edges in ${elapsedMs}ms`
+    `Indexed ${files.length} files \u2192 ${allEntities.length} entities, ${resolvedEdges.length} edges, ${docKeys.length} docs in ${elapsedMs}ms`
   );
   return {
     fileCount: files.length,
@@ -10520,6 +10812,7 @@ async function indexLocalProject(projectRoot, graphStore, repoId, opts) {
     communityCount,
     patternCount,
     ruleCount,
+    docCount: docKeys.length,
     elapsedMs,
     scip: scipResult.mergeResult ? {
       language: scipResult.language,
@@ -10535,7 +10828,7 @@ async function reindexFile(projectRoot, filePath, graphStore, repoId) {
   await removeFileEntities(graphStore, relPath);
   let content;
   try {
-    content = readFileSync18(absPath, "utf-8");
+    content = readFileSync19(absPath, "utf-8");
   } catch {
     return { entities: 0, edges: 0 };
   }
@@ -10969,7 +11262,8 @@ async function populateCozoDB(graphStore, entities, edges) {
         { key: `file:${fp}`, name: basename2(fp), fp, is_test: isTestFile(fp) }
       );
     } catch (err) {
-      process.stderr.write(`[unerr] \u26A0 File entity insert failed for ${fp}: ${err instanceof Error ? err.message : String(err)}
+      const msg = err instanceof Error ? err.message : JSON.stringify(err);
+      process.stderr.write(`[unerr] \u26A0 File entity insert failed for ${fp}: ${msg}
 `);
     }
   }
@@ -11341,7 +11635,113 @@ async function resolveEntityNameGlobal(name, graphStore) {
   }
   return null;
 }
-var INDEXABLE_EXTENSIONS, EXCLUDED_DIRS2, MAX_FILE_SIZE, log6;
+function walkDirForDocs(dir, files, projectRoot) {
+  let entries;
+  try {
+    entries = readdirSync6(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const absPath = join24(dir, entry);
+    let stats;
+    try {
+      stats = statSync6(absPath);
+    } catch {
+      continue;
+    }
+    if (stats.isDirectory()) {
+      if (EXCLUDED_DIRS2.has(entry)) continue;
+      if (entry.startsWith(".") && !CI_CD_DIRS.has(entry)) continue;
+      walkDirForDocs(absPath, files, projectRoot);
+      continue;
+    }
+    if (!stats.isFile()) continue;
+    if (stats.size > MAX_FILE_SIZE) continue;
+    const ext = extname2(entry).toLowerCase();
+    const name = basename2(entry);
+    if (INDEXABLE_EXTENSIONS.has(ext)) continue;
+    if (DOCUMENT_EXTENSIONS.has(ext) || DOCUMENT_NAMES.has(name)) {
+      files.push(absPath);
+    }
+  }
+}
+function discoverDocumentFiles(projectRoot) {
+  const files = [];
+  walkDirForDocs(projectRoot, files, projectRoot);
+  return files;
+}
+function extractDocTokens(absPath, relPath) {
+  const tokens = new Set(tokenize(basename2(relPath)));
+  for (const segment of relPath.split("/").slice(0, -1)) {
+    if (segment && !EXCLUDED_DIRS2.has(segment)) {
+      for (const t of tokenize(segment)) tokens.add(t);
+    }
+  }
+  const ext = extname2(absPath).toLowerCase();
+  try {
+    const content = readFileSync19(absPath, "utf-8").slice(0, DOC_READ_LIMIT);
+    const pattern = DOC_TOKEN_PATTERNS[ext];
+    if (pattern) {
+      pattern.lastIndex = 0;
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        if (match[1]) for (const t of tokenize(match[1])) tokens.add(t);
+        if (match[2]) for (const t of tokenize(match[2])) tokens.add(t);
+      }
+    }
+    if (ext === ".yaml" || ext === ".yml") {
+      const yamlKeyRegex = /^([a-zA-Z_][\w-]*)\s*:/gm;
+      let match;
+      while ((match = yamlKeyRegex.exec(content)) !== null) {
+        if (match[1]) for (const t of tokenize(match[1])) tokens.add(t);
+      }
+    }
+  } catch {
+  }
+  return [...tokens];
+}
+async function indexDocumentFiles(projectRoot, graphStore) {
+  const docFiles = discoverDocumentFiles(projectRoot);
+  if (docFiles.length === 0) return [];
+  const docKeys = [];
+  for (const absPath of docFiles) {
+    const relPath = relative(projectRoot, absPath);
+    const name = basename2(relPath);
+    const key = `doc:${relPath}`;
+    docKeys.push(key);
+    try {
+      await graphStore.db.run(
+        '?[key, kind, name, file_path, fan_in, fan_out, risk_level] <- [[$key, "document", $name, $fp, 0, 0, "low"]] :put entities { key => kind, name, file_path, fan_in, fan_out, risk_level }',
+        { key, name, fp: relPath }
+      );
+    } catch {
+      continue;
+    }
+    const docTokens = extractDocTokens(absPath, relPath);
+    for (const token of docTokens) {
+      try {
+        await graphStore.db.run(
+          "?[token, entity_key] <- [[$token, $key]] :put search_tokens { token, entity_key }",
+          { token, key }
+        );
+      } catch {
+      }
+    }
+    try {
+      await graphStore.db.run(
+        "?[file_path, entity_key] <- [[$fp, $key]] :put file_index { file_path, entity_key }",
+        { fp: relPath, key }
+      );
+    } catch {
+    }
+  }
+  if (docKeys.length > 0) {
+    log6.info(`Documents: ${docKeys.length} doc/config files indexed for search`);
+  }
+  return docKeys;
+}
+var INDEXABLE_EXTENSIONS, EXCLUDED_DIRS2, MAX_FILE_SIZE, DOCUMENT_EXTENSIONS, DOCUMENT_NAMES, CI_CD_DIRS, DOC_READ_LIMIT, log6, DOC_TOKEN_PATTERNS;
 var init_local_indexer = __esm({
   "src/intelligence/local-indexer.ts"() {
     "use strict";
@@ -11395,6 +11795,87 @@ var init_local_indexer = __esm({
       ".parcel-cache"
     ]);
     MAX_FILE_SIZE = 1048576;
+    DOCUMENT_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".md",
+      ".mdx",
+      ".txt",
+      ".rst",
+      ".adoc",
+      ".org",
+      ".yaml",
+      ".yml",
+      ".toml",
+      ".json",
+      ".xml",
+      ".tf",
+      ".tfvars",
+      ".hcl",
+      ".proto",
+      ".graphql",
+      ".gql",
+      ".sql",
+      ".sh",
+      ".bash",
+      ".zsh",
+      ".html",
+      ".css",
+      ".scss",
+      ".sass",
+      ".less",
+      ".vue",
+      ".svelte",
+      ".astro",
+      ".j2",
+      ".jinja2",
+      ".tmpl",
+      ".hbs",
+      ".ejs",
+      ".pug",
+      ".prisma",
+      ".avsc",
+      ".thrift",
+      ".smithy",
+      ".cmake",
+      ".bazel",
+      ".bzl",
+      ".mk",
+      ".csv",
+      ".tsv",
+      ".ini",
+      ".cfg",
+      ".conf",
+      ".properties",
+      ".env.example",
+      ".editorconfig",
+      ".dockerfile",
+      ".tex",
+      ".latex",
+      ".eslintrc",
+      ".prettierrc",
+      ".stylelintrc",
+      ".pylintrc",
+      ".flake8"
+    ]);
+    DOCUMENT_NAMES = /* @__PURE__ */ new Set([
+      "Dockerfile",
+      "Makefile",
+      "Procfile",
+      "Vagrantfile",
+      "Jenkinsfile",
+      "Gemfile",
+      "Rakefile",
+      ".gitignore",
+      ".dockerignore",
+      ".prettierrc",
+      ".editorconfig",
+      ".eslintrc",
+      ".stylelintrc",
+      "biome.json",
+      "tslint.json",
+      ".gitlab-ci.yml"
+    ]);
+    CI_CD_DIRS = /* @__PURE__ */ new Set([".github", ".circleci"]);
+    DOC_READ_LIMIT = 8192;
     log6 = {
       info: (msg) => process.stderr.write(`[unerr] ${msg}
 `),
@@ -11403,6 +11884,31 @@ var init_local_indexer = __esm({
 `);
       }
     };
+    DOC_TOKEN_PATTERNS = {
+      ".md": /^#{1,6}\s+(.+)$/gm,
+      ".mdx": /^#{1,6}\s+(.+)$/gm,
+      ".tf": /^(?:resource|module|variable|data|output)\s+"([^"]+)"(?:\s+"([^"]+)")?/gm,
+      ".hcl": /^(?:resource|module|variable|data|output)\s+"([^"]+)"(?:\s+"([^"]+)")?/gm,
+      ".sql": /CREATE\s+(?:TABLE|VIEW|FUNCTION|PROCEDURE|INDEX)\s+(?:IF\s+NOT\s+EXISTS\s+)?["'`]?(\w+)/gim,
+      ".graphql": /^(?:type|query|mutation|subscription|input|enum|interface)\s+(\w+)/gm,
+      ".gql": /^(?:type|query|mutation|subscription|input|enum|interface)\s+(\w+)/gm,
+      ".sh": /^(?:function\s+)?(\w+)\s*\(\)/gm,
+      ".bash": /^(?:function\s+)?(\w+)\s*\(\)/gm,
+      ".zsh": /^(?:function\s+)?(\w+)\s*\(\)/gm,
+      ".proto": /^(?:message|service|enum|rpc)\s+(\w+)/gm,
+      ".prisma": /^(?:model|enum|type|datasource|generator)\s+(\w+)/gm,
+      ".smithy": /^(?:service|resource|operation|structure|union|enum)\s+(\w+)/gm,
+      ".cmake": /^(?:project|add_library|add_executable|find_package)\s*\(\s*(\w+)/gm,
+      ".bazel": /^(?:cc_library|cc_binary|java_library|py_library|go_library)\s*\(\s*name\s*=\s*"([^"]+)"/gm,
+      ".bzl": /^def\s+(\w+)\s*\(/gm,
+      ".tex": /\\(?:section|subsection|chapter|title)\{([^}]+)\}/gm,
+      ".latex": /\\(?:section|subsection|chapter|title)\{([^}]+)\}/gm,
+      ".html": /<(?:h[1-6]|title)[^>]*>([^<]+)</gim,
+      ".vue": /<(?:h[1-6]|title)[^>]*>([^<]+)</gim,
+      ".svelte": /<(?:h[1-6]|title)[^>]*>([^<]+)</gim,
+      ".thrift": /^(?:service|struct|enum|exception|typedef)\s+(\w+)/gm,
+      ".avsc": /"name"\s*:\s*"([^"]+)"/gm
+    };
   }
 });
 
@@ -11415,23 +11921,23 @@ __export(hook_installer_exports, {
 });
 import {
   chmodSync as chmodSync3,
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   mkdirSync as mkdirSync13,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync9
+  writeFileSync as writeFileSync10
 } from "fs";
 import { join as join25 } from "path";
 function installClaudeHook(cwd) {
   const hooksDir = join25(cwd, ".claude", "hooks");
   const hookPath = join25(hooksDir, "PostToolUse.sh");
-  if (existsSync18(hookPath)) {
+  if (existsSync19(hookPath)) {
     return { path: hookPath, action: "already_exists" };
   }
   try {
-    if (!existsSync18(hooksDir)) {
+    if (!existsSync19(hooksDir)) {
       mkdirSync13(hooksDir, { recursive: true });
     }
-    writeFileSync9(hookPath, HOOK_CONTENT, "utf-8");
+    writeFileSync10(hookPath, HOOK_CONTENT, "utf-8");
     chmodSync3(hookPath, 493);
     return { path: hookPath, action: "installed" };
   } catch {
@@ -11440,7 +11946,7 @@ function installClaudeHook(cwd) {
 }
 function removeClaudeHook(cwd) {
   const hookPath = join25(cwd, ".claude", "hooks", "PostToolUse.sh");
-  if (!existsSync18(hookPath)) return false;
+  if (!existsSync19(hookPath)) return false;
   try {
     unlinkSync2(hookPath);
     return true;
@@ -11449,7 +11955,7 @@ function removeClaudeHook(cwd) {
   }
 }
 function isClaudeHookInstalled(cwd) {
-  return existsSync18(join25(cwd, ".claude", "hooks", "PostToolUse.sh"));
+  return existsSync19(join25(cwd, ".claude", "hooks", "PostToolUse.sh"));
 }
 var HOOK_CONTENT;
 var init_hook_installer = __esm({
@@ -11476,13 +11982,13 @@ __export(tool_detector_exports, {
   detectTools: () => detectTools,
   formatDetectedTools: () => formatDetectedTools
 });
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 import { join as join26 } from "path";
 function detectTools(cwd) {
   const detected = [];
   for (const agent of AGENT_REGISTRY) {
     const hasDirMarker = agent.dirMarkers.some(
-      (dir) => existsSync19(join26(cwd, dir))
+      (dir) => existsSync20(join26(cwd, dir))
     );
     const hasEnvVar = agent.envVars.some((envVar) => !!process.env[envVar]);
     if (hasDirMarker || hasEnvVar) {
@@ -11490,7 +11996,7 @@ function detectTools(cwd) {
       detected.push({
         ide: agent.id,
         configDir: join26(cwd, agent.dirMarkers[0] ?? ""),
-        hasExistingConfig: existsSync19(configPath),
+        hasExistingConfig: existsSync20(configPath),
         agent
       });
     }
@@ -11834,13 +12340,13 @@ __export(resolver_exports, {
   scanSkillDirectory: () => scanSkillDirectory
 });
 import {
-  existsSync as existsSync22,
+  existsSync as existsSync23,
   mkdirSync as mkdirSync16,
-  readFileSync as readFileSync21,
+  readFileSync as readFileSync22,
   readdirSync as readdirSync7,
   rmSync,
   unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync12
+  writeFileSync as writeFileSync13
 } from "fs";
 import { homedir as homedir6 } from "os";
 import { dirname as dirname6, join as join29 } from "path";
@@ -11940,7 +12446,7 @@ function writeSkillFile(skill, ide, skillDir, ext, dirPerSkill) {
     filePath = join29(skillDir, `${skillName}${ext}`);
     content = formatMarkdownSkill(skill);
   }
-  writeFileSync12(filePath, content);
+  writeFileSync13(filePath, content);
   return filePath;
 }
 function formatClaudeCodeSkill(skill) {
@@ -12117,13 +12623,13 @@ function parseFrontmatter(raw) {
   return { meta, content };
 }
 function scanSkillDirectory(dir) {
-  if (!existsSync22(dir)) return [];
+  if (!existsSync23(dir)) return [];
   const skills = [];
   try {
     const files = readdirSync7(dir).filter((f) => f.endsWith(".md"));
     for (const file of files) {
       try {
-        const raw = readFileSync21(join29(dir, file), "utf-8");
+        const raw = readFileSync22(join29(dir, file), "utf-8");
         const { meta, content } = parseFrontmatter(raw);
         const name = meta.name ?? file.replace(/\.md$/, "");
         skills.push({
@@ -12170,13 +12676,13 @@ async function resolveAndInstallSkills(opts) {
 }
 async function ensureSkillsPresent(opts) {
   const { dir, ext, dirPerSkill } = getSkillDir(opts.ide, opts.cwd);
-  if (existsSync22(dir)) {
+  if (existsSync23(dir)) {
     try {
       const entries = readdirSync7(dir);
       let hasSkills;
       if (dirPerSkill) {
         hasSkills = entries.some(
-          (f) => f.startsWith("unerr-") && existsSync22(join29(dir, f, "SKILL.md"))
+          (f) => f.startsWith("unerr-") && existsSync23(join29(dir, f, "SKILL.md"))
         );
       } else {
         hasSkills = entries.some(
@@ -12192,11 +12698,11 @@ async function ensureSkillsPresent(opts) {
 }
 function listInstalledSkills(ide, cwd) {
   const { dir, ext, dirPerSkill } = getSkillDir(ide, cwd);
-  if (!existsSync22(dir)) return [];
+  if (!existsSync23(dir)) return [];
   try {
     if (dirPerSkill) {
       return readdirSync7(dir).filter(
-        (f) => f.startsWith("unerr-") && existsSync22(join29(dir, f, "SKILL.md"))
+        (f) => f.startsWith("unerr-") && existsSync23(join29(dir, f, "SKILL.md"))
       ).map((f) => ({
         name: f.replace("unerr-", ""),
         path: join29(dir, f, "SKILL.md")
@@ -12239,7 +12745,7 @@ var correction_detector_exports = {};
 __export(correction_detector_exports, {
   detectCorrections: () => detectCorrections
 });
-import { existsSync as existsSync24, readFileSync as readFileSync23 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync24 } from "fs";
 function detectCorrections(ledgerPath, options) {
   const MIN_CONFIDENCE = options?.min_confidence ?? 0.6;
   const CORRECTION_WINDOW = options?.correction_window_ms ?? 6e4;
@@ -12262,11 +12768,11 @@ function detectCorrections(ledgerPath, options) {
   return deduplicatePatterns(scored);
 }
 function readLedgerEntries(ledgerPath, sinceDays) {
-  if (!existsSync24(ledgerPath)) return [];
+  if (!existsSync25(ledgerPath)) return [];
   const cutoff = Date.now() - sinceDays * 24 * 60 * 60 * 1e3;
   const entries = [];
   try {
-    const content = readFileSync23(ledgerPath, "utf-8");
+    const content = readFileSync24(ledgerPath, "utf-8");
     const lines = content.split("\n");
     for (const line of lines) {
       if (line.trim().length === 0) continue;
@@ -12471,10 +12977,10 @@ __export(offline_rewind_exports, {
 import { randomBytes } from "crypto";
 import {
   appendFileSync as appendFileSync6,
-  existsSync as existsSync27,
+  existsSync as existsSync28,
   mkdirSync as mkdirSync18,
-  readFileSync as readFileSync25,
-  writeFileSync as writeFileSync14
+  readFileSync as readFileSync26,
+  writeFileSync as writeFileSync15
 } from "fs";
 import { join as join33 } from "path";
 async function offlineRewind(input) {
@@ -12612,9 +13118,9 @@ async function computeLocalBlastRadius(graph, revertFiles, targetFiles, startTim
 }
 function readBranchCounter(unerrDir) {
   const contextPath = join33(unerrDir, "ledger", "branch_context.json");
-  if (!existsSync27(contextPath)) return 1;
+  if (!existsSync28(contextPath)) return 1;
   try {
-    const data = JSON.parse(readFileSync25(contextPath, "utf-8"));
+    const data = JSON.parse(readFileSync26(contextPath, "utf-8"));
     return data.timeline_branch ?? 1;
   } catch {
     return 1;
@@ -12623,13 +13129,13 @@ function readBranchCounter(unerrDir) {
 function incrementBranchCounter(unerrDir) {
   const contextPath = join33(unerrDir, "ledger", "branch_context.json");
   const ledgerDir = join33(unerrDir, "ledger");
-  if (!existsSync27(ledgerDir)) {
+  if (!existsSync28(ledgerDir)) {
     mkdirSync18(ledgerDir, { recursive: true });
   }
   let data = {};
-  if (existsSync27(contextPath)) {
+  if (existsSync28(contextPath)) {
     try {
-      data = JSON.parse(readFileSync25(contextPath, "utf-8"));
+      data = JSON.parse(readFileSync26(contextPath, "utf-8"));
     } catch {
     }
   }
@@ -12637,25 +13143,25 @@ function incrementBranchCounter(unerrDir) {
   const next = current + 1;
   data.timeline_branch = next;
   data.last_rewind_at = (/* @__PURE__ */ new Date()).toISOString();
-  writeFileSync14(contextPath, JSON.stringify(data, null, 2), "utf-8");
+  writeFileSync15(contextPath, JSON.stringify(data, null, 2), "utf-8");
   return next;
 }
 function markEntriesReverted(unerrDir, entryIds) {
   if (entryIds.length === 0) return;
   const revertedPath = join33(unerrDir, "ledger", "reverted_entries.json");
   const ledgerDir = join33(unerrDir, "ledger");
-  if (!existsSync27(ledgerDir)) {
+  if (!existsSync28(ledgerDir)) {
     mkdirSync18(ledgerDir, { recursive: true });
   }
   let existing = [];
-  if (existsSync27(revertedPath)) {
+  if (existsSync28(revertedPath)) {
     try {
-      existing = JSON.parse(readFileSync25(revertedPath, "utf-8"));
+      existing = JSON.parse(readFileSync26(revertedPath, "utf-8"));
     } catch {
     }
   }
   const merged = Array.from(/* @__PURE__ */ new Set([...existing, ...entryIds]));
-  writeFileSync14(revertedPath, JSON.stringify(merged, null, 2), "utf-8");
+  writeFileSync15(revertedPath, JSON.stringify(merged, null, 2), "utf-8");
 }
 function extractFilesFromEntry(entry) {
   const files = [];
@@ -12715,10 +13221,10 @@ __export(shadow_ledger_exports, {
 import { randomBytes as randomBytes2 } from "crypto";
 import {
   appendFileSync as appendFileSync7,
-  existsSync as existsSync28,
+  existsSync as existsSync29,
   mkdirSync as mkdirSync19,
-  readFileSync as readFileSync26,
-  writeFileSync as writeFileSync15
+  readFileSync as readFileSync27,
+  writeFileSync as writeFileSync16
 } from "fs";
 import { join as join34 } from "path";
 function generateId2() {
@@ -12753,7 +13259,7 @@ var init_shadow_ledger = __esm({
         this.ledgerDir = join34(unerrDir, "ledger");
         this.filePath = join34(this.ledgerDir, "shadow.jsonl");
         this.sessionId = generateId2();
-        if (!existsSync28(this.ledgerDir)) {
+        if (!existsSync29(this.ledgerDir)) {
           mkdirSync19(this.ledgerDir, { recursive: true });
         }
         this.recoverFile();
@@ -12860,9 +13366,9 @@ var init_shadow_ledger = __esm({
        * Get all entries (read from file). Used sparingly — prefer buffer.
        */
       readAllEntries() {
-        if (!existsSync28(this.filePath)) return [];
+        if (!existsSync29(this.filePath)) return [];
         try {
-          const content = readFileSync26(this.filePath, "utf-8");
+          const content = readFileSync27(this.filePath, "utf-8");
           const lines = content.split("\n").filter((l) => l.trim().length > 0);
           return lines.map((line) => JSON.parse(line));
         } catch {
@@ -12899,9 +13405,9 @@ var init_shadow_ledger = __esm({
        * Recover from file corruption: truncate to last valid JSONL line.
        */
       recoverFile() {
-        if (!existsSync28(this.filePath)) return;
+        if (!existsSync29(this.filePath)) return;
         try {
-          const content = readFileSync26(this.filePath, "utf-8");
+          const content = readFileSync27(this.filePath, "utf-8");
           const lines = content.split("\n");
           const validLines = [];
           for (const line of lines) {
@@ -12918,23 +13424,23 @@ var init_shadow_ledger = __esm({
             }
           }
           if (validLines.length < lines.filter((l) => l.trim().length > 0).length) {
-            writeFileSync15(
+            writeFileSync16(
               this.filePath,
               validLines.join("\n") + (validLines.length > 0 ? "\n" : ""),
               "utf-8"
             );
           }
         } catch {
-          writeFileSync15(this.filePath, "", "utf-8");
+          writeFileSync16(this.filePath, "", "utf-8");
         }
       }
       /**
        * Load the most recent entries from the file into the buffer.
        */
       loadRecentEntries() {
-        if (!existsSync28(this.filePath)) return;
+        if (!existsSync29(this.filePath)) return;
         try {
-          const content = readFileSync26(this.filePath, "utf-8");
+          const content = readFileSync27(this.filePath, "utf-8");
           const lines = content.split("\n").filter((l) => l.trim().length > 0);
           const start = Math.max(0, lines.length - MAX_BUFFER_SIZE);
           for (let i = start; i < lines.length; i++) {
@@ -12962,9 +13468,9 @@ var init_shadow_ledger = __esm({
        * Count total entries in the file.
        */
       countEntries() {
-        if (!existsSync28(this.filePath)) return 0;
+        if (!existsSync29(this.filePath)) return 0;
         try {
-          const content = readFileSync26(this.filePath, "utf-8");
+          const content = readFileSync27(this.filePath, "utf-8");
           return content.split("\n").filter((l) => l.trim().length > 0).length;
         } catch {
           return 0;
@@ -12989,7 +13495,7 @@ __export(timeline_fork_exports, {
   resetTimelineForks: () => resetTimelineForks,
   wasForkPoint: () => wasForkPoint
 });
-import { existsSync as existsSync29, mkdirSync as mkdirSync20, readFileSync as readFileSync27, writeFileSync as writeFileSync16 } from "fs";
+import { existsSync as existsSync30, mkdirSync as mkdirSync20, readFileSync as readFileSync28, writeFileSync as writeFileSync17 } from "fs";
 import { join as join35 } from "path";
 function createTimelineFork(snapshotId, abandonedEntities, prompts, reason, unerrDir) {
   const state = unerrDir ? loadState(unerrDir) : { activeTimeline: inMemoryTimeline, forks: [] };
@@ -13120,17 +13626,17 @@ function getStatePath(unerrDir) {
 }
 function ensureStateDir(unerrDir) {
   const stateDir = join35(unerrDir, "state");
-  if (!existsSync29(stateDir)) {
+  if (!existsSync30(stateDir)) {
     mkdirSync20(stateDir, { recursive: true });
   }
 }
 function loadState(unerrDir) {
   const path7 = getStatePath(unerrDir);
-  if (!existsSync29(path7)) {
+  if (!existsSync30(path7)) {
     return { activeTimeline: 0, forks: [] };
   }
   try {
-    const raw = readFileSync27(path7, "utf-8");
+    const raw = readFileSync28(path7, "utf-8");
     const parsed = JSON.parse(raw);
     return {
       activeTimeline: typeof parsed.activeTimeline === "number" ? parsed.activeTimeline : 0,
@@ -13144,7 +13650,7 @@ function loadState(unerrDir) {
 function saveState(unerrDir, state) {
   ensureStateDir(unerrDir);
   const path7 = getStatePath(unerrDir);
-  writeFileSync16(path7, JSON.stringify(state, null, 2), "utf-8");
+  writeFileSync17(path7, JSON.stringify(state, null, 2), "utf-8");
 }
 function deduplicateStrings(arr) {
   return Array.from(new Set(arr));
@@ -13206,9 +13712,9 @@ function createEmptyAllTime() {
 function loadStats() {
   const currentWeek = getWeekStart();
   try {
-    const { readFileSync: readFileSync57 } = __require("fs");
+    const { readFileSync: readFileSync58 } = __require("fs");
     const raw = JSON.parse(
-      readFileSync57(getStatsPath(), "utf-8")
+      readFileSync58(getStatsPath(), "utf-8")
     );
     if (raw.version !== 1) {
       return {
@@ -13331,7 +13837,7 @@ __export(branch_context_exports, {
   getHeadSha: () => getHeadSha2,
   startBranchPoller: () => startBranchPoller
 });
-import { existsSync as existsSync30, readFileSync as readFileSync28 } from "fs";
+import { existsSync as existsSync31, readFileSync as readFileSync29 } from "fs";
 import { join as join37 } from "path";
 async function computeBranchContext(cwd) {
   const dir = cwd ?? process.cwd();
@@ -13396,9 +13902,9 @@ function detectBranchSwitch(previousBranch, cwd) {
 function getCurrentBranch2(cwd) {
   const gitDir = cwd ? join37(cwd, ".git") : join37(process.cwd(), ".git");
   const headPath = join37(gitDir, "HEAD");
-  if (!existsSync30(headPath)) return null;
+  if (!existsSync31(headPath)) return null;
   try {
-    const content = readFileSync28(headPath, "utf-8").trim();
+    const content = readFileSync29(headPath, "utf-8").trim();
     if (content.startsWith("ref: refs/heads/")) {
       return content.slice("ref: refs/heads/".length);
     }
@@ -13921,9 +14427,9 @@ function getCumulativePath() {
 function loadCumulativeStats() {
   const currentWeek = getWeekStart2();
   try {
-    const { readFileSync: readFileSync57 } = __require("fs");
+    const { readFileSync: readFileSync58 } = __require("fs");
     const raw = JSON.parse(
-      readFileSync57(getCumulativePath(), "utf-8")
+      readFileSync58(getCumulativePath(), "utf-8")
     );
     if (raw.weekStart !== currentWeek) {
       return {
@@ -13984,9 +14490,9 @@ function createEmptyCumulativeLocal(weekStart) {
 function loadCumulativeLocalStats() {
   const currentWeek = getWeekStart2();
   try {
-    const { readFileSync: readFileSync57 } = __require("fs");
+    const { readFileSync: readFileSync58 } = __require("fs");
     const raw = JSON.parse(
-      readFileSync57(getCumulativeLocalPath(), "utf-8")
+      readFileSync58(getCumulativeLocalPath(), "utf-8")
     );
     if (raw.weekStartDate !== currentWeek) {
       return createEmptyCumulativeLocal(currentWeek);
@@ -14590,11 +15096,11 @@ __export(pid_lock_exports, {
   PidLock: () => PidLock
 });
 import {
-  existsSync as existsSync34,
+  existsSync as existsSync35,
   mkdirSync as mkdirSync21,
-  readFileSync as readFileSync32,
+  readFileSync as readFileSync33,
   unlinkSync as unlinkSync6,
-  writeFileSync as writeFileSync18
+  writeFileSync as writeFileSync19
 } from "fs";
 import { createServer } from "http";
 import { join as join41 } from "path";
@@ -14674,12 +15180,12 @@ var init_pid_lock = __esm({
        */
       async acquire() {
         const stateDir = join41(this.pidPath, "..");
-        if (!existsSync34(stateDir)) {
+        if (!existsSync35(stateDir)) {
           mkdirSync21(stateDir, { recursive: true });
         }
-        if (existsSync34(this.pidPath)) {
+        if (existsSync35(this.pidPath)) {
           try {
-            const raw = readFileSync32(this.pidPath, "utf-8").trim();
+            const raw = readFileSync33(this.pidPath, "utf-8").trim();
             const pidData = parsePidFile(raw);
             if (pidData && isProcessAlive(pidData.pid)) {
               if (pidData.healthPort) {
@@ -14739,7 +15245,7 @@ var init_pid_lock = __esm({
           startedAt: this.startedAt,
           healthPort: this.healthPort
         };
-        writeFileSync18(this.pidPath, JSON.stringify(data), "utf-8");
+        writeFileSync19(this.pidPath, JSON.stringify(data), "utf-8");
       }
       async startHealthServer() {
         return new Promise((resolve3) => {
@@ -14784,8 +15290,8 @@ var init_pid_lock = __esm({
           this.healthServer = null;
         }
         try {
-          if (existsSync34(this.pidPath)) {
-            const raw = readFileSync32(this.pidPath, "utf-8").trim();
+          if (existsSync35(this.pidPath)) {
+            const raw = readFileSync33(this.pidPath, "utf-8").trim();
             const data = parsePidFile(raw);
             if (data && data.pid === process.pid) {
               unlinkSync6(this.pidPath);
@@ -14798,9 +15304,9 @@ var init_pid_lock = __esm({
        * Check if a proxy is currently running (for external callers).
        */
       isLocked() {
-        if (!existsSync34(this.pidPath)) return { locked: false };
+        if (!existsSync35(this.pidPath)) return { locked: false };
         try {
-          const raw = readFileSync32(this.pidPath, "utf-8").trim();
+          const raw = readFileSync33(this.pidPath, "utf-8").trim();
           const data = parsePidFile(raw);
           if (data && isProcessAlive(data.pid)) {
             return { locked: true, pid: data.pid, healthPort: data.healthPort };
@@ -14815,9 +15321,9 @@ var init_pid_lock = __esm({
        * Uses health check for full verification (unlike isLocked() which is sync-only).
        */
       async probe() {
-        if (!existsSync34(this.pidPath)) return { alive: false };
+        if (!existsSync35(this.pidPath)) return { alive: false };
         try {
-          const raw = readFileSync32(this.pidPath, "utf-8").trim();
+          const raw = readFileSync33(this.pidPath, "utf-8").trim();
           const pidData = parsePidFile(raw);
           if (!pidData || !isProcessAlive(pidData.pid)) return { alive: false };
           if (pidData.healthPort) {
@@ -14834,9 +15340,9 @@ var init_pid_lock = __esm({
        */
       static readPidFile(stateDir) {
         const pidPath = join41(stateDir, PID_FILENAME);
-        if (!existsSync34(pidPath)) return null;
+        if (!existsSync35(pidPath)) return null;
         try {
-          const raw = readFileSync32(pidPath, "utf-8").trim();
+          const raw = readFileSync33(pidPath, "utf-8").trim();
           const data = parsePidFile(raw);
           if (data && isProcessAlive(data.pid)) return data;
           return null;
@@ -15127,6 +15633,11 @@ var init_tool_definitions = __esm({
               description: "Direction of references: 'callers' (who calls this entity, default) or 'callees' (what this entity calls)",
               default: "callers"
             },
+            limit: {
+              type: "number",
+              description: "Max number of references to return (default 25). Use higher values only when you need the full list.",
+              default: 25
+            },
             token_budget: TOKEN_BUDGET_PROP
           },
           required: ["key"]
@@ -15285,12 +15796,8 @@ var init_tool_definitions = __esm({
             },
             purpose: {
               type: "string",
-              enum: ["explore", "edit", "reference"],
-              description: "Read intent: 'explore' (default, budget-capped for browsing), 'edit' (full file, no gating \u2014 use when you plan to modify), 'reference' (entity/offset only, tight budget)"
-            },
-            force_full: {
-              type: "boolean",
-              description: "Force full file read even for large files (alias for purpose:'edit')"
+              enum: ["explore", "reference"],
+              description: "Read intent: 'explore' (default, budget-capped for browsing/understanding), 'reference' (entity/offset only, tight budget). To edit a file, use file_read(explore) to understand it, then built-in Read with offset/limit on the target lines, then Edit."
             },
             token_budget: TOKEN_BUDGET_PROP
           },
@@ -15643,7 +16150,7 @@ var init_deep_link = __esm({
 });
 
 // src/proxy/startup-renderer.ts
-import { existsSync as existsSync35, readFileSync as readFileSync33, writeFileSync as writeFileSync19 } from "fs";
+import { existsSync as existsSync36, readFileSync as readFileSync34, writeFileSync as writeFileSync20 } from "fs";
 import { join as join42 } from "path";
 import React2 from "react";
 var StartupRenderer;
@@ -15756,9 +16263,9 @@ var init_startup_renderer = __esm({
           "state",
           "graph_version.json"
         );
-        if (!existsSync35(versionPath)) return true;
+        if (!existsSync36(versionPath)) return true;
         try {
-          const data = JSON.parse(readFileSync33(versionPath, "utf-8"));
+          const data = JSON.parse(readFileSync34(versionPath, "utf-8"));
           return !data.first_boot_shown;
         } catch {
           return true;
@@ -15769,11 +16276,11 @@ var init_startup_renderer = __esm({
         const versionPath = join42(stateDir, "graph_version.json");
         try {
           let data = {};
-          if (existsSync35(versionPath)) {
-            data = JSON.parse(readFileSync33(versionPath, "utf-8"));
+          if (existsSync36(versionPath)) {
+            data = JSON.parse(readFileSync34(versionPath, "utf-8"));
           }
           data.first_boot_shown = true;
-          writeFileSync19(versionPath, JSON.stringify(data, null, 2));
+          writeFileSync20(versionPath, JSON.stringify(data, null, 2));
         } catch {
         }
       }
@@ -16044,13 +16551,13 @@ var init_lifecycle_actor = __esm({
 });
 
 // src/intelligence/facts-schema.ts
-import { existsSync as existsSync36, mkdirSync as mkdirSync22 } from "fs";
+import { existsSync as existsSync37, mkdirSync as mkdirSync22 } from "fs";
 import { join as join43 } from "path";
 async function openFactsDb(projectRoot) {
   const unerrDir = join43(projectRoot, ".unerr");
   mkdirSync22(unerrDir, { recursive: true });
   const dbPath = join43(unerrDir, FACTS_DB_FILENAME);
-  const isNew = !existsSync36(dbPath);
+  const isNew = !existsSync37(dbPath);
   const cozoModule = await import("cozo-node");
   const CozoDbConstructor = cozoModule.default ? cozoModule.default.CozoDb : cozoModule.CozoDb;
   const db = new CozoDbConstructor("sqlite", dbPath);
@@ -16651,7 +17158,7 @@ __export(fact_generator_exports, {
   generateFromSessionAnalysis: () => generateFromSessionAnalysis,
   runFactGenerationPipeline: () => runFactGenerationPipeline
 });
-import { existsSync as existsSync37, readdirSync as readdirSync9, readFileSync as readFileSync34 } from "fs";
+import { existsSync as existsSync38, readdirSync as readdirSync9, readFileSync as readFileSync35 } from "fs";
 import { join as join44 } from "path";
 async function runFactGenerationPipeline(factStore2, unerrDir) {
   const results = [];
@@ -16804,13 +17311,13 @@ async function generateFromSessionAnalysis(factStore2, unerrDir) {
 }
 function loadRecentSessions(unerrDir, limit) {
   const sessionsDir = join44(unerrDir, "sessions");
-  if (!existsSync37(sessionsDir)) return [];
+  if (!existsSync38(sessionsDir)) return [];
   try {
     const files = readdirSync9(sessionsDir).filter((f) => f.endsWith(".jsonl")).sort().slice(-limit);
     const summaries = [];
     for (const file of files) {
       try {
-        const content = readFileSync34(join44(sessionsDir, file), "utf-8");
+        const content = readFileSync35(join44(sessionsDir, file), "utf-8");
         const lines = content.trim().split("\n").filter(Boolean);
         const lastLine = lines[lines.length - 1];
         if (lastLine) {
@@ -17334,7 +17841,7 @@ var init_model_pricing = __esm({
 });
 
 // src/tracking/entity-rewind.ts
-import { readFileSync as readFileSync35, writeFileSync as writeFileSync20 } from "fs";
+import { readFileSync as readFileSync36, writeFileSync as writeFileSync21 } from "fs";
 import { join as join45 } from "path";
 async function revertEntity(entityName, localGraph, projectRoot, filePath) {
   const driftEntity = await findDriftEntity(localGraph, entityName, filePath);
@@ -17412,12 +17919,12 @@ async function findDriftEntity(localGraph, entityName, filePath) {
 }
 async function removeAddedEntity(absPath, entity, localGraph) {
   try {
-    const content = readFileSync35(absPath, "utf-8");
+    const content = readFileSync36(absPath, "utf-8");
     const lines = content.split("\n");
     const startIdx = entity.line_start - 1;
     const endIdx = entity.line_end;
     lines.splice(startIdx, endIdx - startIdx);
-    writeFileSync20(absPath, lines.join("\n"), "utf-8");
+    writeFileSync21(absPath, lines.join("\n"), "utf-8");
     await localGraph.removeDriftEntity(entity.key);
     return {
       reverted: true,
@@ -17447,12 +17954,12 @@ async function restoreDeletedEntity(absPath, entity, localGraph) {
     };
   }
   try {
-    const content = readFileSync35(absPath, "utf-8");
+    const content = readFileSync36(absPath, "utf-8");
     const lines = content.split("\n");
     const previousLines = entity.previous_body.split("\n");
     const insertIdx = Math.min(entity.line_start - 1, lines.length);
     lines.splice(insertIdx, 0, ...previousLines);
-    writeFileSync20(absPath, lines.join("\n"), "utf-8");
+    writeFileSync21(absPath, lines.join("\n"), "utf-8");
     await localGraph.removeDriftEntity(entity.key);
     const endLine = insertIdx + previousLines.length;
     return {
@@ -17483,13 +17990,13 @@ async function restoreModifiedEntity(absPath, entity, localGraph) {
     };
   }
   try {
-    const content = readFileSync35(absPath, "utf-8");
+    const content = readFileSync36(absPath, "utf-8");
     const lines = content.split("\n");
     const previousLines = entity.previous_body.split("\n");
     const startIdx = entity.line_start - 1;
     const deleteCount = entity.line_end - entity.line_start + 1;
     lines.splice(startIdx, deleteCount, ...previousLines);
-    writeFileSync20(absPath, lines.join("\n"), "utf-8");
+    writeFileSync21(absPath, lines.join("\n"), "utf-8");
     await localGraph.removeDriftEntity(entity.key);
     const endLine = startIdx + previousLines.length;
     return {
@@ -17895,7 +18402,7 @@ __export(file_outline_exports, {
   buildFileOutline: () => buildFileOutline,
   fileOutlineTool: () => fileOutlineTool
 });
-import { existsSync as existsSync38, readFileSync as readFileSync36 } from "fs";
+import { existsSync as existsSync39, readFileSync as readFileSync37 } from "fs";
 import { relative as relative2, resolve } from "path";
 function normRisk(rl) {
   const x2 = (rl ?? "low").toLowerCase();
@@ -17954,10 +18461,10 @@ function detectExportedNames(lines, scanLimit) {
 async function buildFileOutline(params) {
   const abs = resolve(params.cwd, params.filePathArg);
   const rel = relative2(params.cwd, abs).replace(/\\/g, "/") || params.filePathArg;
-  if (!existsSync38(abs)) {
+  if (!existsSync39(abs)) {
     throw new Error(`File not found: ${abs}`);
   }
-  const raw = readFileSync36(abs);
+  const raw = readFileSync37(abs);
   const sampleEnd = Math.min(raw.length, 8192);
   for (let i = 0; i < sampleEnd; i++) {
     if (raw[i] === 0) {
@@ -18105,7 +18612,7 @@ __export(file_read_protocol_exports, {
   runFileReadForRouter: () => runFileReadForRouter,
   runFileReadTool: () => runFileReadTool
 });
-import { existsSync as existsSync39, readFileSync as readFileSync37 } from "fs";
+import { existsSync as existsSync40, readFileSync as readFileSync38 } from "fs";
 import { relative as relative3, resolve as resolve2 } from "path";
 function isGeneratedPath(rel) {
   return /(?:^|\/)node_modules\/|(?:^|\/)dist\/|\/\.next\/|\.generated\./.test(
@@ -18166,9 +18673,8 @@ function logFileRead(cwd, file, mode, totalLines, returnedLines, entity, tokenEs
 async function runFileReadForRouter(args, ctx) {
   const filePathArg = args.file_path;
   if (!filePathArg) throw new Error("file_read requires file_path");
-  const forceFull = args.force_full === true;
-  const purpose = args.purpose?.trim() || "explore";
-  const isFullRead = forceFull || purpose === "edit";
+  const rawPurpose = args.purpose?.trim() || "explore";
+  const purpose = rawPurpose === "edit" ? "explore" : rawPurpose;
   const entityName = args.entity?.trim();
   let entityWindowApplied = false;
   let entityMatchInfo;
@@ -18176,14 +18682,14 @@ async function runFileReadForRouter(args, ctx) {
   let limit = args.limit != null ? Math.min(MAX_READ_LINES, Math.max(1, Number(args.limit))) : void 0;
   const defaultBudget = purpose === "reference" ? 1e3 : 2e3;
   const tokenBudget = typeof args.token_budget === "number" && args.token_budget >= 100 ? args.token_budget : defaultBudget;
-  const budgetLines = isFullRead ? MAX_READ_LINES : Math.floor(tokenBudget * CHARS_PER_TOKEN4 / AVG_CHARS_PER_LINE);
+  const budgetLines = Math.floor(tokenBudget * CHARS_PER_TOKEN4 / AVG_CHARS_PER_LINE);
   const abs = resolve2(ctx.cwd, filePathArg);
   const rel = relative3(ctx.cwd, abs).replace(/\\/g, "/") || filePathArg;
   const isOutOfProject = rel.startsWith("..");
-  if (!existsSync39(abs)) {
+  if (!existsSync40(abs)) {
     return { content: { error: `File not found: ${abs}` } };
   }
-  const raw = readFileSync37(abs);
+  const raw = readFileSync38(abs);
   const sampleEnd = Math.min(raw.length, 8192);
   for (let i = 0; i < sampleEnd; i++) {
     if (raw[i] === 0) {
@@ -18199,7 +18705,7 @@ async function runFileReadForRouter(args, ctx) {
   const lines = text2.split("\n");
   const totalLines = lines.length;
   const effectiveGate = Math.max(LINE_GATE, Math.min(HARD_GATE_CEILING, budgetLines));
-  if (totalLines > effectiveGate && totalLines > LINE_GATE && offset === void 0 && !entityName && !isFullRead) {
+  if (totalLines > effectiveGate && totalLines > LINE_GATE && offset === void 0 && !entityName && !entityName) {
     const outline = await buildFileOutline({
       cwd: ctx.cwd,
       filePathArg,
@@ -18210,7 +18716,7 @@ async function runFileReadForRouter(args, ctx) {
       content: {
         ...outline,
         gated: true,
-        _gate_reason: `File has ${totalLines} lines (> ${effectiveGate}). Structure shown \u2014 call file_read again with entity or offset/limit, or force_full:true. NOTE: If you plan to Edit this file, you MUST call built-in Read (not file_read) on the target lines first.`
+        _gate_reason: `File has ${totalLines} lines (> ${effectiveGate}). Structure shown \u2014 call file_read again with entity or offset/limit for targeted access.`
       },
       _layer6_meta: {
         format: "outline",
@@ -18348,7 +18854,7 @@ async function runFileReadForRouter(args, ctx) {
     limit = LOG_TAIL_LINES;
   }
   const effOffset = offset ?? 1;
-  const effLimit = limit ?? (isFullRead ? totalLines : Math.min(budgetLines, totalLines));
+  const effLimit = limit ?? Math.min(budgetLines, totalLines);
   const sliced = lines.slice(effOffset - 1, effOffset - 1 + effLimit);
   const numbered = sliced.map((line, i) => `${effOffset + i}	${line}`).join("\n");
   let body = effOffset > 1 || sliced.length < totalLines || entityWindowApplied ? `${numbered}
@@ -18378,10 +18884,7 @@ ${body}`;
     total_lines: totalLines,
     total_chars: text2.length
   };
-  if (isFullRead && sliced.length === totalLines) {
-    meta.optimization = `file_read full (purpose:${purpose})`;
-    meta._edit_note = "file_read does NOT satisfy Edit's Read prerequisite. You must still call built-in Read before using Edit on this file.";
-  } else if (effOffset > 1 || sliced.length < totalLines || entityWindowApplied) {
+  if (effOffset > 1 || sliced.length < totalLines || entityWindowApplied) {
     meta.optimization = `file_read window lines ${effOffset}-${effOffset + sliced.length - 1}`;
   }
   if (entityWindowApplied) {
@@ -18393,6 +18896,10 @@ ${body}`;
   if (isProbableLogPath(rel) && offset !== void 0 && totalLines > LINE_GATE) {
     meta.optimization = `${meta.optimization ?? "file_read"} \xB7 log_tail`;
   }
+  if (isOutOfProject) {
+    meta.out_of_project = true;
+    meta._hint = "File is outside the indexed project. Graph features (references, callers) unavailable.";
+  }
   const returnedLineCount = sliced.length;
   const readMode = entityWindowApplied ? "entity" : isProbableLogPath(rel) && offset !== void 0 && totalLines > LINE_GATE ? "log_tail" : effOffset > 1 || returnedLineCount < totalLines ? "slice" : "full";
   logFileRead(
@@ -19946,11 +20453,11 @@ var init_query_router = __esm({
             const entity = await this.resolveEntityWithOverlay(key);
             if (entity && entity.file_path && entity.start_line > 0) {
               try {
-                const { readFileSync: readFileSync57 } = await import("fs");
+                const { readFileSync: readFileSync58 } = await import("fs");
                 const { resolve: resolve3 } = await import("path");
                 const cwd = this.projectRoot ?? process.cwd();
                 const abs = resolve3(cwd, entity.file_path);
-                const lines = readFileSync57(abs, "utf-8").split("\n");
+                const lines = readFileSync58(abs, "utf-8").split("\n");
                 const start = entity.start_line - 1;
                 const end = entity.end_line ?? lines.length;
                 entity.body = lines.slice(start, end).join("\n");
@@ -19962,15 +20469,29 @@ var init_query_router = __esm({
           case "get_references": {
             const key = await this.resolveKeyArg(args.key);
             const direction = args.direction ?? "callers";
-            return direction === "callees" ? await this.localGraph.getCalleesOf(key) : await this.localGraph.getCallersOf(key);
+            const limit = typeof args.limit === "number" && args.limit > 0 ? args.limit : 25;
+            const raw = direction === "callees" ? await this.localGraph.getCalleesOf(key) : await this.localGraph.getCallersOf(key);
+            const totalCount = raw.length;
+            const capped = raw.slice(0, limit);
+            const results = capped.map(({ body: _body, ...rest }) => rest);
+            return {
+              references: results,
+              direction,
+              total: totalCount,
+              returned: results.length,
+              truncated: totalCount > limit,
+              ...totalCount > limit ? { _hint: `Showing ${limit} of ${totalCount}. Pass limit: ${totalCount} to see all.` } : {}
+            };
           }
           case "get_callers": {
             const key = await this.resolveKeyArg(args.key);
-            return await this.localGraph.getCallersOf(key);
+            const rawCallers = await this.localGraph.getCallersOf(key);
+            return rawCallers.slice(0, 25).map(({ body: _body, ...rest }) => rest);
           }
           case "get_callees": {
             const key = await this.resolveKeyArg(args.key);
-            return await this.localGraph.getCalleesOf(key);
+            const rawCallees = await this.localGraph.getCalleesOf(key);
+            return rawCallees.slice(0, 25).map(({ body: _body, ...rest }) => rest);
           }
           case "get_imports": {
             const filePath = args.file_path;
@@ -20003,6 +20524,14 @@ var init_query_router = __esm({
                 { entityKey: entityKey2, exceptions }
               );
             }
+            if (filePath && (filePath.endsWith("/") || !/\.\w+$/.test(filePath))) {
+              const dirPrefix = filePath.endsWith("/") ? filePath : `${filePath}/`;
+              const allRules = await this.localGraph.getRules();
+              return allRules.filter((rule) => {
+                if (!rule.file_glob) return true;
+                return rule.file_glob.includes(dirPrefix) || rule.file_glob.startsWith(dirPrefix) || dirPrefix.startsWith(rule.file_glob.replace(/\*.*$/, ""));
+              });
+            }
             return await this.localGraph.getRules(filePath);
           }
           case "check_rules": {
@@ -20038,7 +20567,37 @@ var init_query_router = __esm({
             if (!raw)
               throw new Error("get_business_context requires key or entity_key");
             const key = await this.resolveKeyArg(raw);
-            return await this.localGraph.getBusinessContext(key);
+            const stored = await this.localGraph.getBusinessContext(key);
+            if (stored) return stored;
+            const entity = await this.localGraph.getEntity(key);
+            if (!entity) return { error: `Entity not found: ${raw}` };
+            const callers = await this.localGraph.getCallersOf(key);
+            const callees = await this.localGraph.getCalleesOf(key);
+            const pathParts = entity.file_path.split("/");
+            const dirHint = pathParts.slice(-3, -1).join("/");
+            const featureArea = dirHint || "root";
+            let purpose;
+            if (callers.length === 0 && callees.length > 0)
+              purpose = "Entry point / top-level orchestrator";
+            else if (callers.length > 5)
+              purpose = `Widely-used utility (${callers.length} callers)`;
+            else if (callees.length === 0 && callers.length > 0)
+              purpose = "Leaf function (no outgoing calls)";
+            else if (callers.length > 0 && callees.length > 0)
+              purpose = `Internal function (${callers.length} callers, ${callees.length} callees)`;
+            else
+              purpose = "Standalone / unused function";
+            return {
+              purpose,
+              taxonomy: `${entity.kind}/${featureArea}`,
+              feature_area: featureArea,
+              confidence: 0.3,
+              entity,
+              _source: "inferred",
+              _hint: "This context was inferred from graph structure. Use record_fact to store explicit business context.",
+              callers_count: callers.length,
+              callees_count: callees.length
+            };
           }
           case "get_conventions": {
             return await this.localGraph.getConventions();
@@ -20167,6 +20726,18 @@ var init_query_router = __esm({
             throw new Error(`Unknown local tool: ${toolName}`);
         }
       }
+      /**
+       * Get entity keys for a file path (from file_index).
+       * Used by fact injection to call recallForFile with entity-scoped facts.
+       */
+      async getEntityKeysForFile(filePath) {
+        try {
+          const results = await this.localGraph.getEntitiesByFile(filePath);
+          return results.map((e) => e.key);
+        } catch {
+          return [];
+        }
+      }
       /**
        * Resolve a key argument: if it looks like a hex hash (entity key), use as-is.
        * Otherwise, search by name and return the best match's key.
@@ -21476,7 +22047,7 @@ __export(causal_bridge_exports, {
   assembleCausalChain: () => assembleCausalChain,
   computeDurability: () => computeDurability
 });
-import { existsSync as existsSync40, readFileSync as readFileSync38 } from "fs";
+import { existsSync as existsSync41, readFileSync as readFileSync39 } from "fs";
 import { join as join46 } from "path";
 function computeAggregateDurability(interactions) {
   if (interactions.length === 0) return 1;
@@ -21635,8 +22206,8 @@ var init_causal_bridge = __esm({
       }
       loadEntityLedgerEntries(entityKey2) {
         const ledgerPath = join46(this.unerrDir, "ledger", "shadow.jsonl");
-        if (!existsSync40(ledgerPath)) return [];
-        const content = readFileSync38(ledgerPath, "utf-8");
+        if (!existsSync41(ledgerPath)) return [];
+        const content = readFileSync39(ledgerPath, "utf-8");
         const lines = content.split("\n").filter((l) => l.trim().length > 0);
         const entries = [];
         for (const line of lines) {
@@ -22122,7 +22693,7 @@ var context_ledger_exports = {};
 __export(context_ledger_exports, {
   createContextLedger: () => createContextLedger
 });
-import { existsSync as existsSync41, mkdirSync as mkdirSync23, readFileSync as readFileSync39, writeFileSync as writeFileSync21 } from "fs";
+import { existsSync as existsSync42, mkdirSync as mkdirSync23, readFileSync as readFileSync40, writeFileSync as writeFileSync22 } from "fs";
 import { join as join47 } from "path";
 function createContextLedger(unerrDir) {
   const stateDir = join47(unerrDir, "state");
@@ -22130,7 +22701,7 @@ function createContextLedger(unerrDir) {
   let records = [];
   let index = /* @__PURE__ */ new Map();
   function ensureDir() {
-    if (!existsSync41(stateDir)) {
+    if (!existsSync42(stateDir)) {
       mkdirSync23(stateDir, { recursive: true });
     }
   }
@@ -22139,13 +22710,13 @@ function createContextLedger(unerrDir) {
   }
   function load() {
     ensureDir();
-    if (!existsSync41(filePath)) {
+    if (!existsSync42(filePath)) {
       records = [];
       index = /* @__PURE__ */ new Map();
       return /* @__PURE__ */ new Map();
     }
     try {
-      const raw = readFileSync39(filePath, "utf-8");
+      const raw = readFileSync40(filePath, "utf-8");
       const parsed = JSON.parse(raw);
       records = Array.isArray(parsed) ? parsed : [];
     } catch {
@@ -22181,7 +22752,7 @@ function createContextLedger(unerrDir) {
     records = newRecords;
     index = delivered;
     try {
-      writeFileSync21(filePath, JSON.stringify(records, null, 2), "utf-8");
+      writeFileSync22(filePath, JSON.stringify(records, null, 2), "utf-8");
     } catch {
     }
   }
@@ -23052,11 +23623,11 @@ __export(intent_correlator_exports, {
   IntentCorrelator: () => IntentCorrelator
 });
 import {
-  existsSync as existsSync42,
+  existsSync as existsSync43,
   mkdirSync as mkdirSync24,
-  readFileSync as readFileSync40,
+  readFileSync as readFileSync41,
   renameSync,
-  writeFileSync as writeFileSync22
+  writeFileSync as writeFileSync23
 } from "fs";
 import { join as join48 } from "path";
 function extractFiles4(args) {
@@ -23108,7 +23679,7 @@ var init_intent_correlator = __esm({
       constructor(unerrDir) {
         this.ledgerDir = join48(unerrDir, "ledger");
         this.pendingPath = join48(this.ledgerDir, "pending_correlations.json");
-        if (!existsSync42(this.ledgerDir)) {
+        if (!existsSync43(this.ledgerDir)) {
           mkdirSync24(this.ledgerDir, { recursive: true });
         }
         this.load();
@@ -23200,9 +23771,9 @@ var init_intent_correlator = __esm({
       }
       // ── Persistence ─────────────────────────────────────────────────
       load() {
-        if (!existsSync42(this.pendingPath)) return;
+        if (!existsSync43(this.pendingPath)) return;
         try {
-          const raw = readFileSync40(this.pendingPath, "utf-8");
+          const raw = readFileSync41(this.pendingPath, "utf-8");
           const parsed = JSON.parse(raw);
           if (Array.isArray(parsed)) {
             this.pending = parsed;
@@ -23214,7 +23785,7 @@ var init_intent_correlator = __esm({
       save() {
         try {
           const tmpPath = `${this.pendingPath}.tmp`;
-          writeFileSync22(tmpPath, JSON.stringify(this.pending, null, 2), "utf-8");
+          writeFileSync23(tmpPath, JSON.stringify(this.pending, null, 2), "utf-8");
           renameSync(tmpPath, this.pendingPath);
         } catch (err) {
           process.stderr.write(
@@ -23234,12 +23805,12 @@ __export(working_snapshots_exports, {
 });
 import { randomBytes as randomBytes3 } from "crypto";
 import {
-  existsSync as existsSync43,
+  existsSync as existsSync44,
   mkdirSync as mkdirSync25,
-  readFileSync as readFileSync41,
+  readFileSync as readFileSync42,
   readdirSync as readdirSync10,
   rmSync as rmSync2,
-  writeFileSync as writeFileSync23
+  writeFileSync as writeFileSync24
 } from "fs";
 import { join as join49 } from "path";
 var _log2, MAX_SNAPSHOTS, AUTO_SNAPSHOT_COOLDOWN_MS, WorkingSnapshotStore;
@@ -23260,7 +23831,7 @@ var init_working_snapshots = __esm({
       constructor(unerrDir) {
         this.unerrDir = unerrDir;
         this.snapshotDir = join49(unerrDir, "snapshots");
-        if (!existsSync43(this.snapshotDir)) {
+        if (!existsSync44(this.snapshotDir)) {
           mkdirSync25(this.snapshotDir, { recursive: true });
         }
       }
@@ -23279,7 +23850,7 @@ var init_working_snapshots = __esm({
           sessionId: opts.sessionId,
           processed: false
         };
-        writeFileSync23(
+        writeFileSync24(
           join49(this.snapshotDir, `${id}.json`),
           JSON.stringify(snapshot, null, 2),
           "utf-8"
@@ -23295,9 +23866,9 @@ var init_working_snapshots = __esm({
        */
       get(snapshotId) {
         const filePath = join49(this.snapshotDir, `${snapshotId}.json`);
-        if (!existsSync43(filePath)) return null;
+        if (!existsSync44(filePath)) return null;
         try {
-          return JSON.parse(readFileSync41(filePath, "utf-8"));
+          return JSON.parse(readFileSync42(filePath, "utf-8"));
         } catch {
           return null;
         }
@@ -23306,14 +23877,14 @@ var init_working_snapshots = __esm({
        * List all snapshots, most recent first.
        */
       list() {
-        if (!existsSync43(this.snapshotDir)) return [];
+        if (!existsSync44(this.snapshotDir)) return [];
         const files = readdirSync10(this.snapshotDir).filter(
           (f) => f.endsWith(".json")
         );
         const snapshots = [];
         for (const file of files) {
           try {
-            const raw = readFileSync41(join49(this.snapshotDir, file), "utf-8");
+            const raw = readFileSync42(join49(this.snapshotDir, file), "utf-8");
             snapshots.push(JSON.parse(raw));
           } catch {
           }
@@ -23353,7 +23924,7 @@ var init_working_snapshots = __esm({
         const snapshot = this.get(snapshotId);
         if (!snapshot) return;
         snapshot.processed = true;
-        writeFileSync23(
+        writeFileSync24(
           join49(this.snapshotDir, `${snapshotId}.json`),
           JSON.stringify(snapshot, null, 2),
           "utf-8"
@@ -23370,7 +23941,7 @@ var init_working_snapshots = __esm({
        */
       delete(snapshotId) {
         const filePath = join49(this.snapshotDir, `${snapshotId}.json`);
-        if (!existsSync43(filePath)) return false;
+        if (!existsSync44(filePath)) return false;
         rmSync2(filePath);
         return true;
       }
@@ -23379,9 +23950,9 @@ var init_working_snapshots = __esm({
        */
       getTimelineBranch() {
         const contextPath = join49(this.unerrDir, "branch_context.json");
-        if (!existsSync43(contextPath)) return 0;
+        if (!existsSync44(contextPath)) return 0;
         try {
-          const ctx = JSON.parse(readFileSync41(contextPath, "utf-8"));
+          const ctx = JSON.parse(readFileSync42(contextPath, "utf-8"));
           return ctx.timelineBranch ?? 0;
         } catch {
           return 0;
@@ -23393,16 +23964,16 @@ var init_working_snapshots = __esm({
       incrementTimelineBranch() {
         const contextPath = join49(this.unerrDir, "branch_context.json");
         let ctx = {};
-        if (existsSync43(contextPath)) {
+        if (existsSync44(contextPath)) {
           try {
-            ctx = JSON.parse(readFileSync41(contextPath, "utf-8"));
+            ctx = JSON.parse(readFileSync42(contextPath, "utf-8"));
           } catch {
             ctx = {};
           }
         }
         const current = ctx.timelineBranch ?? 0;
         ctx.timelineBranch = current + 1;
-        writeFileSync23(contextPath, JSON.stringify(ctx, null, 2), "utf-8");
+        writeFileSync24(contextPath, JSON.stringify(ctx, null, 2), "utf-8");
         return current + 1;
       }
       /**
@@ -23568,7 +24139,7 @@ var quality_signals_exports = {};
 __export(quality_signals_exports, {
   QualitySignalTracker: () => QualitySignalTracker
 });
-import { existsSync as existsSync44, readFileSync as readFileSync42, writeFileSync as writeFileSync24 } from "fs";
+import { existsSync as existsSync45, readFileSync as readFileSync43, writeFileSync as writeFileSync25 } from "fs";
 import { join as join50 } from "path";
 function computeDurabilityFromAge(survivalMs) {
   if (survivalMs < FRAGILE_THRESHOLD_MS) {
@@ -23689,11 +24260,11 @@ var init_quality_signals = __esm({
       save() {
         try {
           const dir = join50(this.signalsPath, "..");
-          if (!existsSync44(dir)) {
+          if (!existsSync45(dir)) {
             const { mkdirSync: mkdirSync39 } = __require("fs");
             mkdirSync39(dir, { recursive: true });
           }
-          writeFileSync24(
+          writeFileSync25(
             this.signalsPath,
             JSON.stringify(this.signals, null, 2),
             "utf-8"
@@ -23735,7 +24306,7 @@ var init_quality_signals = __esm({
        * Load signals from disk.
        */
       load() {
-        if (!existsSync44(this.signalsPath)) {
+        if (!existsSync45(this.signalsPath)) {
           return {
             durabilityScores: {},
             corrections: [],
@@ -23744,7 +24315,7 @@ var init_quality_signals = __esm({
         }
         try {
           return JSON.parse(
-            readFileSync42(this.signalsPath, "utf-8")
+            readFileSync43(this.signalsPath, "utf-8")
           );
         } catch {
           return {
@@ -24761,7 +25332,7 @@ var incomplete_work_exports = {};
 __export(incomplete_work_exports, {
   IncompleteWorkDetector: () => IncompleteWorkDetector
 });
-import { existsSync as existsSync45, mkdirSync as mkdirSync26, readFileSync as readFileSync43, writeFileSync as writeFileSync25 } from "fs";
+import { existsSync as existsSync46, mkdirSync as mkdirSync26, readFileSync as readFileSync44, writeFileSync as writeFileSync26 } from "fs";
 import { join as join51 } from "path";
 function severityRank(severity) {
   switch (severity) {
@@ -24956,9 +25527,9 @@ var init_incomplete_work = __esm({
         if (!this.unerrDir) return false;
         try {
           const stateDir = join51(this.unerrDir, "state");
-          if (!existsSync45(stateDir)) mkdirSync26(stateDir, { recursive: true });
+          if (!existsSync46(stateDir)) mkdirSync26(stateDir, { recursive: true });
           const filePath = join51(stateDir, PERSISTENCE_FILE);
-          writeFileSync25(
+          writeFileSync26(
             filePath,
             JSON.stringify({
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -24978,8 +25549,8 @@ var init_incomplete_work = __esm({
       static readPersistedItems(unerrDir) {
         try {
           const filePath = join51(unerrDir, "state", PERSISTENCE_FILE);
-          if (!existsSync45(filePath)) return [];
-          const data = JSON.parse(readFileSync43(filePath, "utf-8"));
+          if (!existsSync46(filePath)) return [];
+          const data = JSON.parse(readFileSync44(filePath, "utf-8"));
           return data.items ?? [];
         } catch {
           return [];
@@ -26450,7 +27021,7 @@ var transport_mux_exports = {};
 __export(transport_mux_exports, {
   TransportMux: () => TransportMux
 });
-import { existsSync as existsSync46, unlinkSync as unlinkSync7 } from "fs";
+import { existsSync as existsSync47, unlinkSync as unlinkSync7 } from "fs";
 import { createServer as createServer2 } from "net";
 var _log4, TransportMux;
 var init_transport_mux = __esm({
@@ -26490,7 +27061,7 @@ var init_transport_mux = __esm({
        * Start listening for secondary clients on the Unix domain socket.
        */
       start() {
-        if (existsSync46(this.sockPath)) {
+        if (existsSync47(this.sockPath)) {
           try {
             unlinkSync7(this.sockPath);
           } catch {
@@ -26523,7 +27094,7 @@ var init_transport_mux = __esm({
           this.server.close();
           this.server = null;
         }
-        if (existsSync46(this.sockPath)) {
+        if (existsSync47(this.sockPath)) {
           try {
             unlinkSync7(this.sockPath);
           } catch {
@@ -26671,7 +27242,7 @@ __export(git_trailers_exports, {
   parseTrailersFromMessage: () => parseTrailersFromMessage,
   uninstallPrepareCommitMsgHook: () => uninstallPrepareCommitMsgHook
 });
-import { existsSync as existsSync47, readFileSync as readFileSync44, writeFileSync as writeFileSync26 } from "fs";
+import { existsSync as existsSync48, readFileSync as readFileSync45, writeFileSync as writeFileSync27 } from "fs";
 import { join as join52 } from "path";
 function getCommitTrailers(ledger, timelineBranch, branch) {
   const recent = ledger.getRecentEntries(1);
@@ -26693,14 +27264,14 @@ function formatTrailers(trailers) {
 }
 function installPrepareCommitMsgHook(projectRoot) {
   const hooksDir = join52(projectRoot, ".git", "hooks");
-  if (!existsSync47(hooksDir)) {
+  if (!existsSync48(hooksDir)) {
     return false;
   }
   const hookPath = join52(hooksDir, "prepare-commit-msg");
   const marker = "# unerr-trailer-injection";
-  if (existsSync47(hookPath)) {
+  if (existsSync48(hookPath)) {
     try {
-      const existing = readFileSync44(hookPath, "utf-8");
+      const existing = readFileSync45(hookPath, "utf-8");
       if (existing.includes(marker)) {
         return true;
       }
@@ -26708,7 +27279,7 @@ function installPrepareCommitMsgHook(projectRoot) {
 
 ${marker}
 ${generateHookScript()}`;
-      writeFileSync26(hookPath, existing + appendSection, { mode: 493 });
+      writeFileSync27(hookPath, existing + appendSection, { mode: 493 });
       _log5.info(
         "Appended trailer injection to existing prepare-commit-msg hook"
       );
@@ -26721,7 +27292,7 @@ ${generateHookScript()}`;
 ${marker}
 ${generateHookScript()}`;
   try {
-    writeFileSync26(hookPath, hookContent, { mode: 493 });
+    writeFileSync27(hookPath, hookContent, { mode: 493 });
     _log5.info("Installed prepare-commit-msg hook for trailer injection");
     return true;
   } catch {
@@ -26730,9 +27301,9 @@ ${generateHookScript()}`;
 }
 function uninstallPrepareCommitMsgHook(projectRoot) {
   const hookPath = join52(projectRoot, ".git", "hooks", "prepare-commit-msg");
-  if (!existsSync47(hookPath)) return true;
+  if (!existsSync48(hookPath)) return true;
   try {
-    const content = readFileSync44(hookPath, "utf-8");
+    const content = readFileSync45(hookPath, "utf-8");
     const marker = "# unerr-trailer-injection";
     if (!content.includes(marker)) return true;
     const lines = content.split("\n");
@@ -26745,7 +27316,7 @@ function uninstallPrepareCommitMsgHook(projectRoot) {
     } else {
       const markerIdx = content.indexOf(marker);
       if (markerIdx > 0) {
-        writeFileSync26(hookPath, `${content.slice(0, markerIdx).trimEnd()}
+        writeFileSync27(hookPath, `${content.slice(0, markerIdx).trimEnd()}
 `, {
           mode: 493
         });
@@ -26897,13 +27468,13 @@ var init_http_transport = __esm({
 
 // src/tracking/branch-snapshot.ts
 import {
-  existsSync as existsSync48,
+  existsSync as existsSync49,
   mkdirSync as mkdirSync28,
-  readFileSync as readFileSync45,
+  readFileSync as readFileSync46,
   readdirSync as readdirSync11,
   rmSync as rmSync3,
   statSync as statSync7,
-  writeFileSync as writeFileSync27
+  writeFileSync as writeFileSync28
 } from "fs";
 import { join as join53 } from "path";
 function sanitizeBranchName(branch) {
@@ -26938,7 +27509,7 @@ var init_branch_snapshot = __esm({
         }
         const dirName = sanitizeBranchName(branch);
         const snapshotDir = join53(this.branchDir, dirName);
-        if (!existsSync48(snapshotDir)) {
+        if (!existsSync49(snapshotDir)) {
           mkdirSync28(snapshotDir, { recursive: true });
         }
         const snapshot = {
@@ -26948,12 +27519,12 @@ var init_branch_snapshot = __esm({
           fileHashes: fileHashState,
           savedAt: (/* @__PURE__ */ new Date()).toISOString()
         };
-        writeFileSync27(
+        writeFileSync28(
           join53(snapshotDir, OVERLAY_FILE),
           JSON.stringify(snapshot, null, 2),
           "utf-8"
         );
-        writeFileSync27(
+        writeFileSync28(
           join53(snapshotDir, HASHES_FILE),
           JSON.stringify(fileHashState, null, 2),
           "utf-8"
@@ -26972,12 +27543,12 @@ var init_branch_snapshot = __esm({
         const dirName = sanitizeBranchName(branch);
         const snapshotDir = join53(this.branchDir, dirName);
         const overlayPath = join53(snapshotDir, OVERLAY_FILE);
-        if (!existsSync48(overlayPath)) {
+        if (!existsSync49(overlayPath)) {
           log16.info(`No snapshot for branch ${branch} \u2014 first visit`);
           return null;
         }
         try {
-          const raw = readFileSync45(overlayPath, "utf-8");
+          const raw = readFileSync46(overlayPath, "utf-8");
           const snapshot = JSON.parse(raw);
           for (const entity of snapshot.entities) {
             await localGraph.upsertDriftEntity(entity);
@@ -26988,7 +27559,7 @@ var init_branch_snapshot = __esm({
             }
           }
           const now = /* @__PURE__ */ new Date();
-          writeFileSync27(
+          writeFileSync28(
             join53(snapshotDir, ".last_access"),
             now.toISOString(),
             "utf-8"
@@ -27009,7 +27580,7 @@ var init_branch_snapshot = __esm({
        */
       hasSnapshot(branch) {
         const dirName = sanitizeBranchName(branch);
-        return existsSync48(join53(this.branchDir, dirName, OVERLAY_FILE));
+        return existsSync49(join53(this.branchDir, dirName, OVERLAY_FILE));
       }
       /**
        * Get the file hash state from a branch snapshot.
@@ -27017,9 +27588,9 @@ var init_branch_snapshot = __esm({
       getSnapshotFileHashes(branch) {
         const dirName = sanitizeBranchName(branch);
         const hashesPath = join53(this.branchDir, dirName, HASHES_FILE);
-        if (!existsSync48(hashesPath)) return null;
+        if (!existsSync49(hashesPath)) return null;
         try {
-          const raw = readFileSync45(hashesPath, "utf-8");
+          const raw = readFileSync46(hashesPath, "utf-8");
           return JSON.parse(raw);
         } catch {
           return null;
@@ -27031,7 +27602,7 @@ var init_branch_snapshot = __esm({
       deleteSnapshot(branch) {
         const dirName = sanitizeBranchName(branch);
         const snapshotDir = join53(this.branchDir, dirName);
-        if (!existsSync48(snapshotDir)) return false;
+        if (!existsSync49(snapshotDir)) return false;
         rmSync3(snapshotDir, { recursive: true, force: true });
         log16.info(`Deleted branch snapshot: ${branch}`);
         return true;
@@ -27040,7 +27611,7 @@ var init_branch_snapshot = __esm({
        * Garbage-collect snapshots for branches that no longer exist in git.
        */
       async garbageCollect() {
-        if (!existsSync48(this.branchDir)) return 0;
+        if (!existsSync49(this.branchDir)) return 0;
         const gitBranches = new Set(await listBranches(this.projectRoot));
         if (gitBranches.size === 0) return 0;
         const snapshots = this.listSnapshots();
@@ -27059,20 +27630,20 @@ var init_branch_snapshot = __esm({
        * List all branch snapshots, sorted by most recently accessed first.
        */
       listSnapshots() {
-        if (!existsSync48(this.branchDir)) return [];
+        if (!existsSync49(this.branchDir)) return [];
         try {
           const entries = readdirSync11(this.branchDir, { withFileTypes: true });
           const snapshots = [];
           for (const entry of entries) {
             if (!entry.isDirectory()) continue;
             const overlayPath = join53(this.branchDir, entry.name, OVERLAY_FILE);
-            if (!existsSync48(overlayPath)) continue;
+            if (!existsSync49(overlayPath)) continue;
             try {
-              const raw = readFileSync45(overlayPath, "utf-8");
+              const raw = readFileSync46(overlayPath, "utf-8");
               const snapshot = JSON.parse(raw);
               const accessPath = join53(this.branchDir, entry.name, ".last_access");
               let accessedAt;
-              if (existsSync48(accessPath)) {
+              if (existsSync49(accessPath)) {
                 accessedAt = statSync7(accessPath).mtime;
               } else {
                 accessedAt = statSync7(overlayPath).mtime;
@@ -27116,11 +27687,11 @@ __export(file_hash_state_exports, {
 });
 import { createHash as createHash3 } from "crypto";
 import {
-  existsSync as existsSync49,
+  existsSync as existsSync50,
   mkdirSync as mkdirSync29,
-  readFileSync as readFileSync46,
+  readFileSync as readFileSync47,
   renameSync as renameSync2,
-  writeFileSync as writeFileSync28
+  writeFileSync as writeFileSync29
 } from "fs";
 import { join as join54 } from "path";
 function contentSha256(content) {
@@ -27182,11 +27753,11 @@ var init_file_hash_state = __esm({
        * Persist state to disk atomically (write .tmp → rename).
        */
       save() {
-        if (!existsSync49(this.stateDir)) {
+        if (!existsSync50(this.stateDir)) {
           mkdirSync29(this.stateDir, { recursive: true });
         }
         const tmpPath = `${this.statePath}.tmp`;
-        writeFileSync28(tmpPath, JSON.stringify(this.state, null, 2), "utf-8");
+        writeFileSync29(tmpPath, JSON.stringify(this.state, null, 2), "utf-8");
         renameSync2(tmpPath, this.statePath);
       }
       /**
@@ -27209,11 +27780,11 @@ var init_file_hash_state = __esm({
         this.state = { files: { ...snapshot.files } };
       }
       load() {
-        if (!existsSync49(this.statePath)) {
+        if (!existsSync50(this.statePath)) {
           return { files: {} };
         }
         try {
-          const raw = readFileSync46(this.statePath, "utf-8");
+          const raw = readFileSync47(this.statePath, "utf-8");
           return JSON.parse(raw);
         } catch {
           return { files: {} };
@@ -27225,13 +27796,13 @@ var init_file_hash_state = __esm({
 
 // src/tracking/stash-manager.ts
 import {
-  existsSync as existsSync50,
+  existsSync as existsSync51,
   mkdirSync as mkdirSync30,
-  readFileSync as readFileSync47,
+  readFileSync as readFileSync48,
   readdirSync as readdirSync12,
   rmSync as rmSync4,
   statSync as statSync8,
-  writeFileSync as writeFileSync29
+  writeFileSync as writeFileSync30
 } from "fs";
 import { join as join55 } from "path";
 var MAX_STASH_SNAPSHOTS, OVERLAY_FILE2, HASHES_FILE2, _log6, StashManager;
@@ -27298,7 +27869,7 @@ var init_stash_manager = __esm({
         }
         const snapshotId = stashRef.slice(0, 12);
         const snapshotDir = join55(this.stashDir, snapshotId);
-        if (!existsSync50(snapshotDir)) {
+        if (!existsSync51(snapshotDir)) {
           mkdirSync30(snapshotDir, { recursive: true });
         }
         const snapshot = {
@@ -27308,12 +27879,12 @@ var init_stash_manager = __esm({
           fileHashes: fileHashState,
           savedAt: (/* @__PURE__ */ new Date()).toISOString()
         };
-        writeFileSync29(
+        writeFileSync30(
           join55(snapshotDir, OVERLAY_FILE2),
           JSON.stringify(snapshot, null, 2),
           "utf-8"
         );
-        writeFileSync29(
+        writeFileSync30(
           join55(snapshotDir, HASHES_FILE2),
           JSON.stringify(fileHashState, null, 2),
           "utf-8"
@@ -27337,12 +27908,12 @@ var init_stash_manager = __esm({
         const latest = snapshots[0];
         const snapshotDir = join55(this.stashDir, latest.id);
         const overlayPath = join55(snapshotDir, OVERLAY_FILE2);
-        if (!existsSync50(overlayPath)) {
+        if (!existsSync51(overlayPath)) {
           _log6.warn(`Snapshot ${latest.id} missing overlay file`);
           return 0;
         }
         try {
-          const raw = readFileSync47(overlayPath, "utf-8");
+          const raw = readFileSync48(overlayPath, "utf-8");
           const snapshot = JSON.parse(raw);
           for (const entity of snapshot.entities) {
             await localGraph.upsertDriftEntity(entity);
@@ -27373,9 +27944,9 @@ var init_stash_manager = __esm({
         if (snapshots.length === 0) return null;
         const latest = snapshots[0];
         const hashesPath = join55(this.stashDir, latest.id, HASHES_FILE2);
-        if (!existsSync50(hashesPath)) return null;
+        if (!existsSync51(hashesPath)) return null;
         try {
-          const raw = readFileSync47(hashesPath, "utf-8");
+          const raw = readFileSync48(hashesPath, "utf-8");
           return JSON.parse(raw);
         } catch {
           return null;
@@ -27387,7 +27958,7 @@ var init_stash_manager = __esm({
       dropSnapshot(stashRef) {
         const snapshotId = stashRef.slice(0, 12);
         const snapshotDir = join55(this.stashDir, snapshotId);
-        if (!existsSync50(snapshotDir)) return false;
+        if (!existsSync51(snapshotDir)) return false;
         rmSync4(snapshotDir, { recursive: true, force: true });
         _log6.info(`Dropped stash snapshot: ${snapshotId}`);
         return true;
@@ -27396,14 +27967,14 @@ var init_stash_manager = __esm({
        * List all stash snapshots, sorted by most recent first.
        */
       listSnapshots() {
-        if (!existsSync50(this.stashDir)) return [];
+        if (!existsSync51(this.stashDir)) return [];
         try {
           const entries = readdirSync12(this.stashDir, { withFileTypes: true });
           const snapshots = [];
           for (const entry of entries) {
             if (!entry.isDirectory()) continue;
             const overlayPath = join55(this.stashDir, entry.name, OVERLAY_FILE2);
-            if (!existsSync50(overlayPath)) continue;
+            if (!existsSync51(overlayPath)) continue;
             try {
               const stat2 = statSync8(overlayPath);
               snapshots.push({ id: entry.name, savedAt: stat2.mtime });
@@ -27421,9 +27992,9 @@ var init_stash_manager = __esm({
        */
       readStashRef() {
         const stashPath = join55(this.gitDir, "refs", "stash");
-        if (!existsSync50(stashPath)) return null;
+        if (!existsSync51(stashPath)) return null;
         try {
-          return readFileSync47(stashPath, "utf-8").trim() || null;
+          return readFileSync48(stashPath, "utf-8").trim() || null;
         } catch {
           return null;
         }
@@ -27433,9 +28004,9 @@ var init_stash_manager = __esm({
        */
       getStashCount() {
         const logPath = join55(this.gitDir, "logs", "refs", "stash");
-        if (!existsSync50(logPath)) return 0;
+        if (!existsSync51(logPath)) return 0;
         try {
-          const content = readFileSync47(logPath, "utf-8");
+          const content = readFileSync48(logPath, "utf-8");
           return content.split("\n").filter((line) => line.trim().length > 0).length;
         } catch {
           return 0;
@@ -27467,11 +28038,11 @@ __export(drift_tracker_exports, {
   determineOrigin: () => determineOrigin
 });
 import {
-  existsSync as existsSync51,
+  existsSync as existsSync52,
   mkdirSync as mkdirSync31,
-  readFileSync as readFileSync48,
+  readFileSync as readFileSync49,
   statSync as statSync9,
-  writeFileSync as writeFileSync30
+  writeFileSync as writeFileSync31
 } from "fs";
 import { join as join56 } from "path";
 function determineOrigin(lastSyncTimestamp) {
@@ -27688,11 +28259,11 @@ var init_drift_tracker = __esm({
         const relPath = filePath.startsWith("/") ? filePath.slice(this.config.projectRoot.length + 1) : filePath;
         const language = detectLanguage2(relPath);
         if (!language) return result;
-        if (existsSync51(absPath) && !this.mtimeCache.check(absPath)) {
+        if (existsSync52(absPath) && !this.mtimeCache.check(absPath)) {
           result.filesSkipped = 1;
           return result;
         }
-        if (!existsSync51(absPath)) {
+        if (!existsSync52(absPath)) {
           const baseEntities2 = await this.localGraph.getEntitiesByFile(relPath);
           this.markFileDeleted(relPath, intentId);
           result.filesProcessed = 1;
@@ -27730,7 +28301,7 @@ var init_drift_tracker = __esm({
           this.maybeEmitDrift(relPath, result);
           return result;
         }
-        const content = readFileSync48(absPath, "utf-8");
+        const content = readFileSync49(absPath, "utf-8");
         const sha = contentSha256(content);
         const decision = this.fileHashManager.shouldProcess(relPath, sha, headSha);
         if (decision === "skip") {
@@ -28050,11 +28621,11 @@ var init_drift_tracker = __esm({
       }
       async saveDriftSummary() {
         const driftDir = join56(this.config.unerrDir, "drift");
-        if (!existsSync51(driftDir)) {
+        if (!existsSync52(driftDir)) {
           mkdirSync31(driftDir, { recursive: true });
         }
         const summary = await this.getDriftSummary();
-        writeFileSync30(
+        writeFileSync31(
           join56(driftDir, "drift_summary.json"),
           JSON.stringify(summary, null, 2),
           "utf-8"
@@ -28464,7 +29035,7 @@ var incremental_indexer_exports = {};
 __export(incremental_indexer_exports, {
   indexFilesIncremental: () => indexFilesIncremental
 });
-import { existsSync as existsSync52, readFileSync as readFileSync49 } from "fs";
+import { existsSync as existsSync53, readFileSync as readFileSync50 } from "fs";
 import { join as join57, relative as relative4 } from "path";
 async function indexFilesIncremental(projectRoot, changedFiles, graphStore, repoId) {
   const startMs = Date.now();
@@ -28482,7 +29053,7 @@ async function indexFilesIncremental(projectRoot, changedFiles, graphStore, repo
   for (const filePath of changedFiles) {
     const absPath = filePath.startsWith("/") ? filePath : join57(projectRoot, filePath);
     const relPath = filePath.startsWith("/") ? relative4(projectRoot, filePath) : filePath;
-    if (!existsSync52(absPath)) {
+    if (!existsSync53(absPath)) {
       const deleted2 = await deleteFileFromGraph(db, relPath);
       filesDeleted++;
       totalEntitiesDeleted += deleted2.entitiesDeleted;
@@ -28495,7 +29066,7 @@ async function indexFilesIncremental(projectRoot, changedFiles, graphStore, repo
     }
     let content;
     try {
-      content = readFileSync49(absPath, "utf-8");
+      content = readFileSync50(absPath, "utf-8");
     } catch {
       continue;
     }
@@ -29662,7 +30233,7 @@ var workspace_manifest_exports = {};
 __export(workspace_manifest_exports, {
   WorkspaceManifest: () => WorkspaceManifest
 });
-import { existsSync as existsSync53, mkdirSync as mkdirSync32, readFileSync as readFileSync50, writeFileSync as writeFileSync31 } from "fs";
+import { existsSync as existsSync54, mkdirSync as mkdirSync32, readFileSync as readFileSync51, writeFileSync as writeFileSync32 } from "fs";
 import { join as join58 } from "path";
 var WorkspaceManifest;
 var init_workspace_manifest = __esm({
@@ -29768,7 +30339,7 @@ var init_workspace_manifest = __esm({
       }
       // ── Internal ─────────────────────────────────────────────────────
       load() {
-        if (!existsSync53(this.manifestPath)) {
+        if (!existsSync54(this.manifestPath)) {
           return {
             version: 1,
             repoId: this.repoId,
@@ -29778,7 +30349,7 @@ var init_workspace_manifest = __esm({
           };
         }
         try {
-          const raw = readFileSync50(this.manifestPath, "utf-8");
+          const raw = readFileSync51(this.manifestPath, "utf-8");
           const parsed = JSON.parse(raw);
           if (parsed.repoId !== this.repoId) {
             return {
@@ -29801,10 +30372,10 @@ var init_workspace_manifest = __esm({
         }
       }
       save() {
-        if (!existsSync53(this.unerrDir)) {
+        if (!existsSync54(this.unerrDir)) {
           mkdirSync32(this.unerrDir, { recursive: true });
         }
-        writeFileSync31(
+        writeFileSync32(
           this.manifestPath,
           JSON.stringify(this.data, null, 2),
           "utf-8"
@@ -29995,7 +30566,7 @@ var log_tailer_exports = {};
 __export(log_tailer_exports, {
   startLogTailer: () => startLogTailer
 });
-import { existsSync as existsSync54, statSync as statSync10, openSync, readSync, closeSync, watch } from "fs";
+import { existsSync as existsSync55, statSync as statSync10, openSync, readSync, closeSync, watch } from "fs";
 import { join as join59 } from "path";
 function formatSize2(bytes) {
   if (bytes >= 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
@@ -30110,22 +30681,22 @@ function startLogTailer(cwd, options) {
   const fileReadsPath = join59(logsDir, "file-reads.jsonl");
   const compressionState = {
     path: compressionPath,
-    offset: existsSync54(compressionPath) ? statSync10(compressionPath).size : 0,
+    offset: existsSync55(compressionPath) ? statSync10(compressionPath).size : 0,
     watcher: null
   };
   const generalState = {
     path: generalPath,
-    offset: existsSync54(generalPath) ? statSync10(generalPath).size : 0,
+    offset: existsSync55(generalPath) ? statSync10(generalPath).size : 0,
     watcher: null
   };
   const tokenFlowState = {
     path: tokenFlowPath,
-    offset: existsSync54(tokenFlowPath) ? statSync10(tokenFlowPath).size : 0,
+    offset: existsSync55(tokenFlowPath) ? statSync10(tokenFlowPath).size : 0,
     watcher: null
   };
   const fileReadsState = {
     path: fileReadsPath,
-    offset: existsSync54(fileReadsPath) ? statSync10(fileReadsPath).size : 0,
+    offset: existsSync55(fileReadsPath) ? statSync10(fileReadsPath).size : 0,
     watcher: null
   };
   function setupWatcher(state, handler) {
@@ -30153,7 +30724,7 @@ function startLogTailer(cwd, options) {
   ];
   const pollInterval = setInterval(() => {
     for (const { state, handler } of allStates) {
-      if (!state.watcher && existsSync54(state.path)) {
+      if (!state.watcher && existsSync55(state.path)) {
         try {
           state.offset = 0;
           state.watcher = watch(state.path, () => {
@@ -31487,13 +32058,13 @@ function createSystemRoutes(deps) {
   });
   app.get("/config", async (c) => {
     const start = performance.now();
-    const { existsSync: existsSync63, readFileSync: readFileSync57 } = await import("fs");
+    const { existsSync: existsSync64, readFileSync: readFileSync58 } = await import("fs");
     const { join: join68 } = await import("path");
     let config = {};
     const configPath = join68(deps.cwd, ".unerr", "config.json");
-    if (existsSync63(configPath)) {
+    if (existsSync64(configPath)) {
       try {
-        config = JSON.parse(readFileSync57(configPath, "utf-8"));
+        config = JSON.parse(readFileSync58(configPath, "utf-8"));
       } catch {
         config = { error: "unreadable" };
       }
@@ -31694,20 +32265,20 @@ __export(session_history_exports, {
   getWeeklyStats: () => getWeeklyStats,
   readSessionHistory: () => readSessionHistory
 });
-import { appendFileSync as appendFileSync8, existsSync as existsSync55, mkdirSync as mkdirSync33, readFileSync as readFileSync51 } from "fs";
+import { appendFileSync as appendFileSync8, existsSync as existsSync56, mkdirSync as mkdirSync33, readFileSync as readFileSync52 } from "fs";
 import { join as join60 } from "path";
 function appendSessionHistory(unerrDir, entry) {
   const stateDir = join60(unerrDir, "state");
-  if (!existsSync55(stateDir)) mkdirSync33(stateDir, { recursive: true });
+  if (!existsSync56(stateDir)) mkdirSync33(stateDir, { recursive: true });
   const historyPath = join60(stateDir, "session-history.jsonl");
   appendFileSync8(historyPath, `${JSON.stringify(entry)}
 `, "utf-8");
 }
 function readSessionHistory(unerrDir) {
   const historyPath = join60(unerrDir, "state", "session-history.jsonl");
-  if (!existsSync55(historyPath)) return [];
+  if (!existsSync56(historyPath)) return [];
   try {
-    const content = readFileSync51(historyPath, "utf-8");
+    const content = readFileSync52(historyPath, "utf-8");
     return content.split("\n").filter(Boolean).map((line) => {
       try {
         return JSON.parse(line);
@@ -32368,7 +32939,7 @@ var http_exports = {};
 __export(http_exports, {
   startDashboardServer: () => startDashboardServer
 });
-import { existsSync as existsSync56, readFileSync as readFileSync52, unlinkSync as unlinkSync8, writeFileSync as writeFileSync32 } from "fs";
+import { existsSync as existsSync57, readFileSync as readFileSync53, unlinkSync as unlinkSync8, writeFileSync as writeFileSync33 } from "fs";
 import { createServer as createServer3 } from "net";
 import { dirname as dirname7, join as join61 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -32418,8 +32989,8 @@ async function startDashboardServer(opts) {
   }
   const distDir = join61(dirname7(fileURLToPath2(import.meta.url)), "ui");
   const spaIndex = join61(distDir, "index.html");
-  if (existsSync56(spaIndex)) {
-    const spaHtml = readFileSync52(spaIndex, "utf-8");
+  if (existsSync57(spaIndex)) {
+    const spaHtml = readFileSync53(spaIndex, "utf-8");
     app.use("*", serveStatic({ root: distDir }));
     app.get("*", (c) => {
       const path7 = c.req.path;
@@ -32456,7 +33027,7 @@ async function startDashboardServer(opts) {
     url: `http://localhost:${port}`
   };
   const tmpPath = `${serverJsonPath}.tmp.${process.pid}`;
-  writeFileSync32(tmpPath, JSON.stringify(serverInfo, null, 2));
+  writeFileSync33(tmpPath, JSON.stringify(serverInfo, null, 2));
   const { renameSync: renameSync3 } = await import("fs");
   renameSync3(tmpPath, serverJsonPath);
   const close = () => {
@@ -32850,7 +33421,7 @@ var proxy_exports = {};
 __export(proxy_exports, {
   startProxy: () => startProxy
 });
-import { existsSync as existsSync57, mkdirSync as mkdirSync34, readFileSync as readFileSync53, readdirSync as readdirSync13, writeFileSync as fsWriteFileSync } from "fs";
+import { existsSync as existsSync58, mkdirSync as mkdirSync34, readFileSync as readFileSync54, readdirSync as readdirSync13, writeFileSync as fsWriteFileSync } from "fs";
 import { join as join62 } from "path";
 async function getProxyFactStore(unerrDir) {
   if (proxyFactStore !== void 0) return proxyFactStore;
@@ -32937,8 +33508,8 @@ async function handleRecallFactsProxy(args, unerrDir) {
 function migrateAgentPermissions(cwd) {
   try {
     const settingsPath = join62(cwd, ".claude", "settings.json");
-    if (!existsSync57(settingsPath)) return;
-    const raw = readFileSync53(settingsPath, "utf-8");
+    if (!existsSync58(settingsPath)) return;
+    const raw = readFileSync54(settingsPath, "utf-8");
     const settings = JSON.parse(raw);
     const deny = settings?.permissions?.deny;
     if (!Array.isArray(deny)) return;
@@ -32959,7 +33530,7 @@ async function startProxy(opts = {}) {
   lifecycle.send({ type: "START_DETECT" });
   startup.setLocalMode(true);
   const stateDir = join62(process.cwd(), ".unerr", "state");
-  if (!existsSync57(stateDir)) {
+  if (!existsSync58(stateDir)) {
     mkdirSync34(stateDir, { recursive: true });
   }
   const pidLock = new PidLock(stateDir);
@@ -32993,15 +33564,15 @@ async function startProxy(opts = {}) {
     repoIds = [opts.repoId];
   } else {
     const configPath = join62(process.cwd(), ".unerr", "config.json");
-    if (existsSync57(configPath)) {
+    if (existsSync58(configPath)) {
       try {
-        const config = JSON.parse(readFileSync53(configPath, "utf-8"));
+        const config = JSON.parse(readFileSync54(configPath, "utf-8"));
         if (config.repoId) repoIds = [config.repoId];
       } catch {
       }
     }
     const manifestsDir = join62(process.cwd(), ".unerr", "manifests");
-    if (repoIds.length === 0 && existsSync57(manifestsDir)) {
+    if (repoIds.length === 0 && existsSync58(manifestsDir)) {
       repoIds = readdirSync13(manifestsDir).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
     }
   }
@@ -33435,8 +34006,8 @@ async function startProxy(opts = {}) {
   );
   process.env.UNERR_SESSION_ID = shadowLedger2.getSessionId();
   try {
-    const { writeFileSync: writeFileSync36 } = await import("fs");
-    writeFileSync36(join62(unerrDirForLedger, "state", "session.id"), shadowLedger2.getSessionId(), "utf-8");
+    const { writeFileSync: writeFileSync37 } = await import("fs");
+    writeFileSync37(join62(unerrDirForLedger, "state", "session.id"), shadowLedger2.getSessionId(), "utf-8");
   } catch {
   }
   router2.setTokenFlow(tokenFlowWriter2);
@@ -34266,7 +34837,7 @@ async function startProxy(opts = {}) {
       });
       for (const file of sourceFiles.slice(0, 500)) {
         try {
-          const content = readFileSync53(join62(process.cwd(), file), "utf-8");
+          const content = readFileSync54(join62(process.cwd(), file), "utf-8");
           const entities = extractEntitiesFromSource2(file, content);
           parseIndex.addEntities(entities);
         } catch {
@@ -34428,7 +34999,7 @@ async function startProxy(opts = {}) {
       temporal: await (async () => {
         try {
           const { TemporalFactStore: TemporalFactStore2 } = await Promise.resolve().then(() => (init_temporal_facts(), temporal_facts_exports));
-          const { readdirSync: readdirSync15, readFileSync: readFileSync57 } = await import("fs");
+          const { readdirSync: readdirSync15, readFileSync: readFileSync58 } = await import("fs");
           const factStore2 = await TemporalFactStore2.create(
             process.cwd()
           );
@@ -34439,7 +35010,7 @@ async function startProxy(opts = {}) {
                 const sessDir = join62(unerrDirForApi, "sessions");
                 const files = readdirSync15(sessDir).filter((f) => f.endsWith(".jsonl")).sort().slice(-limit);
                 return files.map((f) => {
-                  const content = readFileSync57(join62(sessDir, f), "utf-8").trim().split("\n").pop();
+                  const content = readFileSync58(join62(sessDir, f), "utf-8").trim().split("\n").pop();
                   return JSON.parse(content);
                 });
               } catch {
@@ -34861,7 +35432,7 @@ __export(session_logger_exports, {
 import { randomUUID as randomUUID2 } from "crypto";
 import {
   appendFileSync as appendFileSync9,
-  existsSync as existsSync58,
+  existsSync as existsSync59,
   mkdirSync as mkdirSync35,
   readdirSync as readdirSync14,
   statSync as statSync11,
@@ -34875,7 +35446,7 @@ function formatTimestamp() {
   return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
 }
 function cleanupOldLogs(logsDir) {
-  if (!existsSync58(logsDir)) return;
+  if (!existsSync59(logsDir)) return;
   try {
     const files = readdirSync14(logsDir).filter((f) => f.startsWith("session-") && f.endsWith(".log")).map((f) => {
       const fullPath = join63(logsDir, f);
@@ -34895,7 +35466,7 @@ function cleanupOldLogs(logsDir) {
         }
       }
     }
-    const remaining = files.filter((f) => existsSync58(f.path));
+    const remaining = files.filter((f) => existsSync59(f.path));
     if (remaining.length > MAX_FILES) {
       for (const file of remaining.slice(MAX_FILES)) {
         try {
@@ -34988,7 +35559,7 @@ __export(setup_wizard_exports, {
   runSetup: () => runSetup
 });
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync59, mkdirSync as mkdirSync36, writeFileSync as writeFileSync33 } from "fs";
+import { existsSync as existsSync60, mkdirSync as mkdirSync36, writeFileSync as writeFileSync34 } from "fs";
 import { join as join64 } from "path";
 import * as clack from "@clack/prompts";
 async function runSetup(cwd) {
@@ -35000,10 +35571,10 @@ async function runSetup(cwd) {
   mkdirSync36(configDir, { recursive: true });
   const configPath = join64(configDir, "config.json");
   const settingsPath = join64(configDir, "settings.json");
-  writeFileSync33(configPath, `${JSON.stringify({ repoId }, null, 2)}
+  writeFileSync34(configPath, `${JSON.stringify({ repoId }, null, 2)}
 `);
   let existingSettings = {};
-  if (existsSync59(settingsPath)) {
+  if (existsSync60(settingsPath)) {
     try {
       existingSettings = JSON.parse(
         __require("fs").readFileSync(settingsPath, "utf-8")
@@ -35011,7 +35582,7 @@ async function runSetup(cwd) {
     } catch {
     }
   }
-  writeFileSync33(
+  writeFileSync34(
     settingsPath,
     `${JSON.stringify({ ...existingSettings }, null, 2)}
 `
@@ -35612,13 +36183,13 @@ __export(session_summary_writer_exports, {
   readLastSession: () => readLastSession,
   writeSessionSummary: () => writeSessionSummary
 });
-import { existsSync as existsSync60, mkdirSync as mkdirSync37, appendFileSync as appendFileSync10, writeFileSync as writeFileSync34, readFileSync as readFileSync54 } from "fs";
+import { existsSync as existsSync61, mkdirSync as mkdirSync37, appendFileSync as appendFileSync10, writeFileSync as writeFileSync35, readFileSync as readFileSync55 } from "fs";
 import { join as join65 } from "path";
 function writeSessionSummary(unerrDir, ctx) {
   if (ctx.entries.length === 0) return null;
   try {
     const sessionsDir = join65(unerrDir, "sessions");
-    if (!existsSync60(sessionsDir)) {
+    if (!existsSync61(sessionsDir)) {
       mkdirSync37(sessionsDir, { recursive: true });
     }
     const sorted = [...ctx.entries].sort(
@@ -35678,8 +36249,8 @@ function writeSessionSummary(unerrDir, ctx) {
 function readLastSession(unerrDir) {
   try {
     const pointerPath = join65(unerrDir, "state", "last_session.json");
-    if (!existsSync60(pointerPath)) return null;
-    const content = readFileSync54(pointerPath, "utf-8");
+    if (!existsSync61(pointerPath)) return null;
+    const content = readFileSync55(pointerPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -35688,11 +36259,11 @@ function readLastSession(unerrDir) {
 function writeLastSessionPointer(unerrDir, sessionId, record) {
   try {
     const stateDir = join65(unerrDir, "state");
-    if (!existsSync60(stateDir)) {
+    if (!existsSync61(stateDir)) {
       mkdirSync37(stateDir, { recursive: true });
     }
     const pointerPath = join65(stateDir, "last_session.json");
-    writeFileSync34(pointerPath, JSON.stringify(record, null, 2), "utf-8");
+    writeFileSync35(pointerPath, JSON.stringify(record, null, 2), "utf-8");
   } catch {
   }
 }
@@ -35889,20 +36460,20 @@ var mcp_server_exports = {};
 __export(mcp_server_exports, {
   startMcpServer: () => startMcpServer
 });
-import { existsSync as existsSync61, mkdirSync as mkdirSync38, readFileSync as readFileSync55, writeFileSync as writeFileSync35 } from "fs";
+import { existsSync as existsSync62, mkdirSync as mkdirSync38, readFileSync as readFileSync56, writeFileSync as writeFileSync36 } from "fs";
 import { join as join66 } from "path";
 function migrateAgentPermissions2(cwd) {
   try {
     const settingsPath = join66(cwd, ".claude", "settings.json");
-    if (!existsSync61(settingsPath)) return;
-    const raw = readFileSync55(settingsPath, "utf-8");
+    if (!existsSync62(settingsPath)) return;
+    const raw = readFileSync56(settingsPath, "utf-8");
     const settings = JSON.parse(raw);
     const deny = settings?.permissions?.deny;
     if (!Array.isArray(deny)) return;
     const readIdx = deny.indexOf("Read");
     if (readIdx < 0) return;
     deny.splice(readIdx, 1);
-    writeFileSync35(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    writeFileSync36(settingsPath, JSON.stringify(settings, null, 2) + "\n");
     process.stderr.write("[unerr] Migrated permissions: removed Read from deny list (required for Edit workflow)\n");
   } catch {
   }
@@ -35912,7 +36483,7 @@ async function startMcpServer(cwd) {
   const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
   const { ListToolsRequestSchema, CallToolRequestSchema } = await import("@modelcontextprotocol/sdk/types.js");
   const unerrDir = join66(cwd, ".unerr");
-  if (!existsSync61(unerrDir)) {
+  if (!existsSync62(unerrDir)) {
     mkdirSync38(unerrDir, { recursive: true });
   }
   migrateAgentPermissions2(cwd);
@@ -36078,22 +36649,28 @@ async function startMcpServer(cwd) {
         const filePath = args.file_path ?? args.path ?? args.key?.split("::")[0] ?? null;
         if (filePath) {
           try {
-            const [fileFacts, negativeFacts] = await Promise.all([
-              factStore.recallByScope(filePath),
-              factStore.recallNegative(0.2)
-            ]);
-            const seen = /* @__PURE__ */ new Set();
-            const merged = [];
-            for (const f of fileFacts) {
-              if (!seen.has(f.fact_id)) {
-                seen.add(f.fact_id);
-                merged.push(f);
+            let merged;
+            if (name === "file_read" && router) {
+              const entityKeys = await router.getEntityKeysForFile(filePath);
+              merged = await factStore.recallForFile(filePath, entityKeys);
+            } else {
+              const [fileFacts, negativeFacts] = await Promise.all([
+                factStore.recallByScope(filePath),
+                factStore.recallNegative(0.2)
+              ]);
+              const seen = /* @__PURE__ */ new Set();
+              merged = [];
+              for (const f of fileFacts) {
+                if (!seen.has(f.fact_id)) {
+                  seen.add(f.fact_id);
+                  merged.push(f);
+                }
               }
-            }
-            for (const f of negativeFacts) {
-              if (!seen.has(f.fact_id)) {
-                seen.add(f.fact_id);
-                merged.push(f);
+              for (const f of negativeFacts) {
+                if (!seen.has(f.fact_id)) {
+                  seen.add(f.fact_id);
+                  merged.push(f);
+                }
               }
             }
             if (merged.length > 0) {
@@ -36320,7 +36897,7 @@ async function initTier2Modules(unerrDir) {
     try {
       const stateDir = join66(unerrDir, "state");
       mkdirSync38(stateDir, { recursive: true });
-      writeFileSync35(join66(stateDir, "session.id"), sessionId, "utf-8");
+      writeFileSync36(join66(stateDir, "session.id"), sessionId, "utf-8");
     } catch {
     }
     log24.info(`Token flow active (session ${sessionId.slice(0, 8)})`);
@@ -36462,7 +37039,7 @@ async function loadIntelligence(cwd) {
   const projectRoot = cwd;
   try {
     const unerrDir = join66(projectRoot, ".unerr");
-    if (!existsSync61(unerrDir)) {
+    if (!existsSync62(unerrDir)) {
       mkdirSync38(unerrDir, { recursive: true });
     }
     const { openPersistentDb: openPersistentDb2 } = await Promise.resolve().then(() => (init_persistent_db(), persistent_db_exports));
@@ -36483,9 +37060,9 @@ async function loadIntelligence(cwd) {
         await runCommunityDetection2(localGraph);
         const configPath = join66(projectRoot, ".unerr", "config.json");
         let repoId = "unknown";
-        if (existsSync61(configPath)) {
+        if (existsSync62(configPath)) {
           try {
-            const config = JSON.parse(readFileSync55(configPath, "utf-8"));
+            const config = JSON.parse(readFileSync56(configPath, "utf-8"));
             repoId = config.repoId ?? repoId;
           } catch {
           }
@@ -36514,9 +37091,9 @@ async function loadIntelligence(cwd) {
       try {
         const configPath = join66(projectRoot, ".unerr", "config.json");
         let indexRepoId = "unknown";
-        if (existsSync61(configPath)) {
+        if (existsSync62(configPath)) {
           try {
-            const cfg = JSON.parse(readFileSync55(configPath, "utf-8"));
+            const cfg = JSON.parse(readFileSync56(configPath, "utf-8"));
             indexRepoId = cfg.repoId ?? indexRepoId;
           } catch {
           }
@@ -36626,7 +37203,7 @@ var init_mcp_server = __esm({
 
 // src/entrypoints/cli.ts
 init_startup_log();
-import { existsSync as existsSync62, readFileSync as readFileSync56 } from "fs";
+import { existsSync as existsSync63, readFileSync as readFileSync57 } from "fs";
 import { join as join67 } from "path";
 import { Command } from "commander";
 
@@ -38631,19 +39208,19 @@ async function buildShellDiffRiskMap(graph, stdout) {
 }
 async function tryLoadGraphForShellBoost(cwd) {
   try {
-    const { existsSync: existsSync63, readFileSync: readFileSync57 } = await import("fs");
+    const { existsSync: existsSync64, readFileSync: readFileSync58 } = await import("fs");
     const { join: join68 } = await import("path");
     const { gunzipSync: gunzipSync3 } = await import("zlib");
     const { unpack } = await import("msgpackr");
     const snapshotsDir = join68(cwd, ".unerr", "snapshots");
     let snapshotPath2 = join68(snapshotsDir, "graph.msgpack.gz");
-    if (!existsSync63(snapshotPath2)) {
+    if (!existsSync64(snapshotPath2)) {
       snapshotPath2 = join68(snapshotsDir, "graph.msgpack");
     }
-    if (!existsSync63(snapshotPath2)) return null;
+    if (!existsSync64(snapshotPath2)) return null;
     const { default: CozoDbConstructor } = await import("cozo-node");
     const { CozoGraphStore: CozoGraphStore2 } = await Promise.resolve().then(() => (init_local_graph(), local_graph_exports));
-    const raw = readFileSync57(snapshotPath2);
+    const raw = readFileSync58(snapshotPath2);
     let buffer;
     try {
       buffer = gunzipSync3(raw);
@@ -41835,6 +42412,7 @@ function runPreToolUseHook(stdinJson, handler) {
   if (!payload) return "{}";
   const adapter = detectAdapter(payload);
   const normalized = adapter.normalize(payload);
+  normalized.agentName = adapter.name;
   const result = handler(normalized);
   return adapter.formatPreToolUse(result);
 }
@@ -41843,6 +42421,7 @@ function runPostToolUseHook(stdinJson, handler) {
   if (!payload) return "{}";
   const adapter = detectAdapter(payload);
   const normalized = adapter.normalize(payload);
+  normalized.agentName = adapter.name;
   const result = handler(normalized);
   return adapter.formatPostToolUse(result);
 }
@@ -41851,6 +42430,7 @@ function runPromptSubmitHook(stdinJson, handler) {
   if (!payload) return "{}";
   const adapter = detectAdapter(payload);
   const normalized = adapter.normalize(payload);
+  normalized.agentName = adapter.name;
   const result = handler(normalized);
   return adapter.formatPromptSubmit(result);
 }
@@ -41879,17 +42459,27 @@ var preReadHandler = (normalized) => {
   const input = normalized.toolInput;
   const filePath = extractFilePath2(input);
   if (!filePath) return passthrough();
+  const isClaudeCode = normalized.agentName === "claude-code";
   const hasOffset = input.offset !== void 0;
   const hasLimit = input.limit !== void 0;
   const isTargeted = hasOffset || hasLimit;
-  const targetedReadGuidance = isTargeted ? "" : `
-IMPORTANT: Use offset/limit to read only the lines you plan to edit \u2014 do NOT read the entire file. You already know the target lines from file_read. Example: Read with offset=50, limit=30 to read lines 50-79.`;
-  return nudge(
-    `READ ROUTING: Built-in Read is ONLY for the Edit workflow (Read \u2192 Edit). For all other reading, use unerr tools instead:
-- Reading to understand: \`file_read({ file_path: "${filePath}", purpose: "explore" })\`
-- Reading before Edit: built-in Read is correct (proceed)
+  if (isClaudeCode && isTargeted) {
+    return passthrough();
+  }
+  if (isClaudeCode) {
+    return nudge(
+      `READ ROUTING: Built-in Read is ONLY for the Edit workflow (Read \u2192 Edit). Use offset/limit to read only the lines you plan to edit \u2014 do NOT read the entire file.
+For all other reading, use unerr tools instead:
+- Reading to understand: \`file_read({ file_path: "${filePath}" })\`
 - File structure: \`file_outline("${filePath}")\`
-- Specific function: \`get_entity\` or \`file_read\` with \`entity\` param` + targetedReadGuidance
+- Specific function: \`get_entity\` or \`file_read\` with \`entity\` param`
+    );
+  }
+  return nudge(
+    `Use unerr tools instead of built-in Read:
+- \`file_read({ file_path: "${filePath}" })\` \u2014 auto-injects conventions, facts, drift status
+- \`file_outline("${filePath}")\` \u2014 file structure overview
+- \`get_entity\` or \`file_read\` with \`entity\` param \u2014 specific function/class`
   );
 };
 var preGrepHandler = (normalized) => {
@@ -41941,9 +42531,10 @@ var preEditHandler = (normalized) => {
   const input = normalized.toolInput;
   const filePath = extractFilePath2(input);
   if (!filePath || !isCodeFile(filePath)) return passthrough();
-  const readPrereq = `CRITICAL: Edit REQUIRES built-in Read to have been called on "${filePath}" first. file_read (MCP) does NOT satisfy this \u2014 the Edit tool will fail with "File has not been read yet". If you haven't called built-in Read on this file, do so now before attempting Edit. Use offset/limit to read only the lines you plan to edit \u2014 do NOT read the entire file.
+  const isClaudeCode = normalized.agentName === "claude-code";
+  const readPrereq = isClaudeCode ? `CRITICAL: Edit REQUIRES built-in Read to have been called on "${filePath}" first. file_read (MCP) does NOT satisfy this \u2014 the Edit tool will fail with "File has not been read yet". If you haven't called built-in Read (with offset/limit on the target lines) on this file, do so now before attempting Edit.
 
-`;
+` : "";
   const oldStr = input.old_string;
   const hasSignatureChange = oldStr && /^(export\s+)?(async\s+)?function\s+\w+|^(export\s+)?class\s+\w+/.test(oldStr.trim());
   if (hasSignatureChange) {
@@ -41963,9 +42554,16 @@ var postReadHandler = (normalized) => {
   const input = normalized.toolInput;
   const filePath = extractFilePath2(input);
   if (!filePath || !isCodeFile(filePath)) return passthrough();
-  return enrich(
-    `If you're about to Edit this file, this Read was correct (Edit requires built-in Read first).
+  const isClaudeCode = normalized.agentName === "claude-code";
+  if (isClaudeCode) {
+    return enrich(
+      `If you're about to Edit this file, this Read was correct (Edit requires built-in Read first).
 If you're exploring, use \`file_read\` instead \u2014 it auto-injects conventions, facts, and drift status.
+Next steps: \`get_references\` to check callers before modifying, \`get_rules\` to validate conventions.`
+    );
+  }
+  return enrich(
+    `Prefer \`file_read\` over built-in Read \u2014 it auto-injects conventions, facts, and drift status.
 Next steps: \`get_references\` to check callers before modifying, \`get_rules\` to validate conventions.`
   );
 };
@@ -42088,56 +42686,32 @@ function runPreBashHook(stdinJson) {
 }
 
 // src/commands/hook.ts
+function safeHookAction(handler) {
+  return () => {
+    try {
+      const stdin = readFileSync15(0, "utf-8");
+      process.stdout.write(handler(stdin));
+    } catch (e) {
+      process.stderr.write(`[unerr] hook error: ${e}
+`);
+      process.stdout.write("{}");
+    }
+  };
+}
 function registerHookCommand(program2) {
   const hook = program2.command("hook").description("IDE hook handlers (stdin/stdout JSON)");
-  hook.command("pre-bash").description("Rewrite Bash tool input to pipe through unerr exec").action(() => {
-    const stdin = readFileSync15(0, "utf-8");
-    process.stdout.write(runPreBashHook(stdin));
-  });
-  hook.command("pre-read").description("Nudge agent to use file_outline/file_read instead of Read").action(() => {
-    const stdin = readFileSync15(0, "utf-8");
-    process.stdout.write(runPreReadHook(stdin));
-  });
-  hook.command("pre-grep").description("Nudge agent to use search_code/get_callers instead of Grep").action(() => {
-    const stdin = readFileSync15(0, "utf-8");
-    process.stdout.write(runPreGrepHook(stdin));
-  });
-  hook.command("pre-glob").description("Nudge agent to use search_code instead of Glob").action(() => {
-    const stdin = readFileSync15(0, "utf-8");
-    process.stdout.write(runPreGlobHook(stdin));
-  });
-  hook.command("pre-write").description("Blast radius + convention check before Write").action(() => {
-    const stdin = readFileSync15(0, "utf-8");
-    process.stdout.write(runPreWriteHook(stdin));
-  });
-  hook.command("pre-edit").description("Blast radius + convention check before Edit").action(() => {
-    const stdin = readFileSync15(0, "utf-8");
-    process.stdout.write(runPreEditHook(stdin));
-  });
-  hook.command("post-read").description("Enrich Read output with graph navigation suggestions").action(() => {
-    const stdin = readFileSync15(0, "utf-8");
-    process.stdout.write(runPostReadHook(stdin));
-  });
-  hook.command("post-grep").description("Enrich Grep output with graph navigation suggestions").action(() => {
-    const stdin = readFileSync15(0, "utf-8");
-    process.stdout.write(runPostGrepHook(stdin));
-  });
-  hook.command("post-glob").description("Enrich Glob output with graph navigation suggestions").action(() => {
-    const stdin = readFileSync15(0, "utf-8");
-    process.stdout.write(runPostGlobHook(stdin));
-  });
-  hook.command("post-write").description("Post-write convention check + caller verification reminder").action(() => {
-    const stdin = readFileSync15(0, "utf-8");
-    process.stdout.write(runPostWriteHook(stdin));
-  });
-  hook.command("post-edit").description("Post-edit convention check + caller verification reminder").action(() => {
-    const stdin = readFileSync15(0, "utf-8");
-    process.stdout.write(runPostEditHook(stdin));
-  });
-  hook.command("prompt-submit").description("Inject unerr tool reminder on each user prompt").action(() => {
-    const stdin = readFileSync15(0, "utf-8");
-    process.stdout.write(runUserPromptSubmitHook(stdin));
-  });
+  hook.command("pre-bash").description("Rewrite Bash tool input to pipe through unerr exec").action(safeHookAction(runPreBashHook));
+  hook.command("pre-read").description("Nudge agent to use file_outline/file_read instead of Read").action(safeHookAction(runPreReadHook));
+  hook.command("pre-grep").description("Nudge agent to use search_code/get_callers instead of Grep").action(safeHookAction(runPreGrepHook));
+  hook.command("pre-glob").description("Nudge agent to use search_code instead of Glob").action(safeHookAction(runPreGlobHook));
+  hook.command("pre-write").description("Blast radius + convention check before Write").action(safeHookAction(runPreWriteHook));
+  hook.command("pre-edit").description("Blast radius + convention check before Edit").action(safeHookAction(runPreEditHook));
+  hook.command("post-read").description("Enrich Read output with graph navigation suggestions").action(safeHookAction(runPostReadHook));
+  hook.command("post-grep").description("Enrich Grep output with graph navigation suggestions").action(safeHookAction(runPostGrepHook));
+  hook.command("post-glob").description("Enrich Glob output with graph navigation suggestions").action(safeHookAction(runPostGlobHook));
+  hook.command("post-write").description("Post-write convention check + caller verification reminder").action(safeHookAction(runPostWriteHook));
+  hook.command("post-edit").description("Post-edit convention check + caller verification reminder").action(safeHookAction(runPostEditHook));
+  hook.command("prompt-submit").description("Inject unerr tool reminder on each user prompt").action(safeHookAction(runUserPromptSubmitHook));
 }
 
 // src/commands/index.ts
@@ -42307,89 +42881,108 @@ function runInit(cwd) {
 
 // src/commands/install.ts
 init_agent_registry();
-import { chmodSync as chmodSync4, existsSync as existsSync23, mkdirSync as mkdirSync17, readFileSync as readFileSync22, writeFileSync as writeFileSync13 } from "fs";
+import { chmodSync as chmodSync4, existsSync as existsSync24, mkdirSync as mkdirSync17, readFileSync as readFileSync23, writeFileSync as writeFileSync14 } from "fs";
 import { join as join30 } from "path";
 
 // src/config/claude-settings-hooks.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync14, readFileSync as readFileSync19, writeFileSync as writeFileSync10 } from "fs";
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync21, mkdirSync as mkdirSync14, readFileSync as readFileSync20, writeFileSync as writeFileSync11 } from "fs";
 import { join as join27 } from "path";
-var UNERR_MATCHER_HOOKS = [
-  // PreToolUse — advisory nudges + Bash rewrite
-  { event: "PreToolUse", matcher: "Bash", command: "unerr hook pre-bash" },
-  { event: "PreToolUse", matcher: "Read", command: "unerr hook pre-read" },
-  { event: "PreToolUse", matcher: "Grep", command: "unerr hook pre-grep" },
-  { event: "PreToolUse", matcher: "Glob", command: "unerr hook pre-glob" },
-  // PreToolUse — blast radius + convention validation for writes
-  { event: "PreToolUse", matcher: "Write", command: "unerr hook pre-write" },
-  { event: "PreToolUse", matcher: "Edit", command: "unerr hook pre-edit" },
-  // PostToolUse — enrich tool output with graph navigation suggestions
-  { event: "PostToolUse", matcher: "Read", command: "unerr hook post-read" },
-  { event: "PostToolUse", matcher: "Grep", command: "unerr hook post-grep" },
-  { event: "PostToolUse", matcher: "Glob", command: "unerr hook post-glob" },
-  { event: "PostToolUse", matcher: "Write", command: "unerr hook post-write" },
-  { event: "PostToolUse", matcher: "Edit", command: "unerr hook post-edit" }
-];
-var UNERR_GLOBAL_HOOKS = [
-  { event: "UserPromptSubmit", command: "unerr hook prompt-submit" }
-];
-function isUnerrHookEntry(entry, hookCmd, matcherName) {
+function resolveUnerrBinary() {
+  const entryScript = process.argv[1];
+  if (entryScript && existsSync21(entryScript)) {
+    return entryScript;
+  }
+  try {
+    const resolved = execSync2("which unerr", { encoding: "utf-8" }).trim();
+    if (resolved && existsSync21(resolved)) {
+      return resolved;
+    }
+  } catch {
+  }
+  return "unerr";
+}
+var _resolvedBinary;
+function getUnerrBinary() {
+  if (_resolvedBinary === void 0) {
+    _resolvedBinary = resolveUnerrBinary();
+  }
+  return _resolvedBinary;
+}
+function buildMatcherHooks() {
+  const bin = getUnerrBinary();
+  return [
+    // PreToolUse — advisory nudges + Bash rewrite
+    { event: "PreToolUse", matcher: "Bash", command: `${bin} hook pre-bash` },
+    { event: "PreToolUse", matcher: "Read", command: `${bin} hook pre-read` },
+    { event: "PreToolUse", matcher: "Grep", command: `${bin} hook pre-grep` },
+    { event: "PreToolUse", matcher: "Glob", command: `${bin} hook pre-glob` },
+    // PreToolUse — blast radius + convention validation for writes
+    { event: "PreToolUse", matcher: "Write", command: `${bin} hook pre-write` },
+    { event: "PreToolUse", matcher: "Edit", command: `${bin} hook pre-edit` },
+    // PostToolUse — enrich tool output with graph navigation suggestions
+    { event: "PostToolUse", matcher: "Read", command: `${bin} hook post-read` },
+    { event: "PostToolUse", matcher: "Grep", command: `${bin} hook post-grep` },
+    { event: "PostToolUse", matcher: "Glob", command: `${bin} hook post-glob` },
+    { event: "PostToolUse", matcher: "Write", command: `${bin} hook post-write` },
+    { event: "PostToolUse", matcher: "Edit", command: `${bin} hook post-edit` }
+  ];
+}
+function buildGlobalHooks() {
+  const bin = getUnerrBinary();
+  return [
+    { event: "UserPromptSubmit", command: `${bin} hook prompt-submit` }
+  ];
+}
+function isAnyUnerrHook(entry) {
   if (!entry || typeof entry !== "object") return false;
   const e = entry;
-  if (matcherName !== void 0 && e.matcher !== matcherName) return false;
   const hs = e.hooks;
   if (!Array.isArray(hs)) return false;
   return hs.some((h) => {
     if (!h || typeof h !== "object") return false;
-    const x2 = h;
-    return x2.command === hookCmd || x2.command === `npx ${hookCmd}`;
+    const cmd = h.command;
+    return typeof cmd === "string" && /(?:^|\/)unerr\s+hook\s+/.test(cmd);
   });
 }
-function isAnyUnerrHook(entry) {
-  for (const hookDef of UNERR_MATCHER_HOOKS) {
-    if (isUnerrHookEntry(entry, hookDef.command, hookDef.matcher)) return true;
-  }
-  for (const hookDef of UNERR_GLOBAL_HOOKS) {
-    if (isUnerrHookEntry(entry, hookDef.command)) return true;
-  }
-  return false;
-}
 function mergePreToolUseBashHook(cwd) {
   const dir = join27(cwd, ".claude");
   const settingsPath = join27(dir, "settings.json");
   try {
-    if (!existsSync20(dir)) {
+    if (!existsSync21(dir)) {
       mkdirSync14(dir, { recursive: true });
     }
     let settings = {};
-    if (existsSync20(settingsPath)) {
+    if (existsSync21(settingsPath)) {
       try {
-        settings = JSON.parse(readFileSync19(settingsPath, "utf-8"));
+        settings = JSON.parse(readFileSync20(settingsPath, "utf-8"));
       } catch {
         settings = {};
       }
     }
     const hooks = settings.hooks ?? {};
     let added = 0;
-    for (const hookDef of UNERR_MATCHER_HOOKS) {
-      const eventArray = Array.isArray(hooks[hookDef.event]) ? [...hooks[hookDef.event]] : [];
-      const alreadyPresent = eventArray.some(
-        (entry) => isUnerrHookEntry(entry, hookDef.command, hookDef.matcher)
-      );
-      if (!alreadyPresent) {
-        eventArray.push({
-          matcher: hookDef.matcher,
-          hooks: [{ type: "command", command: hookDef.command }]
-        });
-        hooks[hookDef.event] = eventArray;
-        added++;
+    const matcherHooks = buildMatcherHooks();
+    const globalHooks = buildGlobalHooks();
+    for (const eventType of ["PreToolUse", "PostToolUse", "UserPromptSubmit"]) {
+      if (Array.isArray(hooks[eventType])) {
+        hooks[eventType] = hooks[eventType].filter(
+          (entry) => !isAnyUnerrHook(entry)
+        );
       }
     }
-    for (const hookDef of UNERR_GLOBAL_HOOKS) {
+    for (const hookDef of matcherHooks) {
       const eventArray = Array.isArray(hooks[hookDef.event]) ? [...hooks[hookDef.event]] : [];
-      const alreadyPresent = eventArray.some(
-        (entry) => isUnerrHookEntry(entry, hookDef.command)
-      );
-      if (!alreadyPresent) {
+      eventArray.push({
+        matcher: hookDef.matcher,
+        hooks: [{ type: "command", command: hookDef.command }]
+      });
+      hooks[hookDef.event] = eventArray;
+      added++;
+    }
+    for (const hookDef of globalHooks) {
+      const eventArray = Array.isArray(hooks[hookDef.event]) ? [...hooks[hookDef.event]] : [];
+      if (!eventArray.some((entry) => isAnyUnerrHook(entry))) {
         eventArray.push({
           hooks: [{ type: "command", command: hookDef.command }]
         });
@@ -42401,7 +42994,7 @@ function mergePreToolUseBashHook(cwd) {
       return { ok: true, path: settingsPath, action: "already_present" };
     }
     settings.hooks = hooks;
-    writeFileSync10(
+    writeFileSync11(
       settingsPath,
       `${JSON.stringify(settings, null, 2)}
 `,
@@ -42417,13 +43010,13 @@ function addDisallowedTools(cwd) {
   const dir = join27(cwd, ".claude");
   const settingsPath = join27(dir, "settings.json");
   try {
-    if (!existsSync20(dir)) {
+    if (!existsSync21(dir)) {
       mkdirSync14(dir, { recursive: true });
     }
     let settings = {};
-    if (existsSync20(settingsPath)) {
+    if (existsSync21(settingsPath)) {
       try {
-        settings = JSON.parse(readFileSync19(settingsPath, "utf-8"));
+        settings = JSON.parse(readFileSync20(settingsPath, "utf-8"));
       } catch {
         settings = {};
       }
@@ -42446,7 +43039,7 @@ function addDisallowedTools(cwd) {
     }
     permissions.deny = deny;
     settings.permissions = permissions;
-    writeFileSync10(settingsPath, `${JSON.stringify(settings, null, 2)}
+    writeFileSync11(settingsPath, `${JSON.stringify(settings, null, 2)}
 `, "utf-8");
     return { added, path: settingsPath };
   } catch {
@@ -42455,9 +43048,9 @@ function addDisallowedTools(cwd) {
 }
 function removeDisallowedTools(cwd) {
   const settingsPath = join27(cwd, ".claude", "settings.json");
-  if (!existsSync20(settingsPath)) return false;
+  if (!existsSync21(settingsPath)) return false;
   try {
-    const settings = JSON.parse(readFileSync19(settingsPath, "utf-8"));
+    const settings = JSON.parse(readFileSync20(settingsPath, "utf-8"));
     const permissions = settings.permissions;
     if (!permissions || !Array.isArray(permissions.deny)) return false;
     const before = permissions.deny.length;
@@ -42468,7 +43061,7 @@ function removeDisallowedTools(cwd) {
     if (removed === 0) return false;
     if (permissions.deny.length === 0) delete permissions.deny;
     if (Object.keys(permissions).length === 0) delete settings.permissions;
-    writeFileSync10(settingsPath, `${JSON.stringify(settings, null, 2)}
+    writeFileSync11(settingsPath, `${JSON.stringify(settings, null, 2)}
 `, "utf-8");
     return true;
   } catch {
@@ -42477,9 +43070,9 @@ function removeDisallowedTools(cwd) {
 }
 function removePreToolUseBashHook(cwd) {
   const settingsPath = join27(cwd, ".claude", "settings.json");
-  if (!existsSync20(settingsPath)) return false;
+  if (!existsSync21(settingsPath)) return false;
   try {
-    const settings = JSON.parse(readFileSync19(settingsPath, "utf-8"));
+    const settings = JSON.parse(readFileSync20(settingsPath, "utf-8"));
     const hooks = settings.hooks;
     if (!hooks) return false;
     let totalRemoved = 0;
@@ -42496,7 +43089,7 @@ function removePreToolUseBashHook(cwd) {
     }
     if (totalRemoved === 0) return false;
     if (Object.keys(hooks).length === 0) delete settings.hooks;
-    writeFileSync10(
+    writeFileSync11(
       settingsPath,
       `${JSON.stringify(settings, null, 2)}
 `,
@@ -42514,11 +43107,31 @@ init_mcp_config_writer();
 
 // src/config/instruction-writer.ts
 init_agent_registry();
-import { existsSync as existsSync21, mkdirSync as mkdirSync15, readFileSync as readFileSync20, unlinkSync as unlinkSync3, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync15, readFileSync as readFileSync21, unlinkSync as unlinkSync3, writeFileSync as writeFileSync12 } from "fs";
 import { dirname as dirname5, join as join28 } from "path";
 var SENTINEL_START = "<!-- unerr:start -->";
 var SENTINEL_END = "<!-- unerr:end -->";
-function getInstructionContent() {
+function getInstructionContent(ide) {
+  const isClaudeCode = ide === "claude-code";
+  const readForEditRow = isClaudeCode ? `| Understand a file before editing | \`file_read\` with \`purpose:'explore'\` to understand, then built-in \`Read\` (offset/limit) on target lines before Edit | Reading entire file |` : `| Read a file before editing | \`file_read\` with \`entity\` param or offset/limit for targeted access | Reading entire file |`;
+  const twoStepSection = isClaudeCode ? `
+### IMPORTANT: Two-step Read Routing (Claude Code specific)
+
+**Why this matters:** Claude Code's Edit tool requires built-in \`Read\` to have been called on the file first. \`file_read\` (unerr MCP) does NOT satisfy this because it's a separate MCP tool. Meanwhile, built-in Read misses project conventions and facts that \`file_read\` auto-injects.
+
+**The rule \u2014 two paths, choose by intent:**
+
+| Intent | Tool | Why |
+|--------|------|-----|
+| Reading to understand code | \`file_read\` (unerr MCP) | Auto-injects conventions, facts, drift status |
+| Reading immediately before Edit | Built-in \`Read\` with offset/limit | Required by Edit tool \u2014 \`file_read\` does NOT satisfy this. Use targeted reads (offset/limit) for only the lines you plan to edit. |
+
+When your next action is Edit, use built-in Read with offset/limit on the target lines. For everything else, use \`file_read\`.
+
+**Common failure mode:** Using \`file_read\` to understand a file, then attempting Edit without calling built-in Read first. The Edit tool WILL reject with "File has not been read yet". Always call built-in Read (with offset/limit) immediately before Edit.` : "";
+  const summaryEditNote = isClaudeCode ? `
+NEVER use built-in Read/Grep/Glob for code navigation. EXCEPTION: built-in Read (with offset/limit) is REQUIRED immediately before Edit (file_read cannot substitute \u2014 Edit will fail without it).` : `
+NEVER use built-in Read/Grep/Glob for code navigation \u2014 use unerr MCP tools instead.`;
   return `## REQUIRED: Use unerr Graph Intelligence Tools (18 MCP tools)
 
 This project has unerr MCP tools installed. You MUST use these instead of built-in Read/Grep/Glob for code navigation. unerr tools are graph-backed, return results in <5ms, and include project context that built-in tools miss.
@@ -42529,8 +43142,8 @@ This project has unerr MCP tools installed. You MUST use these instead of built-
 |---|---|---|
 | Find a function, class, or type | \`search_code\` | Grep, Glob |
 | Find callers or callees | \`get_references\` (direction: callers/callees) | Grep for function name |
-| Read a file for understanding | \`file_read\` with \`purpose:'explore'\` (default, auto-injects conventions/facts) | Built-in Read (use ONLY before Edit) |
-| Understand a file before editing | \`file_read\` with \`purpose:'edit'\` (returns full file, no gating) | Multiple offset/limit calls |
+| Read a file for understanding | \`file_read\` with \`purpose:'explore'\` (default, auto-injects conventions/facts) | Built-in Read/Grep/Glob |
+${readForEditRow}
 | Get file structure overview | \`file_outline\` | Reading the whole file |
 | Get a specific function or class | \`get_entity\` or \`file_read\` with \`entity\` param | Reading entire file |
 | Trace imports/dependencies | \`get_imports\` or \`get_references\` (direction: callees) | Manual import scanning |
@@ -42538,27 +43151,12 @@ This project has unerr MCP tools installed. You MUST use these instead of built-
 
 ### FORBIDDEN Patterns (these waste tokens and miss context)
 
-- Calling file_read multiple times with offset/limit to read a whole file -> use \`file_read\` with \`purpose:'edit'\` (one call, full content)
 - Reading an entire file to find one function -> use \`get_entity\` or \`file_read\` with \`entity\` param
 - Grep for a function name to find callers -> use \`get_references\` (finds indirect refs too)
 - Glob + Grep to search for code -> use \`search_code\` (indexes ALL entities, <5ms)
 - Reading multiple files to understand conventions -> use \`get_conventions\`
 - Guessing code style for new code -> use \`get_rules\` (with \`content\` param to validate)
-
-### IMPORTANT: Two-step Read Routing
-
-**Why this matters:** The Edit tool has a hard technical constraint \u2014 it requires built-in \`Read\` to have been called on the file first. \`file_read\` (unerr MCP) does NOT satisfy this requirement because it's a separate MCP tool, not the built-in Read. Meanwhile, built-in Read misses project conventions, facts, and drift status that \`file_read\` auto-injects. Using the wrong one at the wrong time either blocks your edit or loses critical context.
-
-**The rule \u2014 two paths, choose by intent:**
-
-| Intent | Tool | Why |
-|--------|------|-----|
-| Reading to understand code | \`file_read\` (unerr MCP) | Auto-injects conventions, facts, drift status |
-| Reading immediately before Edit | Built-in \`Read\` with offset/limit | Required by Edit tool \u2014 \`file_read\` does NOT satisfy this. Use targeted reads (offset/limit) for only the lines you plan to edit. |
-
-When your next action is Edit, use built-in Read. For everything else, use \`file_read\`.
-
-**Common failure mode:** Using \`file_read\` to understand a file, then attempting Edit without calling built-in Read first. The Edit tool WILL reject with "File has not been read yet" \u2014 \`file_read\` (MCP) cannot satisfy this requirement. Always call built-in Read immediately before Edit.
+- Reading a full file when you only need a section -> use \`file_read\` with \`entity\` param or offset/limit${twoStepSection}
 
 ### Tool Reference
 
@@ -42584,9 +43182,8 @@ When your next action is Edit, use built-in Read. For everything else, use \`fil
 
 \`file_read\` auto-injects relevant facts and conventions. For files >50 lines, call \`file_outline\` first, then \`file_read\` with \`entity\` param for targeted access.
 
-**\`purpose\` parameter (IMPORTANT):** Controls read behavior \u2014 set it to match your intent:
-- \`purpose:'explore'\` (default) \u2014 budget-capped, returns outline for large files. Use for browsing/understanding.
-- \`purpose:'edit'\` \u2014 returns full file content with NO gating or budget cap. Use when you plan to modify the file. **One call instead of 3-5 offset/limit calls.**
+**\`purpose\` parameter:** Controls read behavior \u2014 set it to match your intent:
+- \`purpose:'explore'\` (default) \u2014 budget-capped, returns outline for large files. Use for browsing and pre-edit understanding.
 - \`purpose:'reference'\` \u2014 tight budget, entity/offset reads only. Use for quick lookups.
 
 #### Shell Compression (automatic)
@@ -42625,8 +43222,7 @@ ONLY use built-in Read/Grep/Glob when:
 
 ### Summary (CRITICAL \u2014 read this even if you skimmed above)
 
-ALWAYS use unerr MCP tools: \`search_code\`, \`get_references\`, \`file_read\`, \`file_outline\`, \`get_entity\`.
-NEVER use built-in Read/Grep/Glob for code navigation. EXCEPTION: built-in Read is REQUIRED before Edit (file_read cannot substitute \u2014 Edit will fail without it).
+ALWAYS use unerr MCP tools: \`search_code\`, \`get_references\`, \`file_read\`, \`file_outline\`, \`get_entity\`.${summaryEditNote}
 unerr skills available: /audit, /blame, /test, /lint, /commit, /review-pr.
 Before writing code: \`get_conventions\`, \`get_rules\`. After writing: \`get_rules\` with content to validate.
 Before risky changes: \`unerr_mark_working\`. If things break: \`unerr_revert_to_working_state\`.`;
@@ -42637,7 +43233,7 @@ description: REQUIRED \u2014 use unerr graph intelligence tools instead of built
 alwaysApply: true
 ---
 
-${getInstructionContent()}
+${getInstructionContent("cursor")}
 `;
 }
 function writeInstructionFile(cwd, ide) {
@@ -42651,7 +43247,7 @@ function writeInstructionFile(cwd, ide) {
   }
   if (agentDef.instructionFormat === "windsurf-rule") {
     mkdirSync15(dirname5(filePath), { recursive: true });
-    const content = getInstructionContent();
+    const content = getInstructionContent(ide);
     const truncatedContent = content.length > 5800 ? `${content.slice(0, 5800)}
 
 [Truncated \u2014 full content exceeds Windsurf 6K limit]` : content;
@@ -42662,19 +43258,19 @@ description: "Tool routing instructions for unerr MCP integration"
 
 ${truncatedContent}
 `;
-    const existed = existsSync21(filePath);
+    const existed = existsSync22(filePath);
     if (existed) {
-      const existing = readFileSync20(filePath, "utf-8");
+      const existing = readFileSync21(filePath, "utf-8");
       if (existing === windsurfContent) {
         return { path: filePath, action: "skipped" };
       }
     }
-    writeFileSync11(filePath, windsurfContent, "utf-8");
+    writeFileSync12(filePath, windsurfContent, "utf-8");
     return { path: filePath, action: existed ? "updated" : "created" };
   }
   if (agentDef.instructionFormat === "antigravity-rule") {
     mkdirSync15(dirname5(filePath), { recursive: true });
-    const content = getInstructionContent();
+    const content = getInstructionContent(ide);
     const antigravityContent = `---
 name: unerr-instructions
 description: Tool routing instructions for unerr MCP integration
@@ -42683,34 +43279,34 @@ type: manual
 
 ${content}
 `;
-    const existed = existsSync21(filePath);
+    const existed = existsSync22(filePath);
     if (existed) {
-      const existing = readFileSync20(filePath, "utf-8");
+      const existing = readFileSync21(filePath, "utf-8");
       if (existing === antigravityContent) {
         return { path: filePath, action: "skipped" };
       }
     }
-    writeFileSync11(filePath, antigravityContent, "utf-8");
+    writeFileSync12(filePath, antigravityContent, "utf-8");
     return { path: filePath, action: existed ? "updated" : "created" };
   }
-  return mergeMarkdownSection(filePath, getInstructionContent());
+  return mergeMarkdownSection(filePath, getInstructionContent(ide));
 }
 function mergeMarkdownSection(filePath, content) {
   const wrappedContent = `${SENTINEL_START}
 ${content}
 ${SENTINEL_END}`;
-  if (!existsSync21(filePath)) {
+  if (!existsSync22(filePath)) {
     const dir = dirname5(filePath);
-    if (!existsSync21(dir)) mkdirSync15(dir, { recursive: true });
-    writeFileSync11(filePath, `${wrappedContent}
+    if (!existsSync22(dir)) mkdirSync15(dir, { recursive: true });
+    writeFileSync12(filePath, `${wrappedContent}
 `);
     return { path: filePath, action: "created" };
   }
-  const existing = readFileSync20(filePath, "utf-8");
+  const existing = readFileSync21(filePath, "utf-8");
   const startIdx = existing.indexOf(SENTINEL_START);
   const endIdx = existing.indexOf(SENTINEL_END);
   if (startIdx === -1 || endIdx === -1) {
-    writeFileSync11(filePath, `${wrappedContent}
+    writeFileSync12(filePath, `${wrappedContent}
 
 ${existing}`);
     return { path: filePath, action: "updated" };
@@ -42721,21 +43317,21 @@ ${existing}`);
   }
   const before = existing.slice(0, startIdx);
   const after = existing.slice(endIdx + SENTINEL_END.length);
-  writeFileSync11(filePath, `${before}${wrappedContent}${after}`);
+  writeFileSync12(filePath, `${before}${wrappedContent}${after}`);
   return { path: filePath, action: "updated" };
 }
 function writeMdcInstructionFile(filePath) {
   const content = getMdcContent();
-  const alreadyExists = existsSync21(filePath);
+  const alreadyExists = existsSync22(filePath);
   if (alreadyExists) {
-    const existing = readFileSync20(filePath, "utf-8");
+    const existing = readFileSync21(filePath, "utf-8");
     if (existing === content) {
       return { path: filePath, action: "skipped" };
     }
   }
   const dir = dirname5(filePath);
-  if (!existsSync21(dir)) mkdirSync15(dir, { recursive: true });
-  writeFileSync11(filePath, content);
+  if (!existsSync22(dir)) mkdirSync15(dir, { recursive: true });
+  writeFileSync12(filePath, content);
   return {
     path: filePath,
     action: alreadyExists ? "updated" : "created"
@@ -42745,26 +43341,26 @@ function removeInstructionSection(cwd, ide) {
   const agentDef = getAgent(ide);
   if (!agentDef?.instructionFilePath) return false;
   const filePath = join28(cwd, agentDef.instructionFilePath);
-  if (!existsSync21(filePath)) return false;
+  if (!existsSync22(filePath)) return false;
   if (agentDef.instructionFormat === "mdc") {
     unlinkSync3(filePath);
     return true;
   }
   if (agentDef.instructionFormat === "windsurf-rule") {
-    if (existsSync21(filePath)) {
+    if (existsSync22(filePath)) {
       unlinkSync3(filePath);
       return true;
     }
     return false;
   }
   if (agentDef.instructionFormat === "antigravity-rule") {
-    if (existsSync21(filePath)) {
+    if (existsSync22(filePath)) {
       unlinkSync3(filePath);
       return true;
     }
     return false;
   }
-  const content = readFileSync20(filePath, "utf-8");
+  const content = readFileSync21(filePath, "utf-8");
   const startIdx = content.indexOf(SENTINEL_START);
   const endIdx = content.indexOf(SENTINEL_END);
   if (startIdx === -1 || endIdx === -1) return false;
@@ -42775,12 +43371,12 @@ function removeInstructionSection(cwd, ide) {
   if (trimmed.length === 0) {
     unlinkSync3(filePath);
   } else {
-    writeFileSync11(filePath, cleaned);
+    writeFileSync12(filePath, cleaned);
   }
   return true;
 }
 function generateCustomInstructions(ide) {
-  const content = getInstructionContent();
+  const content = getInstructionContent(ide);
   if (ide && ide !== "other") {
     const agentDef = getAgent(ide);
     if (agentDef?.instructionFilePath) {
@@ -43152,16 +43748,16 @@ function installCursorHooks(cwd) {
     ]
   };
   try {
-    if (!existsSync23(hooksDir)) {
+    if (!existsSync24(hooksDir)) {
       mkdirSync17(hooksDir, { recursive: true });
     }
     let config = {
       version: 1,
       hooks: {}
     };
-    if (existsSync23(hooksJsonPath)) {
+    if (existsSync24(hooksJsonPath)) {
       try {
-        const existing = JSON.parse(readFileSync22(hooksJsonPath, "utf-8"));
+        const existing = JSON.parse(readFileSync23(hooksJsonPath, "utf-8"));
         if (existing.version && existing.hooks) {
           config = existing;
         }
@@ -43178,7 +43774,7 @@ function installCursorHooks(cwd) {
       }
       config.hooks[event] = existing;
     }
-    writeFileSync13(hooksJsonPath, `${JSON.stringify(config, null, 2)}
+    writeFileSync14(hooksJsonPath, `${JSON.stringify(config, null, 2)}
 `);
     writeCursorHookScript(hooksDir, "unerr-pre-tool.sh", CURSOR_PRE_TOOL_SCRIPT);
     writeCursorHookScript(hooksDir, "unerr-post-tool.sh", CURSOR_POST_TOOL_SCRIPT);
@@ -43191,15 +43787,15 @@ function installCursorHooks(cwd) {
 }
 function writeCursorHookScript(dir, filename, content) {
   const scriptPath = join30(dir, filename);
-  writeFileSync13(scriptPath, content, "utf-8");
+  writeFileSync14(scriptPath, content, "utf-8");
   chmodSync4(scriptPath, 493);
 }
 function installClineHooks(cwd) {
   const hooksDir = join30(cwd, ".clinerules", "hooks");
   const hookPath = join30(hooksDir, "unerr-pre-tool.sh");
-  if (existsSync23(hookPath)) return true;
+  if (existsSync24(hookPath)) return true;
   try {
-    if (!existsSync23(hooksDir)) {
+    if (!existsSync24(hooksDir)) {
       const { mkdirSync: mkdirSync39 } = __require("fs");
       mkdirSync39(hooksDir, { recursive: true });
     }
@@ -43209,7 +43805,7 @@ function installClineHooks(cwd) {
 # Removed by: unerr uninstall cline
 cat /dev/stdin | unerr hook pre-read
 `;
-    writeFileSync13(hookPath, hookContent, "utf-8");
+    writeFileSync14(hookPath, hookContent, "utf-8");
     chmodSync4(hookPath, 493);
     return true;
   } catch {
@@ -43218,15 +43814,15 @@ cat /dev/stdin | unerr hook pre-read
 }
 function ensureGitignore(cwd) {
   const gitignorePath = join30(cwd, ".gitignore");
-  if (!existsSync23(gitignorePath)) return false;
+  if (!existsSync24(gitignorePath)) return false;
   try {
-    const content = readFileSync22(gitignorePath, "utf-8");
+    const content = readFileSync23(gitignorePath, "utf-8");
     const lines = content.split("\n");
     if (lines.some((l) => l.trim() === ".unerr" || l.trim() === ".unerr/")) {
       return false;
     }
     const newline = content.endsWith("\n") ? "" : "\n";
-    writeFileSync13(
+    writeFileSync14(
       gitignorePath,
       `${content}${newline}
 # unerr local artifacts
@@ -43241,7 +43837,7 @@ function ensureGitignore(cwd) {
 
 // src/commands/learn.ts
 init_correction_detector();
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 import { join as join31 } from "path";
 import { gunzipSync as gunzipSync2 } from "zlib";
 import pc3 from "picocolors";
@@ -43258,7 +43854,7 @@ function registerLearnCommand(program2) {
       const cwd = process.cwd();
       const unerrDir = join31(cwd, ".unerr");
       const ledgerPath = join31(unerrDir, "ledger", "shadow.jsonl");
-      if (!existsSync25(ledgerPath)) {
+      if (!existsSync26(ledgerPath)) {
         fail("No shadow ledger found at .unerr/ledger/shadow.jsonl");
         info(
           "The shadow ledger is created when the unerr proxy runs. Start the proxy first."
@@ -43315,20 +43911,20 @@ async function persistPatterns(patterns, _unerrDir) {
   try {
     const cwd = process.cwd();
     const configPath = join31(cwd, ".unerr", "config.json");
-    if (!existsSync25(configPath)) {
+    if (!existsSync26(configPath)) {
       warn(
         "No repo config found \u2014 cannot persist to CozoDB. Run 'unerr' to configure."
       );
       return;
     }
-    const { readFileSync: readFileSync57 } = await import("fs");
-    const config = JSON.parse(readFileSync57(configPath, "utf-8"));
+    const { readFileSync: readFileSync58 } = await import("fs");
+    const config = JSON.parse(readFileSync58(configPath, "utf-8"));
     if (!config.repoId || !config.orgId) {
       warn("Repo not configured \u2014 cannot persist to CozoDB.");
       return;
     }
     const snapshotPath2 = join31(cwd, ".unerr", "snapshots", "graph.msgpack.gz");
-    if (!existsSync25(snapshotPath2)) {
+    if (!existsSync26(snapshotPath2)) {
       warn("No graph snapshot found \u2014 cannot persist to CozoDB.");
       return;
     }
@@ -43340,7 +43936,7 @@ async function persistPatterns(patterns, _unerrDir) {
     const { CozoGraphStore: CozoGraphStore2 } = await Promise.resolve().then(() => (init_local_graph(), local_graph_exports));
     const store = await CozoGraphStore2.create(db);
     const { unpack } = await import("msgpackr");
-    const raw = readFileSync57(snapshotPath2);
+    const raw = readFileSync58(snapshotPath2);
     const buffer = gunzipSync2(raw);
     const envelope = unpack(buffer);
     await store.loadSnapshot(envelope);
@@ -43357,16 +43953,16 @@ async function persistPatterns(patterns, _unerrDir) {
 
 // src/commands/manifest.ts
 init_exec();
-import { existsSync as existsSync26, readFileSync as readFileSync24 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync25 } from "fs";
 import { join as join32 } from "path";
 async function findRepoRoot() {
   return gitQuery(["rev-parse", "--show-toplevel"]);
 }
 function loadManifest(repoRoot) {
   const manifestPath = join32(repoRoot, ".unerr", "manifest.json");
-  if (!existsSync26(manifestPath)) return null;
+  if (!existsSync27(manifestPath)) return null;
   try {
-    const raw = readFileSync24(manifestPath, "utf-8");
+    const raw = readFileSync25(manifestPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -43687,7 +44283,7 @@ function registerStatsCommand(program2) {
 
 // src/commands/status.ts
 init_git();
-import { existsSync as existsSync31, readFileSync as readFileSync29 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync30 } from "fs";
 import { join as join38 } from "path";
 import React from "react";
 function buildSuggestions(data) {
@@ -43736,9 +44332,9 @@ function registerStatusCommand(program2) {
     const localDataDir = join38(cwd, ".unerr");
     let repoId = "";
     const configPath = join38(unerrDir, "config.json");
-    if (existsSync31(configPath)) {
+    if (existsSync32(configPath)) {
       try {
-        const config = JSON.parse(readFileSync29(configPath, "utf-8"));
+        const config = JSON.parse(readFileSync30(configPath, "utf-8"));
         repoId = config.repoId ?? "";
       } catch {
       }
@@ -43767,9 +44363,9 @@ function registerStatusCommand(program2) {
     let proxyStatus = "Not running";
     let proxyRunning = false;
     const pidPath = join38(unerrDir, "state", "proxy.pid");
-    if (existsSync31(pidPath)) {
+    if (existsSync32(pidPath)) {
       try {
-        const pidStr = readFileSync29(pidPath, "utf-8").trim();
+        const pidStr = readFileSync30(pidPath, "utf-8").trim();
         const pid = Number.parseInt(pidStr, 10);
         process.kill(pid, 0);
         proxyStatus = `Running (PID ${pid})`;
@@ -43780,10 +44376,10 @@ function registerStatusCommand(program2) {
     }
     let graphInfo = "No local graph";
     const manifestsDir = join38(localDataDir, "manifests");
-    if (repoId && existsSync31(join38(manifestsDir, `${repoId}.json`))) {
+    if (repoId && existsSync32(join38(manifestsDir, `${repoId}.json`))) {
       try {
         const manifest = JSON.parse(
-          readFileSync29(join38(manifestsDir, `${repoId}.json`), "utf-8")
+          readFileSync30(join38(manifestsDir, `${repoId}.json`), "utf-8")
         );
         const entityCount = manifest.entityCount ?? 0;
         const edgeCount = manifest.edgeCount ?? 0;
@@ -43802,10 +44398,10 @@ function registerStatusCommand(program2) {
     }
     let drift;
     const driftSummaryPath = join38(unerrDir, "drift", "drift_summary.json");
-    if (existsSync31(driftSummaryPath)) {
+    if (existsSync32(driftSummaryPath)) {
       try {
         const summary = JSON.parse(
-          readFileSync29(driftSummaryPath, "utf-8")
+          readFileSync30(driftSummaryPath, "utf-8")
         );
         drift = {
           modified: summary.modified ?? 0,
@@ -43818,9 +44414,9 @@ function registerStatusCommand(program2) {
     let healthGrade;
     let healthScore;
     const graphVersionPath = join38(unerrDir, "state", "graph_version.json");
-    if (existsSync31(graphVersionPath)) {
+    if (existsSync32(graphVersionPath)) {
       try {
-        const gv = JSON.parse(readFileSync29(graphVersionPath, "utf-8"));
+        const gv = JSON.parse(readFileSync30(graphVersionPath, "utf-8"));
         healthGrade = gv.health_grade;
         healthScore = gv.health_score;
       } catch {
@@ -43831,15 +44427,15 @@ function registerStatusCommand(program2) {
       try {
         const snapshotsDir = join38(localDataDir, "snapshots");
         let snapshotPath2 = join38(snapshotsDir, "graph.msgpack.gz");
-        if (!existsSync31(snapshotPath2)) {
+        if (!existsSync32(snapshotPath2)) {
           snapshotPath2 = join38(snapshotsDir, "graph.msgpack");
         }
-        if (existsSync31(snapshotPath2)) {
+        if (existsSync32(snapshotPath2)) {
           const { gunzipSync: gunzipSync3 } = await import("zlib");
           const { unpack } = await import("msgpackr");
           const { default: CozoDbConstructor } = await import("cozo-node");
           const { CozoGraphStore: CozoGraphStore2 } = await Promise.resolve().then(() => (init_local_graph(), local_graph_exports));
-          const raw = readFileSync29(snapshotPath2);
+          const raw = readFileSync30(snapshotPath2);
           let buffer;
           try {
             buffer = gunzipSync3(raw);
@@ -43858,9 +44454,9 @@ function registerStatusCommand(program2) {
     let liveToolCalls;
     let latency;
     const statsPath = join38(unerrDir, "state", "session_stats.json");
-    if (existsSync31(statsPath) && proxyRunning) {
+    if (existsSync32(statsPath) && proxyRunning) {
       try {
-        const liveStats = JSON.parse(readFileSync29(statsPath, "utf-8"));
+        const liveStats = JSON.parse(readFileSync30(statsPath, "utf-8"));
         const localCalls = liveStats.toolCallsLocal ?? 0;
         if (localCalls > 0) {
           liveToolCalls = { local: localCalls };
@@ -43887,8 +44483,8 @@ function registerStatusCommand(program2) {
         "state",
         "firewall_stats.json"
       );
-      if (existsSync31(firewallStatsPath)) {
-        const fs5 = JSON.parse(readFileSync29(firewallStatsPath, "utf-8"));
+      if (existsSync32(firewallStatsPath)) {
+        const fs5 = JSON.parse(readFileSync30(firewallStatsPath, "utf-8"));
         firewallBlocked = fs5.blocked ?? 0;
       }
     } catch {
@@ -43925,9 +44521,9 @@ function registerStatusCommand(program2) {
     }
     let lastIndexed;
     const snapshotMetaPath = join38(unerrDir, "state", "snapshot_meta.json");
-    if (existsSync31(snapshotMetaPath)) {
+    if (existsSync32(snapshotMetaPath)) {
       try {
-        const meta = JSON.parse(readFileSync29(snapshotMetaPath, "utf-8"));
+        const meta = JSON.parse(readFileSync30(snapshotMetaPath, "utf-8"));
         if (meta.indexedAt) {
           const ageMs = Date.now() - new Date(meta.indexedAt).getTime();
           const ageHours = Math.floor(ageMs / 36e5);
@@ -43944,8 +44540,8 @@ function registerStatusCommand(program2) {
     let corrections;
     try {
       const corrPath = join38(unerrDir, "state", "corrections_count.json");
-      if (existsSync31(corrPath)) {
-        const cc = JSON.parse(readFileSync29(corrPath, "utf-8"));
+      if (existsSync32(corrPath)) {
+        const cc = JSON.parse(readFileSync30(corrPath, "utf-8"));
         corrections = cc.count;
       }
     } catch {
@@ -43954,8 +44550,8 @@ function registerStatusCommand(program2) {
     let conventionCount;
     let ruleCount;
     try {
-      if (existsSync31(graphVersionPath)) {
-        const gv = JSON.parse(readFileSync29(graphVersionPath, "utf-8"));
+      if (existsSync32(graphVersionPath)) {
+        const gv = JSON.parse(readFileSync30(graphVersionPath, "utf-8"));
         communityCount = gv.community_count;
         conventionCount = gv.convention_count;
         ruleCount = gv.rule_count;
@@ -43997,8 +44593,8 @@ function registerStatusCommand(program2) {
     let ledgerEntryCount;
     try {
       const ledgerPath = join38(unerrDir, "ledger", "shadow.jsonl");
-      if (existsSync31(ledgerPath)) {
-        const content = readFileSync29(ledgerPath, "utf-8");
+      if (existsSync32(ledgerPath)) {
+        const content = readFileSync30(ledgerPath, "utf-8");
         ledgerEntryCount = content.split("\n").filter((l) => l.trim().length > 0).length;
       }
     } catch {
@@ -44006,7 +44602,7 @@ function registerStatusCommand(program2) {
     let logPath;
     try {
       const logsDir = join38(unerrDir, "logs");
-      if (existsSync31(logsDir)) {
+      if (existsSync32(logsDir)) {
         const { readdirSync: readdirSync15, statSync: statSync12 } = await import("fs");
         const logs = readdirSync15(logsDir).filter((f) => f.startsWith("session-") && f.endsWith(".log")).map((f) => ({
           name: f,
@@ -44037,8 +44633,8 @@ function registerStatusCommand(program2) {
     if (!proxyRunning) {
       try {
         const statsPath2 = join38(unerrDir, "state", "session_stats.json");
-        if (existsSync31(statsPath2)) {
-          const raw = JSON.parse(readFileSync29(statsPath2, "utf-8"));
+        if (existsSync32(statsPath2)) {
+          const raw = JSON.parse(readFileSync30(statsPath2, "utf-8"));
           const totalCalls = raw.toolCallsLocal ?? 0;
           if (totalCalls > 0) {
             const endTime = raw.updatedAt ? new Date(raw.updatedAt) : /* @__PURE__ */ new Date();
@@ -44073,8 +44669,8 @@ function registerStatusCommand(program2) {
     let preBashHookConfigured = false;
     try {
       const sp = join38(cwd, ".claude", "settings.json");
-      if (existsSync31(sp)) {
-        const raw = readFileSync29(sp, "utf8");
+      if (existsSync32(sp)) {
+        const raw = readFileSync30(sp, "utf8");
         preBashHookConfigured = raw.includes("unerr hook pre-bash") || raw.includes('"unerr hook pre-bash"');
       }
     } catch {
@@ -44362,7 +44958,7 @@ function registerTimelineCommand(program2) {
 
 // src/commands/uninstall.ts
 init_agent_registry();
-import { existsSync as existsSync33, readFileSync as readFileSync31, unlinkSync as unlinkSync5, writeFileSync as writeFileSync17 } from "fs";
+import { existsSync as existsSync34, readFileSync as readFileSync32, unlinkSync as unlinkSync5, writeFileSync as writeFileSync18 } from "fs";
 import { join as join40 } from "path";
 init_hook_installer();
 init_mcp_config_writer();
@@ -44507,9 +45103,9 @@ function runUninstallAll(cwd) {
 }
 function removeCursorHooks(cwd) {
   const hooksPath = join40(cwd, ".cursor", "hooks.json");
-  if (!existsSync33(hooksPath)) return false;
+  if (!existsSync34(hooksPath)) return false;
   try {
-    const config = JSON.parse(readFileSync31(hooksPath, "utf-8"));
+    const config = JSON.parse(readFileSync32(hooksPath, "utf-8"));
     if (!Array.isArray(config.hooks)) return false;
     const before = config.hooks.length;
     config.hooks = config.hooks.filter(
@@ -44519,7 +45115,7 @@ function removeCursorHooks(cwd) {
     if (config.hooks.length === 0) {
       unlinkSync5(hooksPath);
     } else {
-      writeFileSync17(hooksPath, `${JSON.stringify(config, null, 2)}
+      writeFileSync18(hooksPath, `${JSON.stringify(config, null, 2)}
 `);
     }
     return true;
@@ -44529,7 +45125,7 @@ function removeCursorHooks(cwd) {
 }
 function removeClineHooks(cwd) {
   const hookPath = join40(cwd, ".clinerules", "hooks", "unerr-pre-tool.sh");
-  if (!existsSync33(hookPath)) return false;
+  if (!existsSync34(hookPath)) return false;
   try {
     unlinkSync5(hookPath);
     return true;
@@ -45084,9 +45680,9 @@ async function detectProjectRoot(cwd) {
 }
 function readLocalConfig(cwd) {
   const configPath = join67(cwd, ".unerr", "config.json");
-  if (!existsSync62(configPath)) return null;
+  if (!existsSync63(configPath)) return null;
   try {
-    return JSON.parse(readFileSync56(configPath, "utf-8"));
+    return JSON.parse(readFileSync57(configPath, "utf-8"));
   } catch {
     return null;
   }
@@ -45161,7 +45757,7 @@ async function mcpBoot(cwd) {
   }
   const stateDir = join67(cwd, ".unerr", "state");
   const sockPath = join67(stateDir, "proxy.sock");
-  if (existsSync62(sockPath)) {
+  if (existsSync63(sockPath)) {
     const { PidLock: PidLock2 } = await Promise.resolve().then(() => (init_pid_lock(), pid_lock_exports));
     const pidLock = new PidLock2(stateDir);
     const probeResult = await pidLock.probe();
@@ -45182,12 +45778,12 @@ async function mcpBoot(cwd) {
     }
   }
   if (!readLocalConfig(cwd)) {
-    const { mkdirSync: mkdirSync39, writeFileSync: writeFileSync36 } = await import("fs");
+    const { mkdirSync: mkdirSync39, writeFileSync: writeFileSync37 } = await import("fs");
     const { createHash: createHash5 } = await import("crypto");
     const repoId = createHash5("sha256").update(cwd).digest("hex").slice(0, 12);
     const unerrDir = join67(cwd, ".unerr");
     mkdirSync39(unerrDir, { recursive: true });
-    writeFileSync36(
+    writeFileSync37(
       join67(unerrDir, "config.json"),
       JSON.stringify(
         { repoId, mode: "local", createdAt: (/* @__PURE__ */ new Date()).toISOString() },