@unerr-ai/unerr 0.0.0-beta.6 → 0.0.0-beta.8

package/dist/cli.js

@@ -749,20 +749,20 @@ async function getParser(language) {
     const parser = new TreeSitter();
     const langFile = `tree-sitter-${language}.wasm`;
     try {
-      const { join: join67 } = await import("path");
-      const { existsSync: existsSync62 } = await import("fs");
+      const { join: join68 } = await import("path");
+      const { existsSync: existsSync63 } = await import("fs");
       const possiblePaths = [
-        join67(
+        join68(
           process.cwd(),
           "node_modules",
           `tree-sitter-${language}`,
           langFile
         ),
-        join67(process.cwd(), "node_modules", "web-tree-sitter", langFile)
+        join68(process.cwd(), "node_modules", "web-tree-sitter", langFile)
       ];
       let wasmPath = null;
       for (const p of possiblePaths) {
-        if (existsSync62(p)) {
+        if (existsSync63(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,
@@ -1670,6 +1683,7 @@ async function initSchema(db) {
       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,
@@ -2339,14 +2353,15 @@ var init_local_graph = __esm({
       async loadSnapshot(envelope) {
         for (const entity of envelope.entities) {
           await this.write(
-            `?[key, kind, name, file_path, start_line, signature, body, fan_in, fan_out, risk_level] <- [[$key, $kind, $name, $fp, $sl, $sig, $body, $fi, $fo, $rl]]
-         :put entities { key => kind, name, file_path, start_line, signature, body, fan_in, fan_out, risk_level }`,
+            `?[key, kind, name, file_path, start_line, end_line, signature, body, fan_in, fan_out, risk_level] <- [[$key, $kind, $name, $fp, $sl, $el, $sig, $body, $fi, $fo, $rl]]
+         :put entities { key => kind, name, file_path, start_line, end_line, signature, body, fan_in, fan_out, risk_level }`,
             {
               key: entity.key,
               kind: entity.kind,
               name: entity.name,
               fp: entity.file_path,
               sl: entity.start_line ?? 0,
+              el: entity.end_line ?? 0,
               sig: entity.signature ?? "",
               body: entity.body ?? "",
               fi: entity.fan_in ?? 0,
@@ -2454,17 +2469,18 @@ var init_local_graph = __esm({
        */
       async getEntity(key) {
         const result = await this.query(
-          "?[key, kind, name, fp, sl, sig, body, fi, fo, rl, community] := *entities{key, kind, name, file_path: fp, start_line: sl, signature: sig, body, fan_in: fi, fan_out: fo, risk_level: rl, community}, key = $key",
+          "?[key, kind, name, fp, sl, el, sig, body, fi, fo, rl, community] := *entities{key, kind, name, file_path: fp, start_line: sl, end_line: el, signature: sig, body, fan_in: fi, fan_out: fo, risk_level: rl, community}, key = $key",
           { key }
         );
         if (result.rows.length === 0) return null;
-        const [k, kind, name, fp, sl, sig, body, fi, fo, rl, community] = result.rows[0];
+        const [k, kind, name, fp, sl, el, sig, body, fi, fo, rl, community] = result.rows[0];
         return {
           key: k,
           kind,
           name,
           file_path: fp,
           start_line: sl,
+          end_line: el,
           signature: sig,
           body,
           fan_in: fi,
@@ -2507,6 +2523,7 @@ var init_local_graph = __esm({
             name,
             file_path: fp,
             start_line: sl,
+            end_line: 0,
             signature: sig,
             body,
             fan_in: fi,
@@ -2550,6 +2567,7 @@ var init_local_graph = __esm({
             name,
             file_path: fp,
             start_line: sl,
+            end_line: 0,
             signature: sig,
             body,
             fan_in: fi,
@@ -2904,14 +2922,14 @@ var init_local_graph = __esm({
        * Degree ranking excluding kind=="file" and kind=="module".
        */
       async getCriticalNodes(topN = 10, communityId) {
-        const query = communityId !== void 0 ? `?[key, name, fp, fi, fo, degree, community, label, rl] :=
+        const query = communityId !== void 0 ? `?[key, name, fp, fi, fo, degree, community, label, rl, kind] :=
             *entities{key, name, file_path: fp, fan_in: fi, fan_out: fo, community, risk_level: rl, kind},
             kind != "file", kind != "module",
             community = $cid, community >= 0,
             *communities{id: community, label},
             degree = fi + fo
            :order -degree
-           :limit $top_n` : `?[key, name, fp, fi, fo, degree, community, label, rl] :=
+           :limit $top_n` : `?[key, name, fp, fi, fo, degree, community, label, rl, kind] :=
             *entities{key, name, file_path: fp, fan_in: fi, fan_out: fo, community, risk_level: rl, kind},
             kind != "file", kind != "module",
             community >= 0,
@@ -2923,11 +2941,12 @@ var init_local_graph = __esm({
         if (communityId !== void 0) params.cid = communityId;
         const result = await this.query(query, params);
         return result.rows.map((row) => {
-          const [key, name, fp, fi, fo, degree, community, label, rl] = row;
+          const [key, name, fp, fi, fo, degree, community, label, rl, kind] = row;
           return {
             key,
             name,
             file_path: fp,
+            kind,
             fan_in: fi,
             fan_out: fo,
             degree,
@@ -2954,19 +2973,20 @@ var init_local_graph = __esm({
        */
       async getEntitiesByFile(filePath) {
         const result = await this.query(
-          `?[k, kind, name, fp, sl, sig, body, fi, fo, rl, community] := *file_index[$fp, ek],
-        *entities{key: ek, kind, name, file_path: fp, start_line: sl, signature: sig, body, fan_in: fi, fan_out: fo, risk_level: rl, community},
+          `?[k, kind, name, fp, sl, el, sig, body, fi, fo, rl, community] := *file_index[$fp, ek],
+        *entities{key: ek, kind, name, file_path: fp, start_line: sl, end_line: el, signature: sig, body, fan_in: fi, fan_out: fo, risk_level: rl, community},
         k = ek`,
           { fp: filePath }
         );
         return result.rows.map((row) => {
-          const [k, kind, name, fp, sl, sig, body, fi, fo, rl, community] = row;
+          const [k, kind, name, fp, sl, el, sig, body, fi, fo, rl, community] = row;
           return {
             key: k,
             kind,
             name,
             file_path: fp,
             start_line: sl,
+            end_line: el,
             signature: sig,
             body,
             fan_in: fi,
@@ -2982,17 +3002,18 @@ var init_local_graph = __esm({
        */
       async findEntityByName(name) {
         const result = await this.query(
-          "?[k, kind, name, fp, sl, sig, body, fi, fo, rl, community] := *entities{key: k, kind, name, file_path: fp, start_line: sl, signature: sig, body, fan_in: fi, fan_out: fo, risk_level: rl, community}, name = $name :limit 1",
+          "?[k, kind, name, fp, sl, el, sig, body, fi, fo, rl, community] := *entities{key: k, kind, name, file_path: fp, start_line: sl, end_line: el, signature: sig, body, fan_in: fi, fan_out: fo, risk_level: rl, community}, name = $name :limit 1",
           { name }
         );
         if (result.rows.length === 0) return null;
-        const [k, kind, n, fp, sl, sig, body, fi, fo, rl, community] = result.rows[0];
+        const [k, kind, n, fp, sl, el, sig, body, fi, fo, rl, community] = result.rows[0];
         return {
           key: k,
           kind,
           name: n,
           file_path: fp,
           start_line: sl,
+          end_line: el,
           signature: sig,
           body,
           fan_in: fi,
@@ -3704,14 +3725,15 @@ var init_local_graph = __esm({
         const allEntities = [...delta.entities.added, ...delta.entities.updated];
         for (const entity of allEntities) {
           await this.write(
-            `?[key, kind, name, file_path, start_line, signature, body, fan_in, fan_out, risk_level] <- [[$key, $kind, $name, $fp, $sl, $sig, $body, $fi, $fo, $rl]]
-         :put entities { key => kind, name, file_path, start_line, signature, body, fan_in, fan_out, risk_level }`,
+            `?[key, kind, name, file_path, start_line, end_line, signature, body, fan_in, fan_out, risk_level] <- [[$key, $kind, $name, $fp, $sl, $el, $sig, $body, $fi, $fo, $rl]]
+         :put entities { key => kind, name, file_path, start_line, end_line, signature, body, fan_in, fan_out, risk_level }`,
             {
               key: entity.key,
               kind: entity.kind,
               name: entity.name,
               fp: entity.file_path,
               sl: entity.start_line ?? 0,
+              el: entity.end_line ?? 0,
               sig: entity.signature ?? "",
               body: entity.body ?? "",
               fi: entity.fan_in ?? 0,
@@ -4578,7 +4600,9 @@ function normalizeAgentName(input) {
     code: "vscode",
     vs: "vscode",
     google: "antigravity",
-    "google-antigravity": "antigravity"
+    "google-antigravity": "antigravity",
+    windsurf: "windsurf",
+    cascade: "windsurf"
   };
   return aliases[input.toLowerCase()] ?? input.toLowerCase();
 }
@@ -4626,14 +4650,15 @@ var init_agent_registry = __esm({
       {
         id: "windsurf",
         name: "Windsurf",
-        projectConfigPath: ".windsurf/mcp.json",
+        projectConfigPath: ".codeium/windsurf/mcp_config.json",
+        configScope: "global",
         configFormat: "mcp-json",
         dirMarkers: [".windsurf"],
-        envVars: [],
-        hookSupport: false,
-        description: "Codeium's AI IDE",
-        instructionFilePath: null,
-        instructionFormat: null
+        envVars: ["WINDSURF_EDITOR"],
+        hookSupport: true,
+        description: "Codeium's AI IDE (Cascade)",
+        instructionFilePath: ".windsurf/rules/unerr-instructions.md",
+        instructionFormat: "windsurf-rule"
       },
       {
         id: "zed",
@@ -4677,8 +4702,8 @@ var init_agent_registry = __esm({
         projectConfigPath: ".gemini/settings.json",
         configFormat: "settings-json",
         dirMarkers: [".gemini"],
-        envVars: ["GEMINI_API_KEY"],
-        hookSupport: false,
+        envVars: ["GEMINI_API_KEY", "GEMINI_CLI"],
+        hookSupport: true,
         description: "Google's CLI coding agent",
         instructionFilePath: "GEMINI.md",
         instructionFormat: "markdown"
@@ -4746,11 +4771,11 @@ var init_agent_registry = __esm({
       {
         id: "github-copilot-cli",
         name: "GitHub Copilot CLI",
-        projectConfigPath: ".github/mcp.json",
-        configFormat: "mcp-json",
-        dirMarkers: [".github"],
+        projectConfigPath: ".copilot/mcp-config.json",
+        configFormat: "copilot-json",
+        dirMarkers: [".github", ".copilot"],
         envVars: ["GITHUB_COPILOT_TOKEN"],
-        hookSupport: false,
+        hookSupport: true,
         description: "GitHub's CLI AI assistant",
         instructionFilePath: ".github/copilot-instructions.md",
         instructionFormat: "markdown"
@@ -4794,6 +4819,7 @@ __export(mcp_config_writer_exports, {
   writeMcpConfig: () => writeMcpConfig
 });
 import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
 import { dirname as dirname2, join as join7 } from "path";
 function createUnerrServerEntry() {
   return {
@@ -4802,12 +4828,19 @@ function createUnerrServerEntry() {
     args: ["--mcp"]
   };
 }
+function createCopilotServerEntry() {
+  return {
+    type: "local",
+    command: "unerr",
+    args: ["--mcp"]
+  };
+}
 function writeMcpConfig(cwd, ide) {
   const agent = getAgent(ide);
   if (!agent) {
     return { path: "", action: "skipped" };
   }
-  const configPath = join7(cwd, agent.projectConfigPath);
+  const configPath = agent.configScope === "global" ? join7(homedir(), agent.projectConfigPath) : join7(cwd, agent.projectConfigPath);
   const dir = dirname2(configPath);
   if (!existsSync5(dir)) {
     mkdirSync3(dir, { recursive: true });
@@ -4817,6 +4850,8 @@ function writeMcpConfig(cwd, ide) {
       return writeMcpJsonFormat(configPath);
     case "settings-json":
       return writeSettingsJsonFormat(configPath);
+    case "copilot-json":
+      return writeCopilotJsonFormat(configPath);
     case "continue-config":
       return writeContinueFormat(configPath);
     default:
@@ -4832,7 +4867,7 @@ function writeAllMcpConfigs(cwd, agents) {
 function removeMcpConfig(cwd, ide) {
   const agent = getAgent(ide);
   if (!agent) return false;
-  const configPath = join7(cwd, agent.projectConfigPath);
+  const configPath = agent.configScope === "global" ? join7(homedir(), agent.projectConfigPath) : join7(cwd, agent.projectConfigPath);
   if (!existsSync5(configPath)) return false;
   try {
     const existing = JSON.parse(readFileSync6(configPath, "utf-8"));
@@ -4844,6 +4879,9 @@ function removeMcpConfig(cwd, ide) {
     } else if (agent.configFormat === "settings-json") {
       if (!existing.mcp?.servers?.[UNERR_SERVER_KEY]) return false;
       delete existing.mcp.servers[UNERR_SERVER_KEY];
+    } else if (agent.configFormat === "copilot-json") {
+      if (!existing.mcpServers?.[UNERR_SERVER_KEY]) return false;
+      delete existing.mcpServers[UNERR_SERVER_KEY];
     } else {
       if (!existing.mcpServers?.[UNERR_SERVER_KEY]) return false;
       delete existing.mcpServers[UNERR_SERVER_KEY];
@@ -4857,7 +4895,7 @@ function removeMcpConfig(cwd, ide) {
 function isConfigured(cwd, ide) {
   const agent = getAgent(ide);
   if (!agent) return false;
-  const configPath = join7(cwd, agent.projectConfigPath);
+  const configPath = agent.configScope === "global" ? join7(homedir(), agent.projectConfigPath) : join7(cwd, agent.projectConfigPath);
   if (!existsSync5(configPath)) return false;
   try {
     const existing = JSON.parse(readFileSync6(configPath, "utf-8"));
@@ -4869,6 +4907,9 @@ function isConfigured(cwd, ide) {
     if (agent.configFormat === "settings-json") {
       return !!existing.mcp?.servers?.[UNERR_SERVER_KEY];
     }
+    if (agent.configFormat === "copilot-json") {
+      return !!existing.mcpServers?.[UNERR_SERVER_KEY];
+    }
     return !!existing.mcpServers?.[UNERR_SERVER_KEY];
   } catch {
     return false;
@@ -4885,6 +4926,14 @@ function generateConfigSnippet(ide) {
         null,
         2
       );
+    case "copilot-json": {
+      const copilotEntry = createCopilotServerEntry();
+      return JSON.stringify(
+        { mcpServers: { [UNERR_SERVER_KEY]: copilotEntry } },
+        null,
+        2
+      );
+    }
     case "continue-config":
       return JSON.stringify(
         { mcpServers: [{ name: UNERR_SERVER_KEY, ...entry }] },
@@ -4975,6 +5024,29 @@ function writeContinueFormat(configPath) {
   writeFileSync2(configPath, JSON.stringify(config, null, 2), "utf-8");
   return { path: configPath, action: "created" };
 }
+function writeCopilotJsonFormat(configPath) {
+  if (existsSync5(configPath)) {
+    try {
+      const existing = JSON.parse(
+        readFileSync6(configPath, "utf-8")
+      );
+      if (existing.mcpServers?.[UNERR_SERVER_KEY]) {
+        return { path: configPath, action: "skipped" };
+      }
+      existing.mcpServers = existing.mcpServers ?? {};
+      existing.mcpServers[UNERR_SERVER_KEY] = createCopilotServerEntry();
+      writeFileSync2(configPath, JSON.stringify(existing, null, 2), "utf-8");
+      return { path: configPath, action: "updated" };
+    } catch {
+      return { path: configPath, action: "skipped" };
+    }
+  }
+  const config = {
+    mcpServers: { [UNERR_SERVER_KEY]: createCopilotServerEntry() }
+  };
+  writeFileSync2(configPath, JSON.stringify(config, null, 2), "utf-8");
+  return { path: configPath, action: "created" };
+}
 var UNERR_SERVER_KEY;
 var init_mcp_config_writer = __esm({
   "src/config/mcp-config-writer.ts"() {
@@ -5375,7 +5447,7 @@ __export(settings_exports, {
   resolveInferenceEndpoint: () => resolveInferenceEndpoint
 });
 import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 import { join as join12 } from "path";
 import { z } from "zod";
 function resolveEmbeddingEndpoint(config) {
@@ -5406,7 +5478,7 @@ function loadJsonFile(filePath) {
 }
 function loadSettings(cwd) {
   const projectDir = cwd ?? process.cwd();
-  const userSettings = loadJsonFile(join12(homedir3(), ".unerr", "settings.json"));
+  const userSettings = loadJsonFile(join12(homedir4(), ".unerr", "settings.json"));
   const projectSettings = loadJsonFile(
     join12(projectDir, ".unerr", "settings.json")
   );
@@ -6562,6 +6634,7 @@ __export(ast_extractor_exports, {
 import { createHash } from "crypto";
 import { existsSync as existsSync14 } from "fs";
 import { join as join19 } from "path";
+import { fileURLToPath } from "url";
 function detectLanguage2(filePath) {
   const dot = filePath.lastIndexOf(".");
   if (dot < 0) return null;
@@ -6574,13 +6647,18 @@ function extractEntities(content, filePath) {
   const lines = content.split("\n");
   const entities = [];
   const patterns = getPatterns(language);
+  let currentClassName = null;
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i] ?? "";
     for (const pattern of patterns) {
       const match = pattern.regex.exec(line);
       if (match) {
-        const name = match[pattern.nameGroup] ?? "";
-        if (!name || name.length === 0) continue;
+        const rawName = match[pattern.nameGroup] ?? "";
+        if (!rawName || rawName.length === 0) continue;
+        if (pattern.kind === "class") {
+          currentClassName = rawName;
+        }
+        const name = pattern.kind === "method" && currentClassName ? `${currentClassName}.${rawName}` : rawName;
         const signature = match[pattern.sigGroup ?? 0] ?? "";
         const lineStart = i + 1;
         const lineEnd = findBlockEnd(lines, i, language);
@@ -6593,7 +6671,8 @@ function extractEntities(content, filePath) {
           signature: signature.trim(),
           line_start: lineStart,
           line_end: lineEnd,
-          content_hash: contentHash
+          content_hash: contentHash,
+          parent_class: pattern.kind === "method" ? currentClassName ?? void 0 : void 0
         });
         break;
       }
@@ -6625,9 +6704,9 @@ function getPatterns(language) {
           kind: "interface",
           nameGroup: 1
         },
-        // method(params) { — inside class
+        // method(params) { — inside class (with optional access modifiers)
         {
-          regex: /^\s+(?:async\s+)?(?:static\s+)?(?:get\s+|set\s+)?(\w+)\s*(\([^)]*\))\s*(?::\s*\S+\s*)?[{]/,
+          regex: /^\s+(?:(?:private|protected|public|override|abstract|readonly)\s+)*(?:async\s+)?(?:static\s+)?(?:get\s+|set\s+)?(\w+)\s*(\([^)]*\))\s*(?::\s*\S+\s*)?[{]/,
           kind: "method",
           nameGroup: 1,
           sigGroup: 2
@@ -6949,10 +7028,16 @@ async function getTSParser(grammar) {
     }
     const parser = new TreeSitter();
     const wasmFile = `tree-sitter-${grammar}.wasm`;
+    const pkgDir = import.meta.dirname ?? join19(fileURLToPath(import.meta.url), "..");
+    const pkgRoot = join19(pkgDir, "..");
     const possiblePaths = [
       join19(process.cwd(), "node_modules", "tree-sitter-wasms", "out", wasmFile),
       join19(process.cwd(), "node_modules", `tree-sitter-${grammar}`, wasmFile),
-      join19(process.cwd(), "node_modules", "web-tree-sitter", wasmFile)
+      join19(process.cwd(), "node_modules", "web-tree-sitter", wasmFile),
+      // Package-relative paths (when unerr is installed globally or in another project)
+      join19(pkgRoot, "node_modules", "tree-sitter-wasms", "out", wasmFile),
+      join19(pkgRoot, "node_modules", `tree-sitter-${grammar}`, wasmFile),
+      join19(pkgRoot, "node_modules", "web-tree-sitter", wasmFile)
     ];
     let wasmPath = null;
     for (const p of possiblePaths) {
@@ -9009,12 +9094,12 @@ var init_decoder = __esm({
 // src/intelligence/indexer/scip/downloader.ts
 import { chmodSync as chmodSync2, createWriteStream, existsSync as existsSync15, mkdirSync as mkdirSync11 } from "fs";
 import { rename, rm, stat } from "fs/promises";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir5 } from "os";
 import { join as join20 } from "path";
 import { pipeline } from "stream/promises";
 import { createGunzip } from "zlib";
 function getScipBinDir() {
-  return join20(homedir4(), ".unerr", "bin");
+  return join20(homedir5(), ".unerr", "bin");
 }
 function getCachedBinaryPath(language) {
   const spec = DOWNLOAD_SPECS[language];
@@ -9366,7 +9451,7 @@ async function detectScipBinary(language) {
     path: null
   };
 }
-function detectPrimaryLanguage(files) {
+function detectProjectLanguages(files) {
   const counts = {};
   for (const file of files) {
     const dotIdx = file.lastIndexOf(".");
@@ -9377,15 +9462,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({
@@ -9609,77 +9686,94 @@ var init_runner = __esm({
 // src/intelligence/indexer/scip/orchestrator.ts
 import { join as join23 } from "path";
 async function enrichWithScip(files, projectRoot, existingEdges, entities) {
-  const language = detectPrimaryLanguage(files);
-  if (!language) {
+  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 && 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;
+    const runResult = await runScipIndexer({
+      language,
+      binaryPath,
+      projectRoot,
+      outputDir,
+      timeoutMs: 3e4
+    });
+    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
   };
@@ -9720,6 +9814,10 @@ var init_orchestrator = __esm({
 });
 
 // src/intelligence/local-convention-detector.ts
+var local_convention_detector_exports = {};
+__export(local_convention_detector_exports, {
+  detectLocalConventions: () => detectLocalConventions
+});
 import { dirname as dirname4 } from "path";
 async function detectLocalConventions(db) {
   const start = Date.now();
@@ -10281,6 +10379,7 @@ async function indexLocalProject(projectRoot, graphStore, repoId, opts) {
         name: entity.name,
         file_path: relPath,
         start_line: entity.line_start,
+        end_line: entity.line_end,
         signature: entity.signature,
         body: "",
         // Skip body storage for indexing performance
@@ -10444,6 +10543,7 @@ async function reindexFile(projectRoot, filePath, graphStore, repoId) {
     name: e.name,
     file_path: relPath,
     start_line: e.line_start,
+    end_line: e.line_end,
     signature: e.signature,
     body: "",
     fan_in: 0,
@@ -10860,12 +10960,13 @@ async function populateCozoDB(graphStore, entities, edges) {
   for (const fp of filePaths) {
     try {
       await graphStore.db.run(
-        `?[key, kind, name, file_path, start_line, signature, body, fan_in, fan_out, risk_level, is_test] <- [[$key, "module", $name, $fp, 0, "", "", 0, 0, "normal", $is_test]]
-         :put entities { key => kind, name, file_path, start_line, signature, body, fan_in, fan_out, risk_level, is_test }`,
+        `?[key, kind, name, file_path, start_line, end_line, signature, body, fan_in, fan_out, risk_level, is_test] <- [[$key, "module", $name, $fp, 0, 0, "", "", 0, 0, "normal", $is_test]]
+         :put entities { key => kind, name, file_path, start_line, end_line, signature, body, fan_in, fan_out, risk_level, is_test }`,
         { 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}
 `);
     }
   }
@@ -10909,14 +11010,15 @@ async function populateCozoDB(graphStore, entities, edges) {
 async function insertEntity(graphStore, entity) {
   try {
     await graphStore.db.run(
-      `?[key, kind, name, file_path, start_line, signature, body, fan_in, fan_out, risk_level, is_test] <- [[$key, $kind, $name, $fp, $sl, $sig, $body, $fi, $fo, $rl, $is_test]]
-       :put entities { key => kind, name, file_path, start_line, signature, body, fan_in, fan_out, risk_level, is_test }`,
+      `?[key, kind, name, file_path, start_line, end_line, signature, body, fan_in, fan_out, risk_level, is_test] <- [[$key, $kind, $name, $fp, $sl, $el, $sig, $body, $fi, $fo, $rl, $is_test]]
+       :put entities { key => kind, name, file_path, start_line, end_line, signature, body, fan_in, fan_out, risk_level, is_test }`,
       {
         key: entity.key,
         kind: entity.kind,
         name: entity.name,
         fp: entity.file_path,
         sl: entity.start_line ?? 0,
+        el: entity.end_line ?? 0,
         sig: entity.signature ?? "",
         body: entity.body ?? "",
         fi: entity.fan_in ?? 0,
@@ -11737,7 +11839,7 @@ import {
   unlinkSync as unlinkSync4,
   writeFileSync as writeFileSync12
 } from "fs";
-import { homedir as homedir5 } from "os";
+import { homedir as homedir6 } from "os";
 import { dirname as dirname6, join as join29 } from "path";
 function getSkillDir(ide, cwd) {
   switch (ide) {
@@ -11761,9 +11863,9 @@ function getSkillDir(ide, cwd) {
       };
     case "windsurf":
       return {
-        dir: join29(cwd, ".windsurf", "rules"),
+        dir: join29(cwd, ".windsurf", "skills"),
         ext: ".md",
-        dirPerSkill: false
+        dirPerSkill: true
       };
     case "zed":
       return {
@@ -11771,6 +11873,18 @@ function getSkillDir(ide, cwd) {
         ext: ".md",
         dirPerSkill: false
       };
+    case "gemini-cli":
+      return {
+        dir: join29(cwd, ".gemini", "skills"),
+        ext: ".md",
+        dirPerSkill: true
+      };
+    case "github-copilot-cli":
+      return {
+        dir: join29(cwd, ".github", "skills"),
+        ext: ".md",
+        dirPerSkill: true
+      };
     case "antigravity":
       return {
         dir: join29(cwd, ".agents", "skills"),
@@ -11791,7 +11905,22 @@ function writeSkillFile(skill, ide, skillDir, ext, dirPerSkill) {
   const skillName = `unerr-${baseName}`;
   let filePath;
   let content;
-  if (dirPerSkill && ide === "antigravity") {
+  if (dirPerSkill && ide === "windsurf") {
+    const skillSubDir = join29(skillDir, skillName);
+    mkdirSync16(skillSubDir, { recursive: true });
+    filePath = join29(skillSubDir, "SKILL.md");
+    content = formatWindsurfSkillMd(skill);
+  } else if (dirPerSkill && ide === "gemini-cli") {
+    const skillSubDir = join29(skillDir, skillName);
+    mkdirSync16(skillSubDir, { recursive: true });
+    filePath = join29(skillSubDir, "SKILL.md");
+    content = formatGeminiSkill(skill);
+  } else if (dirPerSkill && ide === "github-copilot-cli") {
+    const skillSubDir = join29(skillDir, skillName);
+    mkdirSync16(skillSubDir, { recursive: true });
+    filePath = join29(skillSubDir, "SKILL.md");
+    content = formatCopilotSkill(skill);
+  } else if (dirPerSkill && ide === "antigravity") {
     const skillSubDir = join29(skillDir, skillName);
     mkdirSync16(skillSubDir, { recursive: true });
     filePath = join29(skillSubDir, "SKILL.md");
@@ -11804,9 +11933,6 @@ function writeSkillFile(skill, ide, skillDir, ext, dirPerSkill) {
   } else if (ide === "cursor" && ext === ".mdc") {
     filePath = join29(skillDir, `${skillName}${ext}`);
     content = formatCursorSkill(skill);
-  } else if (ide === "windsurf") {
-    filePath = join29(skillDir, `${skillName}${ext}`);
-    content = formatWindsurfSkill(skill);
   } else {
     filePath = join29(skillDir, `${skillName}${ext}`);
     content = formatMarkdownSkill(skill);
@@ -11888,53 +12014,45 @@ alwaysApply: ${alwaysApply}
 ${skill.content}
 `;
 }
-function formatWindsurfSkill(skill) {
+function formatMarkdownSkill(skill) {
   const trigger = skill.trigger;
   const triggerType = trigger?.type ?? "always";
-  let wsType;
-  switch (triggerType) {
-    case "always":
-      wsType = "always_on";
-      break;
-    case "auto":
-      wsType = "glob";
-      break;
-    case "agent-requested":
-      wsType = "model_decision";
-      break;
-    case "manual":
-      wsType = "manual";
-      break;
-    default:
-      wsType = "always_on";
-  }
   const globLine = trigger?.globs && trigger.globs.length > 0 ? `
 globs: ${JSON.stringify(trigger.globs)}` : "";
-  const truncatedContent = skill.content.length > 5800 ? `${skill.content.slice(0, 5800)}
-
-[Truncated \u2014 full content exceeds Windsurf 6K limit]` : skill.content;
   return `---
-trigger: ${wsType}${globLine}
 description: "${skill.description}"
+trigger: ${triggerType}${globLine}
+version: "${skill.version ?? "1.0.0"}"
 ---
 
 # ${skill.name}
 
-${truncatedContent}
+${skill.content}
 `;
 }
-function formatMarkdownSkill(skill) {
-  const trigger = skill.trigger;
-  const triggerType = trigger?.type ?? "always";
-  const globLine = trigger?.globs && trigger.globs.length > 0 ? `
-globs: ${JSON.stringify(trigger.globs)}` : "";
+function formatWindsurfSkillMd(skill) {
   return `---
-description: "${skill.description}"
-trigger: ${triggerType}${globLine}
-version: "${skill.version ?? "1.0.0"}"
+name: ${skill.name}
+description: ${skill.description}
 ---
 
-# ${skill.name}
+${skill.content}
+`;
+}
+function formatGeminiSkill(skill) {
+  return `---
+name: ${skill.name}
+description: ${skill.description}
+---
+
+${skill.content}
+`;
+}
+function formatCopilotSkill(skill) {
+  return `---
+name: ${skill.name}
+description: ${skill.description}
+---
 
 ${skill.content}
 `;
@@ -12020,7 +12138,7 @@ function scanSkillDirectory(dir) {
   return skills;
 }
 function loadLocalDirectorySkills(cwd) {
-  const userDir = join29(homedir5(), ".unerr", "skills");
+  const userDir = join29(homedir6(), ".unerr", "skills");
   const projectDir = join29(cwd, ".unerr", "skills");
   const userSkills = scanSkillDirectory(userDir);
   const projectSkills = scanSkillDirectory(projectDir);
@@ -13085,9 +13203,9 @@ function createEmptyAllTime() {
 function loadStats() {
   const currentWeek = getWeekStart();
   try {
-    const { readFileSync: readFileSync56 } = __require("fs");
+    const { readFileSync: readFileSync57 } = __require("fs");
     const raw = JSON.parse(
-      readFileSync56(getStatsPath(), "utf-8")
+      readFileSync57(getStatsPath(), "utf-8")
     );
     if (raw.version !== 1) {
       return {
@@ -13800,9 +13918,9 @@ function getCumulativePath() {
 function loadCumulativeStats() {
   const currentWeek = getWeekStart2();
   try {
-    const { readFileSync: readFileSync56 } = __require("fs");
+    const { readFileSync: readFileSync57 } = __require("fs");
     const raw = JSON.parse(
-      readFileSync56(getCumulativePath(), "utf-8")
+      readFileSync57(getCumulativePath(), "utf-8")
     );
     if (raw.weekStart !== currentWeek) {
       return {
@@ -13863,9 +13981,9 @@ function createEmptyCumulativeLocal(weekStart) {
 function loadCumulativeLocalStats() {
   const currentWeek = getWeekStart2();
   try {
-    const { readFileSync: readFileSync56 } = __require("fs");
+    const { readFileSync: readFileSync57 } = __require("fs");
     const raw = JSON.parse(
-      readFileSync56(getCumulativeLocalPath(), "utf-8")
+      readFileSync57(getCumulativeLocalPath(), "utf-8")
     );
     if (raw.weekStartDate !== currentWeek) {
       return createEmptyCumulativeLocal(currentWeek);
@@ -16521,6 +16639,250 @@ var init_record_fact = __esm({
   }
 });
 
+// src/intelligence/fact-generator.ts
+var fact_generator_exports = {};
+__export(fact_generator_exports, {
+  generateFromCausalBridge: () => generateFromCausalBridge,
+  generateFromConventions: () => generateFromConventions,
+  generateFromNegativeKnowledge: () => generateFromNegativeKnowledge,
+  generateFromSessionAnalysis: () => generateFromSessionAnalysis,
+  runFactGenerationPipeline: () => runFactGenerationPipeline
+});
+import { existsSync as existsSync37, readdirSync as readdirSync9, readFileSync as readFileSync34 } from "fs";
+import { join as join44 } from "path";
+async function runFactGenerationPipeline(factStore2, unerrDir) {
+  const results = [];
+  try {
+    const sessionResult = await generateFromSessionAnalysis(factStore2, unerrDir);
+    if (sessionResult) results.push(sessionResult);
+  } catch {
+  }
+  return results;
+}
+async function generateFromConventions(factStore2, conventions) {
+  let created = 0;
+  let reinforced = 0;
+  const details = [];
+  const MIN_CONFIDENCE = 0.7;
+  const MIN_FREQUENCY = 5;
+  for (const conv of conventions) {
+    if (conv.confidence < MIN_CONFIDENCE) continue;
+    if (conv.frequency < MIN_FREQUENCY) continue;
+    const content = formatConventionFact(conv);
+    if (content.length > 280) continue;
+    const input = {
+      fact_type: "semantic",
+      scope: inferScopeFromConvention(conv),
+      subject: conv.name,
+      content,
+      source: "convention_detector",
+      base_confidence: Math.min(0.9, conv.confidence)
+    };
+    const factId = await factStore2.createFact(input);
+    if (factId) {
+      const isNew = !details.some((d) => d.includes(conv.name));
+      if (isNew) {
+        created++;
+        details.push(`[convention] ${conv.name}: ${content.slice(0, 80)}`);
+      } else {
+        reinforced++;
+      }
+    }
+  }
+  return { created, reinforced, source: "convention_detector", details };
+}
+async function generateFromNegativeKnowledge(factStore2, corrections) {
+  let created = 0;
+  let reinforced = 0;
+  const details = [];
+  for (const correction of corrections) {
+    const content = correction.reason.slice(0, 280);
+    const input = {
+      fact_type: "negative",
+      scope: correction.entityKey,
+      subject: correction.entityKey,
+      content,
+      source: "negative_knowledge",
+      base_confidence: 0.9
+    };
+    const factId = await factStore2.createFact(input);
+    if (factId) {
+      created++;
+      details.push(`[negative] ${correction.entityKey}: ${content.slice(0, 60)}`);
+    }
+  }
+  return { created, reinforced, source: "negative_knowledge", details };
+}
+async function generateFromCausalBridge(factStore2, events) {
+  let created = 0;
+  let reinforced = 0;
+  const details = [];
+  for (const event of events) {
+    if (event.action === "survived") {
+      const content = `Change to ${event.entity_key} on ${new Date(event.timestamp).toISOString().split("T")[0]} survived \u2014 shipped to ${event.branch}`;
+      const input = {
+        fact_type: "episodic",
+        scope: event.entity_key,
+        subject: event.entity_key,
+        content: content.slice(0, 280),
+        source: "causal_bridge",
+        base_confidence: 1
+      };
+      const factId = await factStore2.createFact(input);
+      if (factId) {
+        created++;
+        details.push(`[episodic:survived] ${event.entity_key}`);
+      }
+    } else if (event.action === "reverted") {
+      const content = `Change to ${event.entity_key} was reverted within 24h \u2014 approach was incorrect`;
+      const input = {
+        fact_type: "negative",
+        scope: event.entity_key,
+        subject: event.entity_key,
+        content: content.slice(0, 280),
+        source: "causal_bridge",
+        base_confidence: 0.85
+      };
+      const factId = await factStore2.createFact(input);
+      if (factId) {
+        created++;
+        details.push(`[negative:reverted] ${event.entity_key}`);
+      }
+    }
+  }
+  return { created, reinforced, source: "causal_bridge", details };
+}
+async function generateFromSessionAnalysis(factStore2, unerrDir) {
+  let created = 0;
+  let reinforced = 0;
+  const details = [];
+  const summaries = loadRecentSessions(unerrDir, 20);
+  if (summaries.length < 3) {
+    return { created: 0, reinforced: 0, source: "session_analysis", details: [] };
+  }
+  const hotFiles = detectHotFiles(summaries);
+  for (const [file, frequency] of hotFiles) {
+    const pct = Math.round(frequency * 100);
+    const content = `${file} is accessed in ${pct}% of sessions (hot file)`;
+    const confidence = Math.min(0.85, 0.4 + frequency * 0.5);
+    const input = {
+      fact_type: "procedural",
+      scope: file,
+      subject: file,
+      content,
+      source: "session_analysis",
+      base_confidence: confidence
+    };
+    const factId = await factStore2.createFact(input);
+    if (factId) {
+      created++;
+      details.push(`[procedural:hot] ${file} (${pct}%)`);
+    }
+  }
+  const highRevertFiles = detectHighRevertFiles(summaries);
+  for (const [file, revertRate] of highRevertFiles) {
+    const pct = Math.round(revertRate * 100);
+    const content = `${file} has a ${pct}% revert rate across sessions \u2014 changes here are fragile`;
+    const input = {
+      fact_type: "negative",
+      scope: file,
+      subject: file,
+      content: content.slice(0, 280),
+      source: "session_analysis",
+      base_confidence: Math.min(0.85, 0.5 + revertRate * 0.4)
+    };
+    const factId = await factStore2.createFact(input);
+    if (factId) {
+      created++;
+      details.push(`[negative:fragile] ${file} (${pct}% revert rate)`);
+    }
+  }
+  return { created, reinforced, source: "session_analysis", details };
+}
+function loadRecentSessions(unerrDir, limit) {
+  const sessionsDir = join44(unerrDir, "sessions");
+  if (!existsSync37(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 lines = content.trim().split("\n").filter(Boolean);
+        const lastLine = lines[lines.length - 1];
+        if (lastLine) {
+          summaries.push(JSON.parse(lastLine));
+        }
+      } catch {
+      }
+    }
+    return summaries;
+  } catch {
+    return [];
+  }
+}
+function detectHotFiles(summaries) {
+  const fileCounts = /* @__PURE__ */ new Map();
+  const total = summaries.length;
+  for (const session of summaries) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const file of session.files_modified) {
+      if (!seen.has(file)) {
+        seen.add(file);
+        fileCounts.set(file, (fileCounts.get(file) ?? 0) + 1);
+      }
+    }
+  }
+  const HOT_THRESHOLD = 0.5;
+  return [...fileCounts.entries()].map(([file, count]) => [file, count / total]).filter(([_, freq]) => freq >= HOT_THRESHOLD).sort((a, b) => b[1] - a[1]).slice(0, 10);
+}
+function detectHighRevertFiles(summaries) {
+  const fileModifiedCount = /* @__PURE__ */ new Map();
+  const fileRevertCount = /* @__PURE__ */ new Map();
+  for (const session of summaries) {
+    for (const file of session.files_modified) {
+      fileModifiedCount.set(file, (fileModifiedCount.get(file) ?? 0) + 1);
+      if (session.revert_count > 0) {
+        fileRevertCount.set(file, (fileRevertCount.get(file) ?? 0) + 1);
+      }
+    }
+  }
+  const HIGH_REVERT_THRESHOLD = 0.4;
+  const MIN_MODIFICATIONS = 3;
+  return [...fileModifiedCount.entries()].filter(([_, count]) => count >= MIN_MODIFICATIONS).map(([file, count]) => {
+    const reverts = fileRevertCount.get(file) ?? 0;
+    return [file, reverts / count];
+  }).filter(([_, rate]) => rate >= HIGH_REVERT_THRESHOLD).sort((a, b) => b[1] - a[1]).slice(0, 5);
+}
+function formatConventionFact(conv) {
+  const pct = Math.round(conv.confidence * 100);
+  switch (conv.kind) {
+    case "naming":
+      return `Naming convention: ${conv.name} (${pct}% confidence, ${conv.frequency} entities)`;
+    case "structure":
+      return `Structure pattern: ${conv.name} (${pct}% confidence)`;
+    case "import_direction":
+      return `Import convention: ${conv.name} (${pct}% confidence)`;
+    default:
+      return `Convention: ${conv.name} (${pct}% confidence)`;
+  }
+}
+function inferScopeFromConvention(conv) {
+  if (conv.exemplarKeys.length > 0) {
+    const first = conv.exemplarKeys[0];
+    const parts = first.split("/");
+    if (parts.length >= 2) {
+      return parts.slice(0, 2).join("/");
+    }
+  }
+  return "project";
+}
+var init_fact_generator = __esm({
+  "src/intelligence/fact-generator.ts"() {
+    "use strict";
+  }
+});
+
 // src/proxy/auto-bootstrap.ts
 var auto_bootstrap_exports = {};
 __export(auto_bootstrap_exports, {
@@ -16969,8 +17331,8 @@ var init_model_pricing = __esm({
 });
 
 // src/tracking/entity-rewind.ts
-import { readFileSync as readFileSync34, writeFileSync as writeFileSync20 } from "fs";
-import { join as join44 } from "path";
+import { readFileSync as readFileSync35, writeFileSync as writeFileSync20 } from "fs";
+import { join as join45 } from "path";
 async function revertEntity(entityName, localGraph, projectRoot, filePath) {
   const driftEntity = await findDriftEntity(localGraph, entityName, filePath);
   if (!driftEntity) {
@@ -16982,7 +17344,7 @@ async function revertEntity(entityName, localGraph, projectRoot, filePath) {
       error: `No drifted entity found: "${entityName}"${filePath ? ` in ${filePath}` : ""}`
     };
   }
-  const absPath = join44(projectRoot, driftEntity.file_path);
+  const absPath = join45(projectRoot, driftEntity.file_path);
   if (driftEntity.drift_status === "added") {
     return removeAddedEntity(absPath, driftEntity, localGraph);
   }
@@ -17047,7 +17409,7 @@ async function findDriftEntity(localGraph, entityName, filePath) {
 }
 async function removeAddedEntity(absPath, entity, localGraph) {
   try {
-    const content = readFileSync34(absPath, "utf-8");
+    const content = readFileSync35(absPath, "utf-8");
     const lines = content.split("\n");
     const startIdx = entity.line_start - 1;
     const endIdx = entity.line_end;
@@ -17082,7 +17444,7 @@ async function restoreDeletedEntity(absPath, entity, localGraph) {
     };
   }
   try {
-    const content = readFileSync34(absPath, "utf-8");
+    const content = readFileSync35(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);
@@ -17118,7 +17480,7 @@ async function restoreModifiedEntity(absPath, entity, localGraph) {
     };
   }
   try {
-    const content = readFileSync34(absPath, "utf-8");
+    const content = readFileSync35(absPath, "utf-8");
     const lines = content.split("\n");
     const previousLines = entity.previous_body.split("\n");
     const startIdx = entity.line_start - 1;
@@ -17530,7 +17892,7 @@ __export(file_outline_exports, {
   buildFileOutline: () => buildFileOutline,
   fileOutlineTool: () => fileOutlineTool
 });
-import { existsSync as existsSync37, readFileSync as readFileSync35 } from "fs";
+import { existsSync as existsSync38, readFileSync as readFileSync36 } from "fs";
 import { relative as relative2, resolve } from "path";
 function normRisk(rl) {
   const x2 = (rl ?? "low").toLowerCase();
@@ -17589,10 +17951,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 (!existsSync37(abs)) {
+  if (!existsSync38(abs)) {
     throw new Error(`File not found: ${abs}`);
   }
-  const raw = readFileSync35(abs);
+  const raw = readFileSync36(abs);
   const sampleEnd = Math.min(raw.length, 8192);
   for (let i = 0; i < sampleEnd; i++) {
     if (raw[i] === 0) {
@@ -17740,7 +18102,7 @@ __export(file_read_protocol_exports, {
   runFileReadForRouter: () => runFileReadForRouter,
   runFileReadTool: () => runFileReadTool
 });
-import { existsSync as existsSync38, readFileSync as readFileSync36 } from "fs";
+import { existsSync as existsSync39, readFileSync as readFileSync37 } from "fs";
 import { relative as relative3, resolve as resolve2 } from "path";
 function isGeneratedPath(rel) {
   return /(?:^|\/)node_modules\/|(?:^|\/)dist\/|\/\.next\/|\.generated\./.test(
@@ -17815,10 +18177,10 @@ async function runFileReadForRouter(args, ctx) {
   const abs = resolve2(ctx.cwd, filePathArg);
   const rel = relative3(ctx.cwd, abs).replace(/\\/g, "/") || filePathArg;
   const isOutOfProject = rel.startsWith("..");
-  if (!existsSync38(abs)) {
+  if (!existsSync39(abs)) {
     return { content: { 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) {
@@ -17845,9 +18207,16 @@ 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.`
+        _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.`
       },
-      _layer6_meta: { format: "outline", gated: true }
+      _layer6_meta: {
+        format: "outline",
+        gated: true,
+        total_lines: totalLines,
+        total_chars: text2.length,
+        tokens_estimate: Math.ceil(outline.token_estimate ?? 0),
+        optimization: `file_read gated \u2192 outline (${totalLines} lines)`
+      }
     };
   }
   if (entityName) {
@@ -17869,7 +18238,7 @@ async function runFileReadForRouter(args, ctx) {
             const match = ranked[0].entity;
             if (match.start_line >= 1 && match.start_line <= totalLines) {
               const start = Math.max(1, match.start_line - ENTITY_CONTEXT);
-              const endLine = match.start_line + match.body.split("\n").length - 1;
+              const endLine = (match.end_line ?? 0) > match.start_line ? match.end_line : match.start_line + match.body.split("\n").length - 1;
               const end = Math.min(totalLines, endLine + ENTITY_CONTEXT);
               offset = start;
               limit = Math.min(MAX_READ_LINES, end - start + 1);
@@ -17958,9 +18327,16 @@ async function runFileReadForRouter(args, ctx) {
             query: entityName,
             suggestions: []
           },
-          _gate_reason: `Entity "${entityName}" not found with high confidence. Use one of the suggestions or specify offset/limit.`
+          _gate_reason: `Entity "${entityName}" not found with high confidence. Use one of the suggestions or specify offset/limit. NOTE: If you plan to Edit this file, you MUST call built-in Read (not file_read) first.`
         },
-        _layer6_meta: { format: "outline", gated: true }
+        _layer6_meta: {
+          format: "outline",
+          gated: true,
+          total_lines: totalLines,
+          total_chars: text2.length,
+          tokens_estimate: Math.ceil(outline.token_estimate ?? 0),
+          optimization: `file_read gated \u2192 outline (${totalLines} lines)`
+        }
       };
     }
   }
@@ -17996,10 +18372,12 @@ ${body}`;
   const meta = {
     format: "json",
     tokens_estimate: Math.ceil(sliced.join("\n").length / CHARS_PER_TOKEN4),
-    total_lines: totalLines
+    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) {
     meta.optimization = `file_read window lines ${effOffset}-${effOffset + sliced.length - 1}`;
   }
@@ -18182,9 +18560,13 @@ var init_query_router = __esm({
     LOCAL_TOOLS = /* @__PURE__ */ new Set([
       "get_function",
       "get_class",
+      "get_entity",
+      // consolidated: replaces get_function + get_class
       "get_file",
       "get_callers",
       "get_callees",
+      "get_references",
+      // consolidated: replaces get_callers + get_callees
       "get_imports",
       "search_code",
       "get_rules",
@@ -18610,7 +18992,7 @@ var init_query_router = __esm({
                 Object.assign(meta, fr._layer6_meta);
                 if (this.tokenFlow && fr._layer6_meta.optimization && fr._layer6_meta.total_lines) {
                   const deliveredTokens = fr._layer6_meta.tokens_estimate ?? 0;
-                  const fullFileTokens = Math.ceil(fr._layer6_meta.total_lines * 80 / 4);
+                  const fullFileTokens = fr._layer6_meta.total_chars ? Math.ceil(fr._layer6_meta.total_chars / 4) : Math.ceil(fr._layer6_meta.total_lines * 80 / 4);
                   const fileReadSaved = fullFileTokens - deliveredTokens;
                   if (fileReadSaved > 50) {
                     this.tokenFlow.record({
@@ -19558,7 +19940,21 @@ var init_query_router = __esm({
           case "get_file": {
             const raw = args.key ?? args.name;
             const key = await this.resolveKeyArg(raw);
-            return this.resolveEntityWithOverlay(key);
+            const entity = await this.resolveEntityWithOverlay(key);
+            if (entity && entity.file_path && entity.start_line > 0) {
+              try {
+                const { readFileSync: readFileSync57 } = 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 start = entity.start_line - 1;
+                const end = entity.end_line ?? lines.length;
+                entity.body = lines.slice(start, end).join("\n");
+              } catch {
+              }
+            }
+            return entity;
           }
           case "get_references": {
             const key = await this.resolveKeyArg(args.key);
@@ -19931,11 +20327,14 @@ var init_query_router = __esm({
     ENTITY_ARRAY_TOOLS = /* @__PURE__ */ new Set([
       "get_callers",
       "get_callees",
+      "get_references",
       "search_code"
     ]);
     SINGLE_ENTITY_TOOLS = /* @__PURE__ */ new Set([
+      "get_entity",
       "get_function",
-      "get_class"
+      "get_class",
+      "get_file"
     ]);
   }
 });
@@ -21074,8 +21473,8 @@ __export(causal_bridge_exports, {
   assembleCausalChain: () => assembleCausalChain,
   computeDurability: () => computeDurability
 });
-import { existsSync as existsSync39, readFileSync as readFileSync37 } from "fs";
-import { join as join45 } from "path";
+import { existsSync as existsSync40, readFileSync as readFileSync38 } from "fs";
+import { join as join46 } from "path";
 function computeAggregateDurability(interactions) {
   if (interactions.length === 0) return 1;
   const survivedCount = interactions.filter((i) => i.survived).length;
@@ -21232,9 +21631,9 @@ var init_causal_bridge = __esm({
         return chains;
       }
       loadEntityLedgerEntries(entityKey2) {
-        const ledgerPath = join45(this.unerrDir, "ledger", "shadow.jsonl");
-        if (!existsSync39(ledgerPath)) return [];
-        const content = readFileSync37(ledgerPath, "utf-8");
+        const ledgerPath = join46(this.unerrDir, "ledger", "shadow.jsonl");
+        if (!existsSync40(ledgerPath)) return [];
+        const content = readFileSync38(ledgerPath, "utf-8");
         const lines = content.split("\n").filter((l) => l.trim().length > 0);
         const entries = [];
         for (const line of lines) {
@@ -21720,15 +22119,15 @@ var context_ledger_exports = {};
 __export(context_ledger_exports, {
   createContextLedger: () => createContextLedger
 });
-import { existsSync as existsSync40, mkdirSync as mkdirSync23, readFileSync as readFileSync38, writeFileSync as writeFileSync21 } from "fs";
-import { join as join46 } from "path";
+import { existsSync as existsSync41, mkdirSync as mkdirSync23, readFileSync as readFileSync39, writeFileSync as writeFileSync21 } from "fs";
+import { join as join47 } from "path";
 function createContextLedger(unerrDir) {
-  const stateDir = join46(unerrDir, "state");
-  const filePath = join46(stateDir, "context-ledger.json");
+  const stateDir = join47(unerrDir, "state");
+  const filePath = join47(stateDir, "context-ledger.json");
   let records = [];
   let index = /* @__PURE__ */ new Map();
   function ensureDir() {
-    if (!existsSync40(stateDir)) {
+    if (!existsSync41(stateDir)) {
       mkdirSync23(stateDir, { recursive: true });
     }
   }
@@ -21737,13 +22136,13 @@ function createContextLedger(unerrDir) {
   }
   function load() {
     ensureDir();
-    if (!existsSync40(filePath)) {
+    if (!existsSync41(filePath)) {
       records = [];
       index = /* @__PURE__ */ new Map();
       return /* @__PURE__ */ new Map();
     }
     try {
-      const raw = readFileSync38(filePath, "utf-8");
+      const raw = readFileSync39(filePath, "utf-8");
       const parsed = JSON.parse(raw);
       records = Array.isArray(parsed) ? parsed : [];
     } catch {
@@ -22650,13 +23049,13 @@ __export(intent_correlator_exports, {
   IntentCorrelator: () => IntentCorrelator
 });
 import {
-  existsSync as existsSync41,
+  existsSync as existsSync42,
   mkdirSync as mkdirSync24,
-  readFileSync as readFileSync39,
+  readFileSync as readFileSync40,
   renameSync,
   writeFileSync as writeFileSync22
 } from "fs";
-import { join as join47 } from "path";
+import { join as join48 } from "path";
 function extractFiles4(args) {
   const files = args.files;
   if (files && Array.isArray(files)) {
@@ -22704,9 +23103,9 @@ var init_intent_correlator = __esm({
       pendingPath;
       pending = [];
       constructor(unerrDir) {
-        this.ledgerDir = join47(unerrDir, "ledger");
-        this.pendingPath = join47(this.ledgerDir, "pending_correlations.json");
-        if (!existsSync41(this.ledgerDir)) {
+        this.ledgerDir = join48(unerrDir, "ledger");
+        this.pendingPath = join48(this.ledgerDir, "pending_correlations.json");
+        if (!existsSync42(this.ledgerDir)) {
           mkdirSync24(this.ledgerDir, { recursive: true });
         }
         this.load();
@@ -22798,9 +23197,9 @@ var init_intent_correlator = __esm({
       }
       // ── Persistence ─────────────────────────────────────────────────
       load() {
-        if (!existsSync41(this.pendingPath)) return;
+        if (!existsSync42(this.pendingPath)) return;
         try {
-          const raw = readFileSync39(this.pendingPath, "utf-8");
+          const raw = readFileSync40(this.pendingPath, "utf-8");
           const parsed = JSON.parse(raw);
           if (Array.isArray(parsed)) {
             this.pending = parsed;
@@ -22832,14 +23231,14 @@ __export(working_snapshots_exports, {
 });
 import { randomBytes as randomBytes3 } from "crypto";
 import {
-  existsSync as existsSync42,
+  existsSync as existsSync43,
   mkdirSync as mkdirSync25,
-  readFileSync as readFileSync40,
-  readdirSync as readdirSync9,
+  readFileSync as readFileSync41,
+  readdirSync as readdirSync10,
   rmSync as rmSync2,
   writeFileSync as writeFileSync23
 } from "fs";
-import { join as join48 } from "path";
+import { join as join49 } from "path";
 var _log2, MAX_SNAPSHOTS, AUTO_SNAPSHOT_COOLDOWN_MS, WorkingSnapshotStore;
 var init_working_snapshots = __esm({
   "src/tracking/working-snapshots.ts"() {
@@ -22857,8 +23256,8 @@ var init_working_snapshots = __esm({
       unerrDir;
       constructor(unerrDir) {
         this.unerrDir = unerrDir;
-        this.snapshotDir = join48(unerrDir, "snapshots");
-        if (!existsSync42(this.snapshotDir)) {
+        this.snapshotDir = join49(unerrDir, "snapshots");
+        if (!existsSync43(this.snapshotDir)) {
           mkdirSync25(this.snapshotDir, { recursive: true });
         }
       }
@@ -22878,7 +23277,7 @@ var init_working_snapshots = __esm({
           processed: false
         };
         writeFileSync23(
-          join48(this.snapshotDir, `${id}.json`),
+          join49(this.snapshotDir, `${id}.json`),
           JSON.stringify(snapshot, null, 2),
           "utf-8"
         );
@@ -22892,10 +23291,10 @@ var init_working_snapshots = __esm({
        * Get a snapshot by ID.
        */
       get(snapshotId) {
-        const filePath = join48(this.snapshotDir, `${snapshotId}.json`);
-        if (!existsSync42(filePath)) return null;
+        const filePath = join49(this.snapshotDir, `${snapshotId}.json`);
+        if (!existsSync43(filePath)) return null;
         try {
-          return JSON.parse(readFileSync40(filePath, "utf-8"));
+          return JSON.parse(readFileSync41(filePath, "utf-8"));
         } catch {
           return null;
         }
@@ -22904,14 +23303,14 @@ var init_working_snapshots = __esm({
        * List all snapshots, most recent first.
        */
       list() {
-        if (!existsSync42(this.snapshotDir)) return [];
-        const files = readdirSync9(this.snapshotDir).filter(
+        if (!existsSync43(this.snapshotDir)) return [];
+        const files = readdirSync10(this.snapshotDir).filter(
           (f) => f.endsWith(".json")
         );
         const snapshots = [];
         for (const file of files) {
           try {
-            const raw = readFileSync40(join48(this.snapshotDir, file), "utf-8");
+            const raw = readFileSync41(join49(this.snapshotDir, file), "utf-8");
             snapshots.push(JSON.parse(raw));
           } catch {
           }
@@ -22952,7 +23351,7 @@ var init_working_snapshots = __esm({
         if (!snapshot) return;
         snapshot.processed = true;
         writeFileSync23(
-          join48(this.snapshotDir, `${snapshotId}.json`),
+          join49(this.snapshotDir, `${snapshotId}.json`),
           JSON.stringify(snapshot, null, 2),
           "utf-8"
         );
@@ -22967,8 +23366,8 @@ var init_working_snapshots = __esm({
        * Delete a snapshot.
        */
       delete(snapshotId) {
-        const filePath = join48(this.snapshotDir, `${snapshotId}.json`);
-        if (!existsSync42(filePath)) return false;
+        const filePath = join49(this.snapshotDir, `${snapshotId}.json`);
+        if (!existsSync43(filePath)) return false;
         rmSync2(filePath);
         return true;
       }
@@ -22976,10 +23375,10 @@ var init_working_snapshots = __esm({
        * Get the timeline branch counter from branch_context.json.
        */
       getTimelineBranch() {
-        const contextPath = join48(this.unerrDir, "branch_context.json");
-        if (!existsSync42(contextPath)) return 0;
+        const contextPath = join49(this.unerrDir, "branch_context.json");
+        if (!existsSync43(contextPath)) return 0;
         try {
-          const ctx = JSON.parse(readFileSync40(contextPath, "utf-8"));
+          const ctx = JSON.parse(readFileSync41(contextPath, "utf-8"));
           return ctx.timelineBranch ?? 0;
         } catch {
           return 0;
@@ -22989,11 +23388,11 @@ var init_working_snapshots = __esm({
        * Increment the timeline branch counter. Returns the new value.
        */
       incrementTimelineBranch() {
-        const contextPath = join48(this.unerrDir, "branch_context.json");
+        const contextPath = join49(this.unerrDir, "branch_context.json");
         let ctx = {};
-        if (existsSync42(contextPath)) {
+        if (existsSync43(contextPath)) {
           try {
-            ctx = JSON.parse(readFileSync40(contextPath, "utf-8"));
+            ctx = JSON.parse(readFileSync41(contextPath, "utf-8"));
           } catch {
             ctx = {};
           }
@@ -23166,8 +23565,8 @@ var quality_signals_exports = {};
 __export(quality_signals_exports, {
   QualitySignalTracker: () => QualitySignalTracker
 });
-import { existsSync as existsSync43, readFileSync as readFileSync41, writeFileSync as writeFileSync24 } from "fs";
-import { join as join49 } from "path";
+import { existsSync as existsSync44, readFileSync as readFileSync42, writeFileSync as writeFileSync24 } from "fs";
+import { join as join50 } from "path";
 function computeDurabilityFromAge(survivalMs) {
   if (survivalMs < FRAGILE_THRESHOLD_MS) {
     return 0.1 + survivalMs / FRAGILE_THRESHOLD_MS * 0.2;
@@ -23194,7 +23593,7 @@ var init_quality_signals = __esm({
       /** Maximum corrections to retain in memory/disk. */
       static MAX_CORRECTIONS = 200;
       constructor(unerrDir) {
-        this.signalsPath = join49(unerrDir, "state", "quality_signals.json");
+        this.signalsPath = join50(unerrDir, "state", "quality_signals.json");
         this.signals = this.load();
       }
       /**
@@ -23286,8 +23685,8 @@ var init_quality_signals = __esm({
        */
       save() {
         try {
-          const dir = join49(this.signalsPath, "..");
-          if (!existsSync43(dir)) {
+          const dir = join50(this.signalsPath, "..");
+          if (!existsSync44(dir)) {
             const { mkdirSync: mkdirSync39 } = __require("fs");
             mkdirSync39(dir, { recursive: true });
           }
@@ -23333,7 +23732,7 @@ var init_quality_signals = __esm({
        * Load signals from disk.
        */
       load() {
-        if (!existsSync43(this.signalsPath)) {
+        if (!existsSync44(this.signalsPath)) {
           return {
             durabilityScores: {},
             corrections: [],
@@ -23342,7 +23741,7 @@ var init_quality_signals = __esm({
         }
         try {
           return JSON.parse(
-            readFileSync41(this.signalsPath, "utf-8")
+            readFileSync42(this.signalsPath, "utf-8")
           );
         } catch {
           return {
@@ -24359,8 +24758,8 @@ var incomplete_work_exports = {};
 __export(incomplete_work_exports, {
   IncompleteWorkDetector: () => IncompleteWorkDetector
 });
-import { existsSync as existsSync44, mkdirSync as mkdirSync26, readFileSync as readFileSync42, writeFileSync as writeFileSync25 } from "fs";
-import { join as join50 } from "path";
+import { existsSync as existsSync45, mkdirSync as mkdirSync26, readFileSync as readFileSync43, writeFileSync as writeFileSync25 } from "fs";
+import { join as join51 } from "path";
 function severityRank(severity) {
   switch (severity) {
     case "high":
@@ -24553,9 +24952,9 @@ var init_incomplete_work = __esm({
       persistItems(items) {
         if (!this.unerrDir) return false;
         try {
-          const stateDir = join50(this.unerrDir, "state");
-          if (!existsSync44(stateDir)) mkdirSync26(stateDir, { recursive: true });
-          const filePath = join50(stateDir, PERSISTENCE_FILE);
+          const stateDir = join51(this.unerrDir, "state");
+          if (!existsSync45(stateDir)) mkdirSync26(stateDir, { recursive: true });
+          const filePath = join51(stateDir, PERSISTENCE_FILE);
           writeFileSync25(
             filePath,
             JSON.stringify({
@@ -24575,9 +24974,9 @@ var init_incomplete_work = __esm({
        */
       static readPersistedItems(unerrDir) {
         try {
-          const filePath = join50(unerrDir, "state", PERSISTENCE_FILE);
-          if (!existsSync44(filePath)) return [];
-          const data = JSON.parse(readFileSync42(filePath, "utf-8"));
+          const filePath = join51(unerrDir, "state", PERSISTENCE_FILE);
+          if (!existsSync45(filePath)) return [];
+          const data = JSON.parse(readFileSync43(filePath, "utf-8"));
           return data.items ?? [];
         } catch {
           return [];
@@ -26048,7 +26447,7 @@ var transport_mux_exports = {};
 __export(transport_mux_exports, {
   TransportMux: () => TransportMux
 });
-import { existsSync as existsSync45, unlinkSync as unlinkSync7 } from "fs";
+import { existsSync as existsSync46, unlinkSync as unlinkSync7 } from "fs";
 import { createServer as createServer2 } from "net";
 var _log4, TransportMux;
 var init_transport_mux = __esm({
@@ -26088,7 +26487,7 @@ var init_transport_mux = __esm({
        * Start listening for secondary clients on the Unix domain socket.
        */
       start() {
-        if (existsSync45(this.sockPath)) {
+        if (existsSync46(this.sockPath)) {
           try {
             unlinkSync7(this.sockPath);
           } catch {
@@ -26121,7 +26520,7 @@ var init_transport_mux = __esm({
           this.server.close();
           this.server = null;
         }
-        if (existsSync45(this.sockPath)) {
+        if (existsSync46(this.sockPath)) {
           try {
             unlinkSync7(this.sockPath);
           } catch {
@@ -26269,8 +26668,8 @@ __export(git_trailers_exports, {
   parseTrailersFromMessage: () => parseTrailersFromMessage,
   uninstallPrepareCommitMsgHook: () => uninstallPrepareCommitMsgHook
 });
-import { existsSync as existsSync46, readFileSync as readFileSync43, writeFileSync as writeFileSync26 } from "fs";
-import { join as join51 } from "path";
+import { existsSync as existsSync47, readFileSync as readFileSync44, writeFileSync as writeFileSync26 } from "fs";
+import { join as join52 } from "path";
 function getCommitTrailers(ledger, timelineBranch, branch) {
   const recent = ledger.getRecentEntries(1);
   if (recent.length === 0) return null;
@@ -26290,15 +26689,15 @@ function formatTrailers(trailers) {
   ].join("\n");
 }
 function installPrepareCommitMsgHook(projectRoot) {
-  const hooksDir = join51(projectRoot, ".git", "hooks");
-  if (!existsSync46(hooksDir)) {
+  const hooksDir = join52(projectRoot, ".git", "hooks");
+  if (!existsSync47(hooksDir)) {
     return false;
   }
-  const hookPath = join51(hooksDir, "prepare-commit-msg");
+  const hookPath = join52(hooksDir, "prepare-commit-msg");
   const marker = "# unerr-trailer-injection";
-  if (existsSync46(hookPath)) {
+  if (existsSync47(hookPath)) {
     try {
-      const existing = readFileSync43(hookPath, "utf-8");
+      const existing = readFileSync44(hookPath, "utf-8");
       if (existing.includes(marker)) {
         return true;
       }
@@ -26327,10 +26726,10 @@ ${generateHookScript()}`;
   }
 }
 function uninstallPrepareCommitMsgHook(projectRoot) {
-  const hookPath = join51(projectRoot, ".git", "hooks", "prepare-commit-msg");
-  if (!existsSync46(hookPath)) return true;
+  const hookPath = join52(projectRoot, ".git", "hooks", "prepare-commit-msg");
+  if (!existsSync47(hookPath)) return true;
   try {
-    const content = readFileSync43(hookPath, "utf-8");
+    const content = readFileSync44(hookPath, "utf-8");
     const marker = "# unerr-trailer-injection";
     if (!content.includes(marker)) return true;
     const lines = content.split("\n");
@@ -26495,15 +26894,15 @@ var init_http_transport = __esm({
 
 // src/tracking/branch-snapshot.ts
 import {
-  existsSync as existsSync47,
+  existsSync as existsSync48,
   mkdirSync as mkdirSync28,
-  readFileSync as readFileSync44,
-  readdirSync as readdirSync10,
+  readFileSync as readFileSync45,
+  readdirSync as readdirSync11,
   rmSync as rmSync3,
   statSync as statSync7,
   writeFileSync as writeFileSync27
 } from "fs";
-import { join as join52 } from "path";
+import { join as join53 } from "path";
 function sanitizeBranchName(branch) {
   return branch.replace(/\//g, "__").replace(/[^a-zA-Z0-9_.\-]/g, "_");
 }
@@ -26521,7 +26920,7 @@ var init_branch_snapshot = __esm({
       branchDir;
       projectRoot;
       constructor(unerrDir, projectRoot) {
-        this.branchDir = join52(unerrDir, "drift", "branches");
+        this.branchDir = join53(unerrDir, "drift", "branches");
         this.projectRoot = projectRoot;
       }
       /**
@@ -26535,8 +26934,8 @@ var init_branch_snapshot = __esm({
           log16.info(`No drift entities/edges to snapshot for branch ${branch}`);
         }
         const dirName = sanitizeBranchName(branch);
-        const snapshotDir = join52(this.branchDir, dirName);
-        if (!existsSync47(snapshotDir)) {
+        const snapshotDir = join53(this.branchDir, dirName);
+        if (!existsSync48(snapshotDir)) {
           mkdirSync28(snapshotDir, { recursive: true });
         }
         const snapshot = {
@@ -26547,12 +26946,12 @@ var init_branch_snapshot = __esm({
           savedAt: (/* @__PURE__ */ new Date()).toISOString()
         };
         writeFileSync27(
-          join52(snapshotDir, OVERLAY_FILE),
+          join53(snapshotDir, OVERLAY_FILE),
           JSON.stringify(snapshot, null, 2),
           "utf-8"
         );
         writeFileSync27(
-          join52(snapshotDir, HASHES_FILE),
+          join53(snapshotDir, HASHES_FILE),
           JSON.stringify(fileHashState, null, 2),
           "utf-8"
         );
@@ -26568,14 +26967,14 @@ var init_branch_snapshot = __esm({
        */
       async restoreSnapshot(branch, localGraph) {
         const dirName = sanitizeBranchName(branch);
-        const snapshotDir = join52(this.branchDir, dirName);
-        const overlayPath = join52(snapshotDir, OVERLAY_FILE);
-        if (!existsSync47(overlayPath)) {
+        const snapshotDir = join53(this.branchDir, dirName);
+        const overlayPath = join53(snapshotDir, OVERLAY_FILE);
+        if (!existsSync48(overlayPath)) {
           log16.info(`No snapshot for branch ${branch} \u2014 first visit`);
           return null;
         }
         try {
-          const raw = readFileSync44(overlayPath, "utf-8");
+          const raw = readFileSync45(overlayPath, "utf-8");
           const snapshot = JSON.parse(raw);
           for (const entity of snapshot.entities) {
             await localGraph.upsertDriftEntity(entity);
@@ -26587,7 +26986,7 @@ var init_branch_snapshot = __esm({
           }
           const now = /* @__PURE__ */ new Date();
           writeFileSync27(
-            join52(snapshotDir, ".last_access"),
+            join53(snapshotDir, ".last_access"),
             now.toISOString(),
             "utf-8"
           );
@@ -26607,17 +27006,17 @@ var init_branch_snapshot = __esm({
        */
       hasSnapshot(branch) {
         const dirName = sanitizeBranchName(branch);
-        return existsSync47(join52(this.branchDir, dirName, OVERLAY_FILE));
+        return existsSync48(join53(this.branchDir, dirName, OVERLAY_FILE));
       }
       /**
        * Get the file hash state from a branch snapshot.
        */
       getSnapshotFileHashes(branch) {
         const dirName = sanitizeBranchName(branch);
-        const hashesPath = join52(this.branchDir, dirName, HASHES_FILE);
-        if (!existsSync47(hashesPath)) return null;
+        const hashesPath = join53(this.branchDir, dirName, HASHES_FILE);
+        if (!existsSync48(hashesPath)) return null;
         try {
-          const raw = readFileSync44(hashesPath, "utf-8");
+          const raw = readFileSync45(hashesPath, "utf-8");
           return JSON.parse(raw);
         } catch {
           return null;
@@ -26628,8 +27027,8 @@ var init_branch_snapshot = __esm({
        */
       deleteSnapshot(branch) {
         const dirName = sanitizeBranchName(branch);
-        const snapshotDir = join52(this.branchDir, dirName);
-        if (!existsSync47(snapshotDir)) return false;
+        const snapshotDir = join53(this.branchDir, dirName);
+        if (!existsSync48(snapshotDir)) return false;
         rmSync3(snapshotDir, { recursive: true, force: true });
         log16.info(`Deleted branch snapshot: ${branch}`);
         return true;
@@ -26638,14 +27037,14 @@ var init_branch_snapshot = __esm({
        * Garbage-collect snapshots for branches that no longer exist in git.
        */
       async garbageCollect() {
-        if (!existsSync47(this.branchDir)) return 0;
+        if (!existsSync48(this.branchDir)) return 0;
         const gitBranches = new Set(await listBranches(this.projectRoot));
         if (gitBranches.size === 0) return 0;
         const snapshots = this.listSnapshots();
         let removed = 0;
         for (const snapshot of snapshots) {
           if (!gitBranches.has(snapshot.branch)) {
-            const snapshotDir = join52(this.branchDir, snapshot.id);
+            const snapshotDir = join53(this.branchDir, snapshot.id);
             rmSync3(snapshotDir, { recursive: true, force: true });
             log16.info(`GC removed snapshot for deleted branch: ${snapshot.branch}`);
             removed++;
@@ -26657,20 +27056,20 @@ var init_branch_snapshot = __esm({
        * List all branch snapshots, sorted by most recently accessed first.
        */
       listSnapshots() {
-        if (!existsSync47(this.branchDir)) return [];
+        if (!existsSync48(this.branchDir)) return [];
         try {
-          const entries = readdirSync10(this.branchDir, { withFileTypes: true });
+          const entries = readdirSync11(this.branchDir, { withFileTypes: true });
           const snapshots = [];
           for (const entry of entries) {
             if (!entry.isDirectory()) continue;
-            const overlayPath = join52(this.branchDir, entry.name, OVERLAY_FILE);
-            if (!existsSync47(overlayPath)) continue;
+            const overlayPath = join53(this.branchDir, entry.name, OVERLAY_FILE);
+            if (!existsSync48(overlayPath)) continue;
             try {
-              const raw = readFileSync44(overlayPath, "utf-8");
+              const raw = readFileSync45(overlayPath, "utf-8");
               const snapshot = JSON.parse(raw);
-              const accessPath = join52(this.branchDir, entry.name, ".last_access");
+              const accessPath = join53(this.branchDir, entry.name, ".last_access");
               let accessedAt;
-              if (existsSync47(accessPath)) {
+              if (existsSync48(accessPath)) {
                 accessedAt = statSync7(accessPath).mtime;
               } else {
                 accessedAt = statSync7(overlayPath).mtime;
@@ -26697,7 +27096,7 @@ var init_branch_snapshot = __esm({
         if (snapshots.length <= MAX_BRANCH_SNAPSHOTS) return;
         const toRemove = snapshots.slice(MAX_BRANCH_SNAPSHOTS);
         for (const snapshot of toRemove) {
-          const dir = join52(this.branchDir, snapshot.id);
+          const dir = join53(this.branchDir, snapshot.id);
           rmSync3(dir, { recursive: true, force: true });
           log16.info(`LRU evicted branch snapshot: ${snapshot.branch}`);
         }
@@ -26714,13 +27113,13 @@ __export(file_hash_state_exports, {
 });
 import { createHash as createHash3 } from "crypto";
 import {
-  existsSync as existsSync48,
+  existsSync as existsSync49,
   mkdirSync as mkdirSync29,
-  readFileSync as readFileSync45,
+  readFileSync as readFileSync46,
   renameSync as renameSync2,
   writeFileSync as writeFileSync28
 } from "fs";
-import { join as join53 } from "path";
+import { join as join54 } from "path";
 function contentSha256(content) {
   return createHash3("sha256").update(content).digest("hex");
 }
@@ -26734,8 +27133,8 @@ var init_file_hash_state = __esm({
       statePath;
       state;
       constructor(unerrDir) {
-        this.stateDir = join53(unerrDir, "state");
-        this.statePath = join53(this.stateDir, STATE_FILE);
+        this.stateDir = join54(unerrDir, "state");
+        this.statePath = join54(this.stateDir, STATE_FILE);
         this.state = this.load();
       }
       /**
@@ -26780,7 +27179,7 @@ var init_file_hash_state = __esm({
        * Persist state to disk atomically (write .tmp → rename).
        */
       save() {
-        if (!existsSync48(this.stateDir)) {
+        if (!existsSync49(this.stateDir)) {
           mkdirSync29(this.stateDir, { recursive: true });
         }
         const tmpPath = `${this.statePath}.tmp`;
@@ -26807,11 +27206,11 @@ var init_file_hash_state = __esm({
         this.state = { files: { ...snapshot.files } };
       }
       load() {
-        if (!existsSync48(this.statePath)) {
+        if (!existsSync49(this.statePath)) {
           return { files: {} };
         }
         try {
-          const raw = readFileSync45(this.statePath, "utf-8");
+          const raw = readFileSync46(this.statePath, "utf-8");
           return JSON.parse(raw);
         } catch {
           return { files: {} };
@@ -26823,15 +27222,15 @@ var init_file_hash_state = __esm({
 
 // src/tracking/stash-manager.ts
 import {
-  existsSync as existsSync49,
+  existsSync as existsSync50,
   mkdirSync as mkdirSync30,
-  readFileSync as readFileSync46,
-  readdirSync as readdirSync11,
+  readFileSync as readFileSync47,
+  readdirSync as readdirSync12,
   rmSync as rmSync4,
   statSync as statSync8,
   writeFileSync as writeFileSync29
 } from "fs";
-import { join as join54 } from "path";
+import { join as join55 } from "path";
 var MAX_STASH_SNAPSHOTS, OVERLAY_FILE2, HASHES_FILE2, _log6, StashManager;
 var init_stash_manager = __esm({
   "src/tracking/stash-manager.ts"() {
@@ -26849,8 +27248,8 @@ var init_stash_manager = __esm({
       constructor(unerrDir, projectRoot) {
         this.unerrDir = unerrDir;
         this.projectRoot = projectRoot;
-        this.stashDir = join54(unerrDir, "drift", "stash");
-        this.gitDir = join54(projectRoot, ".git");
+        this.stashDir = join55(unerrDir, "drift", "stash");
+        this.gitDir = join55(projectRoot, ".git");
         this.previousStashRef = this.readStashRef();
         this.previousStashCount = this.getStashCount();
       }
@@ -26895,8 +27294,8 @@ var init_stash_manager = __esm({
           return null;
         }
         const snapshotId = stashRef.slice(0, 12);
-        const snapshotDir = join54(this.stashDir, snapshotId);
-        if (!existsSync49(snapshotDir)) {
+        const snapshotDir = join55(this.stashDir, snapshotId);
+        if (!existsSync50(snapshotDir)) {
           mkdirSync30(snapshotDir, { recursive: true });
         }
         const snapshot = {
@@ -26907,12 +27306,12 @@ var init_stash_manager = __esm({
           savedAt: (/* @__PURE__ */ new Date()).toISOString()
         };
         writeFileSync29(
-          join54(snapshotDir, OVERLAY_FILE2),
+          join55(snapshotDir, OVERLAY_FILE2),
           JSON.stringify(snapshot, null, 2),
           "utf-8"
         );
         writeFileSync29(
-          join54(snapshotDir, HASHES_FILE2),
+          join55(snapshotDir, HASHES_FILE2),
           JSON.stringify(fileHashState, null, 2),
           "utf-8"
         );
@@ -26933,14 +27332,14 @@ var init_stash_manager = __esm({
           return 0;
         }
         const latest = snapshots[0];
-        const snapshotDir = join54(this.stashDir, latest.id);
-        const overlayPath = join54(snapshotDir, OVERLAY_FILE2);
-        if (!existsSync49(overlayPath)) {
+        const snapshotDir = join55(this.stashDir, latest.id);
+        const overlayPath = join55(snapshotDir, OVERLAY_FILE2);
+        if (!existsSync50(overlayPath)) {
           _log6.warn(`Snapshot ${latest.id} missing overlay file`);
           return 0;
         }
         try {
-          const raw = readFileSync46(overlayPath, "utf-8");
+          const raw = readFileSync47(overlayPath, "utf-8");
           const snapshot = JSON.parse(raw);
           for (const entity of snapshot.entities) {
             await localGraph.upsertDriftEntity(entity);
@@ -26970,10 +27369,10 @@ var init_stash_manager = __esm({
         const snapshots = this.listSnapshots();
         if (snapshots.length === 0) return null;
         const latest = snapshots[0];
-        const hashesPath = join54(this.stashDir, latest.id, HASHES_FILE2);
-        if (!existsSync49(hashesPath)) return null;
+        const hashesPath = join55(this.stashDir, latest.id, HASHES_FILE2);
+        if (!existsSync50(hashesPath)) return null;
         try {
-          const raw = readFileSync46(hashesPath, "utf-8");
+          const raw = readFileSync47(hashesPath, "utf-8");
           return JSON.parse(raw);
         } catch {
           return null;
@@ -26984,8 +27383,8 @@ var init_stash_manager = __esm({
        */
       dropSnapshot(stashRef) {
         const snapshotId = stashRef.slice(0, 12);
-        const snapshotDir = join54(this.stashDir, snapshotId);
-        if (!existsSync49(snapshotDir)) return false;
+        const snapshotDir = join55(this.stashDir, snapshotId);
+        if (!existsSync50(snapshotDir)) return false;
         rmSync4(snapshotDir, { recursive: true, force: true });
         _log6.info(`Dropped stash snapshot: ${snapshotId}`);
         return true;
@@ -26994,14 +27393,14 @@ var init_stash_manager = __esm({
        * List all stash snapshots, sorted by most recent first.
        */
       listSnapshots() {
-        if (!existsSync49(this.stashDir)) return [];
+        if (!existsSync50(this.stashDir)) return [];
         try {
-          const entries = readdirSync11(this.stashDir, { withFileTypes: true });
+          const entries = readdirSync12(this.stashDir, { withFileTypes: true });
           const snapshots = [];
           for (const entry of entries) {
             if (!entry.isDirectory()) continue;
-            const overlayPath = join54(this.stashDir, entry.name, OVERLAY_FILE2);
-            if (!existsSync49(overlayPath)) continue;
+            const overlayPath = join55(this.stashDir, entry.name, OVERLAY_FILE2);
+            if (!existsSync50(overlayPath)) continue;
             try {
               const stat2 = statSync8(overlayPath);
               snapshots.push({ id: entry.name, savedAt: stat2.mtime });
@@ -27018,10 +27417,10 @@ var init_stash_manager = __esm({
        * Read the current stash ref SHA from `.git/refs/stash`.
        */
       readStashRef() {
-        const stashPath = join54(this.gitDir, "refs", "stash");
-        if (!existsSync49(stashPath)) return null;
+        const stashPath = join55(this.gitDir, "refs", "stash");
+        if (!existsSync50(stashPath)) return null;
         try {
-          return readFileSync46(stashPath, "utf-8").trim() || null;
+          return readFileSync47(stashPath, "utf-8").trim() || null;
         } catch {
           return null;
         }
@@ -27030,10 +27429,10 @@ var init_stash_manager = __esm({
        * Count current stash entries via `.git/logs/refs/stash`.
        */
       getStashCount() {
-        const logPath = join54(this.gitDir, "logs", "refs", "stash");
-        if (!existsSync49(logPath)) return 0;
+        const logPath = join55(this.gitDir, "logs", "refs", "stash");
+        if (!existsSync50(logPath)) return 0;
         try {
-          const content = readFileSync46(logPath, "utf-8");
+          const content = readFileSync47(logPath, "utf-8");
           return content.split("\n").filter((line) => line.trim().length > 0).length;
         } catch {
           return 0;
@@ -27047,7 +27446,7 @@ var init_stash_manager = __esm({
         if (snapshots.length <= MAX_STASH_SNAPSHOTS) return;
         const toRemove = snapshots.slice(MAX_STASH_SNAPSHOTS);
         for (const snapshot of toRemove) {
-          const dir = join54(this.stashDir, snapshot.id);
+          const dir = join55(this.stashDir, snapshot.id);
           rmSync4(dir, { recursive: true, force: true });
           _log6.info(`LRU evicted stash snapshot: ${snapshot.id}`);
         }
@@ -27065,13 +27464,13 @@ __export(drift_tracker_exports, {
   determineOrigin: () => determineOrigin
 });
 import {
-  existsSync as existsSync50,
+  existsSync as existsSync51,
   mkdirSync as mkdirSync31,
-  readFileSync as readFileSync47,
+  readFileSync as readFileSync48,
   statSync as statSync9,
   writeFileSync as writeFileSync30
 } from "fs";
-import { join as join55 } from "path";
+import { join as join56 } from "path";
 function determineOrigin(lastSyncTimestamp) {
   if (lastSyncTimestamp === 0) return "human";
   const elapsed = Date.now() - lastSyncTimestamp;
@@ -27282,15 +27681,15 @@ var init_drift_tracker = __esm({
           crossFileInvalidated: 0,
           edgesExtracted: 0
         };
-        const absPath = filePath.startsWith("/") ? filePath : join55(this.config.projectRoot, filePath);
+        const absPath = filePath.startsWith("/") ? filePath : join56(this.config.projectRoot, filePath);
         const relPath = filePath.startsWith("/") ? filePath.slice(this.config.projectRoot.length + 1) : filePath;
         const language = detectLanguage2(relPath);
         if (!language) return result;
-        if (existsSync50(absPath) && !this.mtimeCache.check(absPath)) {
+        if (existsSync51(absPath) && !this.mtimeCache.check(absPath)) {
           result.filesSkipped = 1;
           return result;
         }
-        if (!existsSync50(absPath)) {
+        if (!existsSync51(absPath)) {
           const baseEntities2 = await this.localGraph.getEntitiesByFile(relPath);
           this.markFileDeleted(relPath, intentId);
           result.filesProcessed = 1;
@@ -27328,7 +27727,7 @@ var init_drift_tracker = __esm({
           this.maybeEmitDrift(relPath, result);
           return result;
         }
-        const content = readFileSync47(absPath, "utf-8");
+        const content = readFileSync48(absPath, "utf-8");
         const sha = contentSha256(content);
         const decision = this.fileHashManager.shouldProcess(relPath, sha, headSha);
         if (decision === "skip") {
@@ -27562,7 +27961,7 @@ var init_drift_tracker = __esm({
         return await this.stashManager.restoreSnapshot(this.localGraph);
       }
       async markFileDeleted(filePath, intentId) {
-        const absPath = filePath.startsWith("/") ? filePath : join55(this.config.projectRoot, filePath);
+        const absPath = filePath.startsWith("/") ? filePath : join56(this.config.projectRoot, filePath);
         this.mtimeCache.evict(absPath);
         const baseEntities = await this.localGraph.getEntitiesByFile(filePath);
         const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -27647,13 +28046,13 @@ var init_drift_tracker = __esm({
         return invalidated;
       }
       async saveDriftSummary() {
-        const driftDir = join55(this.config.unerrDir, "drift");
-        if (!existsSync50(driftDir)) {
+        const driftDir = join56(this.config.unerrDir, "drift");
+        if (!existsSync51(driftDir)) {
           mkdirSync31(driftDir, { recursive: true });
         }
         const summary = await this.getDriftSummary();
         writeFileSync30(
-          join55(driftDir, "drift_summary.json"),
+          join56(driftDir, "drift_summary.json"),
           JSON.stringify(summary, null, 2),
           "utf-8"
         );
@@ -28062,8 +28461,8 @@ var incremental_indexer_exports = {};
 __export(incremental_indexer_exports, {
   indexFilesIncremental: () => indexFilesIncremental
 });
-import { existsSync as existsSync51, readFileSync as readFileSync48 } from "fs";
-import { join as join56, relative as relative4 } from "path";
+import { existsSync as existsSync52, readFileSync as readFileSync49 } from "fs";
+import { join as join57, relative as relative4 } from "path";
 async function indexFilesIncremental(projectRoot, changedFiles, graphStore, repoId) {
   const startMs = Date.now();
   const db = graphStore.db;
@@ -28078,9 +28477,9 @@ async function indexFilesIncremental(projectRoot, changedFiles, graphStore, repo
   const changedEntityKeys = /* @__PURE__ */ new Set();
   const deletedEntityKeys = /* @__PURE__ */ new Set();
   for (const filePath of changedFiles) {
-    const absPath = filePath.startsWith("/") ? filePath : join56(projectRoot, filePath);
+    const absPath = filePath.startsWith("/") ? filePath : join57(projectRoot, filePath);
     const relPath = filePath.startsWith("/") ? relative4(projectRoot, filePath) : filePath;
-    if (!existsSync51(absPath)) {
+    if (!existsSync52(absPath)) {
       const deleted2 = await deleteFileFromGraph(db, relPath);
       filesDeleted++;
       totalEntitiesDeleted += deleted2.entitiesDeleted;
@@ -28093,7 +28492,7 @@ async function indexFilesIncremental(projectRoot, changedFiles, graphStore, repo
     }
     let content;
     try {
-      content = readFileSync48(absPath, "utf-8");
+      content = readFileSync49(absPath, "utf-8");
     } catch {
       continue;
     }
@@ -28381,6 +28780,7 @@ async function upsertEntitiesBatched(db, entities) {
     e.name,
     e.file_path,
     e.start_line ?? 0,
+    e.end_line ?? 0,
     e.signature ?? "",
     e.body ?? "",
     e.fan_in ?? 0,
@@ -28398,21 +28798,22 @@ async function upsertEntitiesBatched(db, entities) {
   });
   try {
     await db.run(
-      `?[key, kind, name, file_path, start_line, signature, body, fan_in, fan_out, risk_level, is_test] <- [${rowStrs.join(", ")}]
-       :put entities { key => kind, name, file_path, start_line, signature, body, fan_in, fan_out, risk_level, is_test }`
+      `?[key, kind, name, file_path, start_line, end_line, signature, body, fan_in, fan_out, risk_level, is_test] <- [${rowStrs.join(", ")}]
+       :put entities { key => kind, name, file_path, start_line, end_line, signature, body, fan_in, fan_out, risk_level, is_test }`
     );
   } catch {
     for (const entity of entities) {
       try {
         await db.run(
-          `?[key, kind, name, file_path, start_line, signature, body, fan_in, fan_out, risk_level, is_test] <- [[$key, $kind, $name, $fp, $sl, $sig, $body, $fi, $fo, $rl, $is_test]]
-           :put entities { key => kind, name, file_path, start_line, signature, body, fan_in, fan_out, risk_level, is_test }`,
+          `?[key, kind, name, file_path, start_line, end_line, signature, body, fan_in, fan_out, risk_level, is_test] <- [[$key, $kind, $name, $fp, $sl, $el, $sig, $body, $fi, $fo, $rl, $is_test]]
+           :put entities { key => kind, name, file_path, start_line, end_line, signature, body, fan_in, fan_out, risk_level, is_test }`,
           {
             key: entity.key,
             kind: entity.kind,
             name: entity.name,
             fp: entity.file_path,
             sl: entity.start_line ?? 0,
+            el: entity.end_line ?? 0,
             sig: entity.signature ?? "",
             body: entity.body ?? "",
             fi: entity.fan_in ?? 0,
@@ -29258,8 +29659,8 @@ var workspace_manifest_exports = {};
 __export(workspace_manifest_exports, {
   WorkspaceManifest: () => WorkspaceManifest
 });
-import { existsSync as existsSync52, mkdirSync as mkdirSync32, readFileSync as readFileSync49, writeFileSync as writeFileSync31 } from "fs";
-import { join as join57 } from "path";
+import { existsSync as existsSync53, mkdirSync as mkdirSync32, readFileSync as readFileSync50, writeFileSync as writeFileSync31 } from "fs";
+import { join as join58 } from "path";
 var WorkspaceManifest;
 var init_workspace_manifest = __esm({
   "src/tracking/workspace-manifest.ts"() {
@@ -29269,7 +29670,7 @@ var init_workspace_manifest = __esm({
         this.unerrDir = unerrDir;
         this.repoId = repoId;
         this.sessionId = sessionId;
-        this.manifestPath = join57(unerrDir, "manifest.json");
+        this.manifestPath = join58(unerrDir, "manifest.json");
         this.data = this.load();
       }
       unerrDir;
@@ -29364,7 +29765,7 @@ var init_workspace_manifest = __esm({
       }
       // ── Internal ─────────────────────────────────────────────────────
       load() {
-        if (!existsSync52(this.manifestPath)) {
+        if (!existsSync53(this.manifestPath)) {
           return {
             version: 1,
             repoId: this.repoId,
@@ -29374,7 +29775,7 @@ var init_workspace_manifest = __esm({
           };
         }
         try {
-          const raw = readFileSync49(this.manifestPath, "utf-8");
+          const raw = readFileSync50(this.manifestPath, "utf-8");
           const parsed = JSON.parse(raw);
           if (parsed.repoId !== this.repoId) {
             return {
@@ -29397,7 +29798,7 @@ var init_workspace_manifest = __esm({
         }
       }
       save() {
-        if (!existsSync52(this.unerrDir)) {
+        if (!existsSync53(this.unerrDir)) {
           mkdirSync32(this.unerrDir, { recursive: true });
         }
         writeFileSync31(
@@ -29591,8 +29992,8 @@ var log_tailer_exports = {};
 __export(log_tailer_exports, {
   startLogTailer: () => startLogTailer
 });
-import { existsSync as existsSync53, statSync as statSync10, openSync, readSync, closeSync, watch } from "fs";
-import { join as join58 } from "path";
+import { existsSync as existsSync54, 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`;
   if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)}KB`;
@@ -29699,29 +30100,29 @@ function tailFile(state, handler) {
   }
 }
 function startLogTailer(cwd, options) {
-  const logsDir = join58(cwd, ".unerr", "logs");
-  const compressionPath = join58(logsDir, "compression.jsonl");
-  const generalPath = join58(logsDir, "unerr.jsonl");
-  const tokenFlowPath = join58(logsDir, "token-flow.jsonl");
-  const fileReadsPath = join58(logsDir, "file-reads.jsonl");
+  const logsDir = join59(cwd, ".unerr", "logs");
+  const compressionPath = join59(logsDir, "compression.jsonl");
+  const generalPath = join59(logsDir, "unerr.jsonl");
+  const tokenFlowPath = join59(logsDir, "token-flow.jsonl");
+  const fileReadsPath = join59(logsDir, "file-reads.jsonl");
   const compressionState = {
     path: compressionPath,
-    offset: existsSync53(compressionPath) ? statSync10(compressionPath).size : 0,
+    offset: existsSync54(compressionPath) ? statSync10(compressionPath).size : 0,
     watcher: null
   };
   const generalState = {
     path: generalPath,
-    offset: existsSync53(generalPath) ? statSync10(generalPath).size : 0,
+    offset: existsSync54(generalPath) ? statSync10(generalPath).size : 0,
     watcher: null
   };
   const tokenFlowState = {
     path: tokenFlowPath,
-    offset: existsSync53(tokenFlowPath) ? statSync10(tokenFlowPath).size : 0,
+    offset: existsSync54(tokenFlowPath) ? statSync10(tokenFlowPath).size : 0,
     watcher: null
   };
   const fileReadsState = {
     path: fileReadsPath,
-    offset: existsSync53(fileReadsPath) ? statSync10(fileReadsPath).size : 0,
+    offset: existsSync54(fileReadsPath) ? statSync10(fileReadsPath).size : 0,
     watcher: null
   };
   function setupWatcher(state, handler) {
@@ -29749,7 +30150,7 @@ function startLogTailer(cwd, options) {
   ];
   const pollInterval = setInterval(() => {
     for (const { state, handler } of allStates) {
-      if (!state.watcher && existsSync53(state.path)) {
+      if (!state.watcher && existsSync54(state.path)) {
         try {
           state.offset = 0;
           state.watcher = watch(state.path, () => {
@@ -30467,6 +30868,336 @@ function createIntelligenceRoutes(deps) {
       }
     });
   });
+  app.get("/risk-hotspots", async (c) => {
+    const start = performance.now();
+    const limit = parseLimit(c.req.query("limit"), 20, 50);
+    if (!deps.localGraph) {
+      return c.json(
+        {
+          data: [],
+          _meta: {
+            source: "local",
+            graph: "unavailable",
+            latency_ms: Math.round((performance.now() - start) * 100) / 100
+          }
+        },
+        503
+      );
+    }
+    const topNodes = await deps.localGraph.getCriticalNodes(limit);
+    const keys = topNodes.map((n) => n.key);
+    const testCountMap = /* @__PURE__ */ new Map();
+    if (keys.length > 0) {
+      try {
+        const directResult = await deps.localGraph.db.run(
+          `?[target, count(tk)] := *edges{from_key: tk, to_key: target, type: "tests"},
+            target in $keys`,
+          { keys }
+        );
+        for (const row of directResult.rows) {
+          testCountMap.set(row[0], row[1]);
+        }
+        const transitiveResult = await deps.localGraph.db.run(
+          `?[target, count(tk)] := *edges{from_key: mid, to_key: target, type: "calls"},
+            *edges{from_key: tk, to_key: mid, type: "tests"},
+            target in $keys`,
+          { keys }
+        );
+        for (const row of transitiveResult.rows) {
+          const key = row[0];
+          const existing = testCountMap.get(key) ?? 0;
+          testCountMap.set(key, existing + row[1]);
+        }
+      } catch {
+      }
+    }
+    const callerCountMap = /* @__PURE__ */ new Map();
+    if (keys.length > 0) {
+      try {
+        const callerResult = await deps.localGraph.db.run(
+          `?[target, count(caller)] := *edges{from_key: caller, to_key: target, type: "calls"},
+            target in $keys`,
+          { keys }
+        );
+        for (const row of callerResult.rows) {
+          callerCountMap.set(row[0], row[1]);
+        }
+      } catch {
+      }
+    }
+    const hotspots = topNodes.map((n) => ({
+      key: n.key,
+      name: n.name,
+      file_path: n.file_path,
+      kind: n.kind,
+      fan_in: n.fan_in,
+      fan_out: n.fan_out,
+      degree: n.degree,
+      risk_level: n.risk_level,
+      community_label: n.community_label,
+      test_count: testCountMap.get(n.key) ?? 0,
+      caller_count: callerCountMap.get(n.key) ?? 0
+    }));
+    return c.json({
+      data: hotspots,
+      _meta: {
+        source: "local",
+        latency_ms: Math.round((performance.now() - start) * 100) / 100
+      }
+    });
+  });
+  app.get("/insights", async (c) => {
+    const start = performance.now();
+    if (!deps.localGraph) {
+      return c.json(
+        {
+          data: null,
+          _meta: {
+            source: "local",
+            graph: "unavailable",
+            latency_ms: Math.round((performance.now() - start) * 100) / 100
+          }
+        },
+        503
+      );
+    }
+    const topN = 50;
+    const topNodes = await deps.localGraph.getCriticalNodes(topN);
+    const keys = topNodes.map((n) => n.key);
+    const testCountMap = /* @__PURE__ */ new Map();
+    if (keys.length > 0) {
+      try {
+        const directResult = await deps.localGraph.db.run(
+          `?[target, count(tk)] := *edges{from_key: tk, to_key: target, type: "tests"},
+            target in $keys`,
+          { keys }
+        );
+        for (const row of directResult.rows) {
+          testCountMap.set(row[0], row[1]);
+        }
+        const transitiveResult = await deps.localGraph.db.run(
+          `?[target, count(tk)] := *edges{from_key: mid, to_key: target, type: "calls"},
+            *edges{from_key: tk, to_key: mid, type: "tests"},
+            target in $keys`,
+          { keys }
+        );
+        for (const row of transitiveResult.rows) {
+          const k = row[0];
+          testCountMap.set(k, (testCountMap.get(k) ?? 0) + row[1]);
+        }
+      } catch {
+      }
+    }
+    let totalBlastRadius = 0;
+    let testedBlastRadius = 0;
+    let untestedBlastRadius = 0;
+    for (const n of topNodes) {
+      const weight = Math.max(n.fan_in, 1);
+      totalBlastRadius += weight;
+      if ((testCountMap.get(n.key) ?? 0) > 0) {
+        testedBlastRadius += weight;
+      } else {
+        untestedBlastRadius += weight;
+      }
+    }
+    const blastRadiusCoverage = totalBlastRadius > 0 ? Math.round(testedBlastRadius / totalBlastRadius * 100) : 0;
+    const bottlenecks = topNodes.filter(
+      (n) => n.fan_in >= 3 && n.fan_out >= 2 && (testCountMap.get(n.key) ?? 0) === 0
+    ).map((n) => ({
+      key: n.key,
+      name: n.name,
+      file_path: n.file_path,
+      kind: n.kind,
+      fan_in: n.fan_in,
+      fan_out: n.fan_out,
+      degree: n.degree,
+      risk_level: n.risk_level
+    }));
+    const riskDistribution = { high: 0, medium: 0, low: 0 };
+    for (const n of topNodes) {
+      const level = n.risk_level;
+      if (level in riskDistribution) riskDistribution[level]++;
+    }
+    const sortedByDegree = [...topNodes].sort((a, b) => b.degree - a.degree);
+    const totalDegree = topNodes.reduce((s, n) => s + n.degree, 0);
+    const top5Degree = sortedByDegree.slice(0, 5).reduce((s, n) => s + n.degree, 0);
+    const riskConcentration = totalDegree > 0 ? Math.round(top5Degree / totalDegree * 100) : 0;
+    const communityMap = /* @__PURE__ */ new Map();
+    for (const n of topNodes) {
+      const label = n.community_label || `cluster-${n.community}`;
+      let comm = communityMap.get(label);
+      if (!comm) {
+        comm = {
+          label,
+          entities: 0,
+          totalDegree: 0,
+          riskHigh: 0,
+          riskMedium: 0,
+          riskLow: 0,
+          untested: 0,
+          tested: 0,
+          totalFanIn: 0,
+          untestedFanIn: 0
+        };
+        communityMap.set(label, comm);
+      }
+      comm.entities++;
+      comm.totalDegree += n.degree;
+      comm.totalFanIn += n.fan_in;
+      const hasCoverage = (testCountMap.get(n.key) ?? 0) > 0;
+      if (hasCoverage) comm.tested++;
+      else {
+        comm.untested++;
+        comm.untestedFanIn += n.fan_in;
+      }
+      if (n.risk_level === "high") comm.riskHigh++;
+      else if (n.risk_level === "medium") comm.riskMedium++;
+      else comm.riskLow++;
+    }
+    const communityHealth = [];
+    for (const [, comm] of communityMap) {
+      const total = comm.tested + comm.untested;
+      communityHealth.push({
+        label: comm.label,
+        entities: comm.entities,
+        tested: comm.tested,
+        untested: comm.untested,
+        coveragePct: total > 0 ? Math.round(comm.tested / total * 100) : 0,
+        blastRadiusCoveragePct: comm.totalFanIn > 0 ? Math.round(
+          (comm.totalFanIn - comm.untestedFanIn) / comm.totalFanIn * 100
+        ) : 0,
+        riskHigh: comm.riskHigh,
+        riskMedium: comm.riskMedium,
+        riskLow: comm.riskLow,
+        totalDegree: comm.totalDegree
+      });
+    }
+    communityHealth.sort(
+      (a, b) => a.blastRadiusCoveragePct - b.blastRadiusCoveragePct
+    );
+    let mostCoupledPair = null;
+    try {
+      const fcResult = await deps.localGraph.db.run(
+        `?[from_label, to_label, w] :=
+          *file_edges{from_file, to_file, weight: w},
+          *file_communities{file_path: from_file, label: from_label},
+          *file_communities{file_path: to_file, label: to_label},
+          from_label != to_label
+         :order -w
+         :limit 1`
+      );
+      if (fcResult.rows.length > 0) {
+        const [from, to, weight] = fcResult.rows[0];
+        mostCoupledPair = { from, to, weight };
+      }
+    } catch {
+    }
+    const insights = [];
+    if (blastRadiusCoverage < 50) {
+      insights.push({
+        id: "blast-radius-coverage",
+        severity: "critical",
+        title: `Blast-radius coverage is only ${blastRadiusCoverage}%`,
+        description: `${untestedBlastRadius} dependency-weighted risk sits in untested code. Your entity-count coverage looks better but hides that your most-depended-on code is unprotected.`,
+        metric: blastRadiusCoverage,
+        metricLabel: "blast-radius coverage"
+      });
+    } else if (blastRadiusCoverage < 75) {
+      insights.push({
+        id: "blast-radius-coverage",
+        severity: "warning",
+        title: `Blast-radius coverage at ${blastRadiusCoverage}%`,
+        description: `Your most critical code paths are partially covered, but ${untestedBlastRadius} dependency-weight remains untested.`,
+        metric: blastRadiusCoverage,
+        metricLabel: "blast-radius coverage"
+      });
+    } else {
+      insights.push({
+        id: "blast-radius-coverage",
+        severity: "positive",
+        title: `Strong blast-radius coverage: ${blastRadiusCoverage}%`,
+        description: "Your highest-impact code paths are well tested. Regressions are unlikely to cascade silently.",
+        metric: blastRadiusCoverage,
+        metricLabel: "blast-radius coverage"
+      });
+    }
+    if (bottlenecks.length > 0) {
+      const totalBottleneckFanIn = bottlenecks.reduce(
+        (s, b) => s + b.fan_in,
+        0
+      );
+      insights.push({
+        id: "bottlenecks",
+        severity: bottlenecks.length >= 5 ? "critical" : "warning",
+        title: `${bottlenecks.length} structural bottleneck${bottlenecks.length !== 1 ? "s" : ""} with zero tests`,
+        description: `These functions have high fan-in AND fan-out \u2014 all dependency traffic flows through them. Combined, ${totalBottleneckFanIn} dependents are exposed. A failure in any one cascades in both directions.`,
+        metric: bottlenecks.length,
+        metricLabel: "bottlenecks"
+      });
+    }
+    if (riskConcentration > 40) {
+      insights.push({
+        id: "risk-concentration",
+        severity: riskConcentration > 60 ? "warning" : "info",
+        title: `${riskConcentration}% of structural risk concentrated in top 5 entities`,
+        description: `Your risk isn't spread evenly \u2014 a small number of entities carry most of the dependency weight. Focus testing and review here for maximum impact.`,
+        metric: riskConcentration,
+        metricLabel: "risk in top 5"
+      });
+    }
+    if (mostCoupledPair && mostCoupledPair.weight >= 3) {
+      insights.push({
+        id: "coupling-hotspot",
+        severity: mostCoupledPair.weight >= 10 ? "warning" : "info",
+        title: `"${mostCoupledPair.from}" and "${mostCoupledPair.to}" are tightly coupled`,
+        description: `${mostCoupledPair.weight} cross-boundary calls between these modules. Changes in one are likely to require changes in the other.`,
+        metric: mostCoupledPair.weight,
+        metricLabel: "cross-boundary calls"
+      });
+    }
+    if (riskDistribution.high === 0 && topNodes.length > 0) {
+      insights.push({
+        id: "no-high-risk",
+        severity: "positive",
+        title: "No high-risk entities detected",
+        description: "Your top entities are well-balanced with moderate dependency counts. The codebase structure is healthy."
+      });
+    }
+    const bottleneckPenalty = Math.min(bottlenecks.length * 5, 25);
+    const highRiskPenalty = Math.min(riskDistribution.high * 3, 15);
+    const concentrationPenalty = riskConcentration > 50 ? (riskConcentration - 50) * 0.4 : 0;
+    const healthScore = Math.max(
+      0,
+      Math.min(
+        100,
+        Math.round(
+          blastRadiusCoverage * 0.4 + (100 - bottleneckPenalty) * 0.25 + (100 - concentrationPenalty) * 0.2 + (100 - highRiskPenalty) * 0.15
+        )
+      )
+    );
+    const healthGrade = healthScore >= 90 ? "A" : healthScore >= 80 ? "B" : healthScore >= 65 ? "C" : healthScore >= 50 ? "D" : "F";
+    return c.json({
+      data: {
+        healthScore,
+        healthGrade,
+        blastRadiusCoverage,
+        untestedBlastRadius,
+        testedBlastRadius,
+        totalBlastRadius,
+        bottlenecks,
+        riskDistribution,
+        riskConcentration,
+        communityHealth,
+        mostCoupledPair,
+        insights
+      },
+      _meta: {
+        source: "local",
+        entities_analyzed: topNodes.length,
+        latency_ms: Math.round((performance.now() - start) * 100) / 100
+      }
+    });
+  });
   app.get("/durability", async (c) => {
     const start = performance.now();
     const limit = parseLimit(c.req.query("ledger_limit"), 800, 5e3);
@@ -30753,13 +31484,13 @@ function createSystemRoutes(deps) {
   });
   app.get("/config", async (c) => {
     const start = performance.now();
-    const { existsSync: existsSync62, readFileSync: readFileSync56 } = await import("fs");
-    const { join: join67 } = await import("path");
+    const { existsSync: existsSync63, readFileSync: readFileSync57 } = await import("fs");
+    const { join: join68 } = await import("path");
     let config = {};
-    const configPath = join67(deps.cwd, ".unerr", "config.json");
-    if (existsSync62(configPath)) {
+    const configPath = join68(deps.cwd, ".unerr", "config.json");
+    if (existsSync63(configPath)) {
       try {
-        config = JSON.parse(readFileSync56(configPath, "utf-8"));
+        config = JSON.parse(readFileSync57(configPath, "utf-8"));
       } catch {
         config = { error: "unreadable" };
       }
@@ -30960,20 +31691,20 @@ __export(session_history_exports, {
   getWeeklyStats: () => getWeeklyStats,
   readSessionHistory: () => readSessionHistory
 });
-import { appendFileSync as appendFileSync8, existsSync as existsSync54, mkdirSync as mkdirSync33, readFileSync as readFileSync50 } from "fs";
-import { join as join59 } from "path";
+import { appendFileSync as appendFileSync8, existsSync as existsSync55, mkdirSync as mkdirSync33, readFileSync as readFileSync51 } from "fs";
+import { join as join60 } from "path";
 function appendSessionHistory(unerrDir, entry) {
-  const stateDir = join59(unerrDir, "state");
-  if (!existsSync54(stateDir)) mkdirSync33(stateDir, { recursive: true });
-  const historyPath = join59(stateDir, "session-history.jsonl");
+  const stateDir = join60(unerrDir, "state");
+  if (!existsSync55(stateDir)) mkdirSync33(stateDir, { recursive: true });
+  const historyPath = join60(stateDir, "session-history.jsonl");
   appendFileSync8(historyPath, `${JSON.stringify(entry)}
 `, "utf-8");
 }
 function readSessionHistory(unerrDir) {
-  const historyPath = join59(unerrDir, "state", "session-history.jsonl");
-  if (!existsSync54(historyPath)) return [];
+  const historyPath = join60(unerrDir, "state", "session-history.jsonl");
+  if (!existsSync55(historyPath)) return [];
   try {
-    const content = readFileSync50(historyPath, "utf-8");
+    const content = readFileSync51(historyPath, "utf-8");
     return content.split("\n").filter(Boolean).map((line) => {
       try {
         return JSON.parse(line);
@@ -31211,7 +31942,7 @@ function createTokenFlowRoutes(deps) {
         first_ts: data.first_ts,
         last_ts: data.last_ts,
         mechanisms: [...data.mechanisms],
-        agent_name: agentBySession.get(id) ?? null
+        agent_name: agentBySession.get(id) ?? deps.getAgentName?.(id) ?? null
       };
     }).sort((a, b) => b.last_ts.localeCompare(a.last_ts));
     const paginated = allSessions.slice(offset, offset + limit);
@@ -31350,18 +32081,297 @@ var init_token_flow2 = __esm({
   }
 });
 
+// src/server/routes/reasoning-quality.ts
+import { Hono as Hono7 } from "hono";
+function computeQualityMetrics(events) {
+  if (events.length === 0) {
+    return {
+      signal_to_noise_ratio: 0,
+      noise_removed_pct: 0,
+      context_density: 0,
+      entities_resolved: 0,
+      graph_tokens_delivered: 0,
+      attention_multiplier: 1,
+      first_call_resolution_rate: 0,
+      graph_calls: 0,
+      total_tool_calls: 0,
+      turns_saved: 0,
+      exploration_loops_prevented: 0,
+      blast_radius_warnings: 0,
+      circuit_breaker_activations: 0,
+      convention_injections: 0,
+      prevention_score: 0,
+      reasoning_quality_multiplier: 0,
+      total_sessions: 0,
+      total_turns: 0,
+      total_events: 0
+    };
+  }
+  let totalWithout = 0;
+  let totalWith = 0;
+  let graphCalls = 0;
+  let graphTokensDelivered = 0;
+  let shellCompressionEvents = 0;
+  let behaviorEvents = 0;
+  let blastRadiusWarnings = 0;
+  let circuitBreakerActivations = 0;
+  let conventionInjections = 0;
+  let explorationLoopsPrevented = 0;
+  let dedupEvents = 0;
+  const sessions = /* @__PURE__ */ new Set();
+  const turns = /* @__PURE__ */ new Set();
+  for (const e of events) {
+    totalWithout += e.tokens_without;
+    totalWith += e.tokens_with;
+    sessions.add(e.session_id);
+    turns.add(`${e.session_id}:${e.turn}`);
+    if (GRAPH_MECHANISMS.has(e.mechanism)) {
+      graphCalls++;
+      graphTokensDelivered += e.tokens_with;
+    }
+    if (SHELL_MECHANISMS.has(e.mechanism)) {
+      shellCompressionEvents++;
+    }
+    if (SAFETY_MECHANISMS.has(e.mechanism)) {
+      behaviorEvents++;
+    }
+    const d = e.detail;
+    if (d) {
+      if (d.counterfactual === "blast_radius" || d.blast_radius) {
+        blastRadiusWarnings++;
+      }
+      if (d.circuit_breaker || d.counterfactual === "circuit_breaker") {
+        circuitBreakerActivations++;
+      }
+      if (d.conventions_injected || d.counterfactual === "convention_injection") {
+        conventionInjections++;
+      }
+      if (d.hook_redirect || d.counterfactual === "hook_redirect") {
+        explorationLoopsPrevented++;
+      }
+    }
+    if (e.mechanism === "session_dedup") {
+      dedupEvents++;
+    }
+  }
+  const totalSaved = totalWithout - totalWith;
+  const totalToolCalls = events.length;
+  const snr = totalWithout > 0 ? totalWith / totalWithout : 0;
+  const noiseRemovedPct = totalWithout > 0 ? Math.round((totalWithout - totalWith) / totalWithout * 100) : 0;
+  const contextDensity = graphTokensDelivered > 0 ? Math.round(graphCalls / (graphTokensDelivered / 1e3) * 10) / 10 : 0;
+  const compressionRatio = totalWith > 0 ? totalWithout / totalWith : 1;
+  const attentionMultiplier = Math.round(Math.sqrt(compressionRatio) * 100) / 100;
+  const firstCallRate = totalToolCalls > 0 ? Math.round(graphCalls / totalToolCalls * 100) : 0;
+  const turnsSaved = Math.round(graphCalls * 2.5);
+  const totalConventionInjections = conventionInjections + behaviorEvents;
+  const preventionScore = blastRadiusWarnings + circuitBreakerActivations * 10 + totalConventionInjections;
+  const firstCallRateDecimal = firstCallRate / 100;
+  const reasoningMultiplier = compressionRatio > 0 && firstCallRateDecimal > 0 ? Math.round(compressionRatio * (1 + firstCallRateDecimal) * 100) / 100 : 0;
+  return {
+    signal_to_noise_ratio: Math.round(snr * 1e3) / 1e3,
+    noise_removed_pct: noiseRemovedPct,
+    context_density: contextDensity,
+    entities_resolved: graphCalls,
+    graph_tokens_delivered: graphTokensDelivered,
+    attention_multiplier: attentionMultiplier,
+    first_call_resolution_rate: firstCallRate,
+    graph_calls: graphCalls,
+    total_tool_calls: totalToolCalls,
+    turns_saved: turnsSaved,
+    exploration_loops_prevented: explorationLoopsPrevented,
+    blast_radius_warnings: blastRadiusWarnings,
+    circuit_breaker_activations: circuitBreakerActivations,
+    convention_injections: totalConventionInjections,
+    prevention_score: preventionScore,
+    reasoning_quality_multiplier: reasoningMultiplier,
+    total_sessions: sessions.size,
+    total_turns: turns.size,
+    total_events: events.length
+  };
+}
+function createReasoningQualityRoutes(deps) {
+  const app = new Hono7();
+  app.get("/global", (c) => {
+    const start = performance.now();
+    const fromTs = c.req.query("from_ts");
+    const toTs = c.req.query("to_ts");
+    const events = readTokenFlowEvents(deps.unerrDir, {
+      from_ts: fromTs || void 0,
+      to_ts: toTs || void 0
+    });
+    const metrics = computeQualityMetrics(events);
+    return c.json({
+      data: metrics,
+      _meta: { latency_ms: Math.round((performance.now() - start) * 100) / 100 }
+    });
+  });
+  app.get("/session", (c) => {
+    const start = performance.now();
+    const querySessionId = c.req.query("session_id");
+    const writer = deps.getTokenFlowWriter();
+    const allEvents = readTokenFlowEvents(deps.unerrDir);
+    if (allEvents.length === 0) {
+      return c.json({ data: null, _meta: { latency_ms: 0 } });
+    }
+    let sessionId = querySessionId || writer?.sessionId;
+    if (!sessionId) {
+      sessionId = allEvents[allEvents.length - 1]?.session_id;
+    }
+    if (!sessionId) {
+      return c.json({ data: null, _meta: { latency_ms: 0 } });
+    }
+    const sessionEvents = querySessionId ? allEvents.filter((e) => e.session_id === sessionId) : allEvents.filter((e) => e.session_id === sessionId || e.session_id === "unknown");
+    const metrics = computeQualityMetrics(sessionEvents);
+    const turnGroups = /* @__PURE__ */ new Map();
+    for (const e of sessionEvents) {
+      const group = turnGroups.get(e.turn) ?? [];
+      group.push(e);
+      turnGroups.set(e.turn, group);
+    }
+    const trajectory = [];
+    let cumWithout = 0;
+    let cumWith = 0;
+    for (const [turn, turnEvents] of [...turnGroups.entries()].sort(([a], [b]) => a - b)) {
+      let turnGraphCalls = 0;
+      let turnGraphDelivered = 0;
+      for (const e of turnEvents) {
+        cumWithout += e.tokens_without;
+        cumWith += e.tokens_with;
+        if (GRAPH_MECHANISMS.has(e.mechanism)) {
+          turnGraphCalls++;
+          turnGraphDelivered += e.tokens_with;
+        }
+      }
+      trajectory.push({
+        turn,
+        snr: cumWithout > 0 ? Math.round(cumWith / cumWithout * 1e3) / 1e3 : 0,
+        cumulative_noise_removed_pct: cumWithout > 0 ? Math.round((cumWithout - cumWith) / cumWithout * 100) : 0,
+        graph_calls_this_turn: turnGraphCalls,
+        context_density: turnGraphDelivered > 0 ? Math.round(turnGraphCalls / (turnGraphDelivered / 1e3) * 10) / 10 : 0
+      });
+    }
+    return c.json({
+      data: {
+        ...metrics,
+        session_id: sessionId,
+        trajectory
+      },
+      _meta: { latency_ms: Math.round((performance.now() - start) * 100) / 100 }
+    });
+  });
+  app.get("/sessions", (c) => {
+    const start = performance.now();
+    const fromTs = c.req.query("from_ts");
+    const toTs = c.req.query("to_ts");
+    const limit = Math.min(Number(c.req.query("limit") ?? 50), 200);
+    const offset = Math.max(Number(c.req.query("offset") ?? 0), 0);
+    const allEvents = readTokenFlowEvents(deps.unerrDir, {
+      from_ts: fromTs || void 0,
+      to_ts: toTs || void 0
+    });
+    const historyEntries = readSessionHistory(deps.unerrDir);
+    const agentBySession = /* @__PURE__ */ new Map();
+    for (const h of historyEntries) {
+      if (h.agentName) agentBySession.set(h.sessionId, h.agentName);
+    }
+    const sessionMap = /* @__PURE__ */ new Map();
+    for (const e of allEvents) {
+      const group = sessionMap.get(e.session_id) ?? [];
+      group.push(e);
+      sessionMap.set(e.session_id, group);
+    }
+    const allSessions = [...sessionMap.entries()].map(([sessionId, events]) => {
+      const m = computeQualityMetrics(events);
+      const lastTs = events.reduce((max, e) => e.ts > max ? e.ts : max, events[0].ts);
+      const firstTs = events.reduce((min, e) => e.ts < min ? e.ts : min, events[0].ts);
+      return {
+        session_id: sessionId,
+        first_ts: firstTs,
+        last_ts: lastTs,
+        agent_name: agentBySession.get(sessionId) ?? deps.getAgentName?.(sessionId) ?? null,
+        noise_removed_pct: m.noise_removed_pct,
+        first_call_resolution_rate: m.first_call_resolution_rate,
+        prevention_score: m.prevention_score,
+        reasoning_quality_multiplier: m.reasoning_quality_multiplier,
+        context_density: m.context_density,
+        turns_saved: m.turns_saved,
+        total_events: m.total_events,
+        total_turns: m.total_turns
+      };
+    }).sort((a, b) => b.last_ts.localeCompare(a.last_ts));
+    const paginated = allSessions.slice(offset, offset + limit);
+    return c.json({
+      data: paginated,
+      total: allSessions.length,
+      limit,
+      offset,
+      _meta: { latency_ms: Math.round((performance.now() - start) * 100) / 100 }
+    });
+  });
+  app.get("/trend", (c) => {
+    const start = performance.now();
+    const fromTs = c.req.query("from_ts");
+    const toTs = c.req.query("to_ts");
+    const allEvents = readTokenFlowEvents(deps.unerrDir, {
+      from_ts: fromTs || void 0,
+      to_ts: toTs || void 0
+    });
+    const sessionMap = /* @__PURE__ */ new Map();
+    for (const e of allEvents) {
+      const group = sessionMap.get(e.session_id) ?? [];
+      group.push(e);
+      sessionMap.set(e.session_id, group);
+    }
+    const trend = [...sessionMap.entries()].map(([sessionId, events]) => {
+      const m = computeQualityMetrics(events);
+      const firstTs = events.reduce((min, e) => e.ts < min ? e.ts : min, events[0].ts);
+      const lastTs = events.reduce((max, e) => e.ts > max ? e.ts : max, events[0].ts);
+      return {
+        session_id: sessionId,
+        first_ts: firstTs,
+        last_ts: lastTs,
+        noise_removed_pct: m.noise_removed_pct,
+        first_call_resolution_rate: m.first_call_resolution_rate,
+        prevention_score: m.prevention_score,
+        reasoning_quality_multiplier: m.reasoning_quality_multiplier,
+        context_density: m.context_density,
+        attention_multiplier: m.attention_multiplier,
+        turns_saved: m.turns_saved,
+        total_events: m.total_events
+      };
+    }).sort((a, b) => a.first_ts.localeCompare(b.first_ts));
+    return c.json({
+      data: trend,
+      total: trend.length,
+      _meta: { latency_ms: Math.round((performance.now() - start) * 100) / 100 }
+    });
+  });
+  return app;
+}
+var GRAPH_MECHANISMS, SHELL_MECHANISMS, SAFETY_MECHANISMS;
+var init_reasoning_quality = __esm({
+  "src/server/routes/reasoning-quality.ts"() {
+    "use strict";
+    init_token_flow();
+    init_session_history();
+    GRAPH_MECHANISMS = /* @__PURE__ */ new Set(["graph_query", "file_read"]);
+    SHELL_MECHANISMS = /* @__PURE__ */ new Set(["shell_compression"]);
+    SAFETY_MECHANISMS = /* @__PURE__ */ new Set(["behavior_automation"]);
+  }
+});
+
 // src/server/http.ts
 var http_exports = {};
 __export(http_exports, {
   startDashboardServer: () => startDashboardServer
 });
-import { existsSync as existsSync55, readFileSync as readFileSync51, unlinkSync as unlinkSync8, writeFileSync as writeFileSync32 } from "fs";
+import { existsSync as existsSync56, readFileSync as readFileSync52, unlinkSync as unlinkSync8, writeFileSync as writeFileSync32 } from "fs";
 import { createServer as createServer3 } from "net";
-import { dirname as dirname7, join as join60 } from "path";
-import { fileURLToPath } from "url";
+import { dirname as dirname7, join as join61 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
-import { Hono as Hono7 } from "hono";
+import { Hono as Hono8 } from "hono";
 async function findAvailablePort() {
   for (let port = PORT_START; port <= PORT_END; port++) {
     const available = await new Promise((resolve3) => {
@@ -31385,7 +32395,7 @@ async function startDashboardServer(opts) {
     return null;
   }
   opts.system.dashboardPort = port;
-  const app = new Hono7();
+  const app = new Hono8();
   app.use("*", corsMiddleware);
   app.use("*", cacheMiddleware);
   app.use("*", timingMiddleware);
@@ -31400,10 +32410,13 @@ async function startDashboardServer(opts) {
   if (opts.tokenFlow) {
     app.route("/api/token-flow", createTokenFlowRoutes(opts.tokenFlow));
   }
-  const distDir = join60(dirname7(fileURLToPath(import.meta.url)), "ui");
-  const spaIndex = join60(distDir, "index.html");
-  if (existsSync55(spaIndex)) {
-    const spaHtml = readFileSync51(spaIndex, "utf-8");
+  if (opts.reasoningQuality) {
+    app.route("/api/reasoning-quality", createReasoningQualityRoutes(opts.reasoningQuality));
+  }
+  const distDir = join61(dirname7(fileURLToPath2(import.meta.url)), "ui");
+  const spaIndex = join61(distDir, "index.html");
+  if (existsSync56(spaIndex)) {
+    const spaHtml = readFileSync52(spaIndex, "utf-8");
     app.use("*", serveStatic({ root: distDir }));
     app.get("*", (c) => {
       const path7 = c.req.path;
@@ -31432,7 +32445,7 @@ async function startDashboardServer(opts) {
     port,
     hostname: "127.0.0.1"
   });
-  const serverJsonPath = join60(opts.stateDir, "server.json");
+  const serverJsonPath = join61(opts.stateDir, "server.json");
   const serverInfo = {
     port,
     pid: process.pid,
@@ -31466,6 +32479,7 @@ var init_http = __esm({
     init_system();
     init_temporal();
     init_token_flow2();
+    init_reasoning_quality();
     PORT_START = 7600;
     PORT_END = 7700;
   }
@@ -31833,13 +32847,13 @@ var proxy_exports = {};
 __export(proxy_exports, {
   startProxy: () => startProxy
 });
-import { existsSync as existsSync56, mkdirSync as mkdirSync34, readFileSync as readFileSync52, readdirSync as readdirSync12 } from "fs";
-import { join as join61 } from "path";
+import { existsSync as existsSync57, mkdirSync as mkdirSync34, readFileSync as readFileSync53, readdirSync as readdirSync13, writeFileSync as fsWriteFileSync } from "fs";
+import { join as join62 } from "path";
 async function getProxyFactStore(unerrDir) {
   if (proxyFactStore !== void 0) return proxyFactStore;
   try {
     const { TemporalFactStore: TemporalFactStore2 } = await Promise.resolve().then(() => (init_temporal_facts(), temporal_facts_exports));
-    const cwd = join61(unerrDir, "..");
+    const cwd = join62(unerrDir, "..");
     proxyFactStore = await TemporalFactStore2.create(cwd);
     return proxyFactStore;
   } catch {
@@ -31917,15 +32931,32 @@ 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");
+    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);
+    fsWriteFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    process.stderr.write("[unerr] Migrated permissions: removed Read from deny list (required for Edit workflow)\n");
+  } catch {
+  }
+}
 async function startProxy(opts = {}) {
   const stats = createSessionStats(true);
   const startup = new StartupRenderer();
   startup.mount();
+  migrateAgentPermissions(process.cwd());
   const lifecycle = createLifecycleActor(process.cwd());
   lifecycle.send({ type: "START_DETECT" });
   startup.setLocalMode(true);
-  const stateDir = join61(process.cwd(), ".unerr", "state");
-  if (!existsSync56(stateDir)) {
+  const stateDir = join62(process.cwd(), ".unerr", "state");
+  if (!existsSync57(stateDir)) {
     mkdirSync34(stateDir, { recursive: true });
   }
   const pidLock = new PidLock(stateDir);
@@ -31943,7 +32974,7 @@ async function startProxy(opts = {}) {
   startupLog.step(
     `PID ${process.pid} ${startupLog.fmt.muted(`\xB7 health localhost:${lockResult.healthPort}`)}`
   );
-  const ledgerDir = join61(process.cwd(), ".unerr", "ledger");
+  const ledgerDir = join62(process.cwd(), ".unerr", "ledger");
   const previousSession = detectSessionResume(stateDir, ledgerDir);
   if (previousSession) {
     stats.isResumedSession = true;
@@ -31958,17 +32989,17 @@ async function startProxy(opts = {}) {
   if (opts.repoId) {
     repoIds = [opts.repoId];
   } else {
-    const configPath = join61(process.cwd(), ".unerr", "config.json");
-    if (existsSync56(configPath)) {
+    const configPath = join62(process.cwd(), ".unerr", "config.json");
+    if (existsSync57(configPath)) {
       try {
-        const config = JSON.parse(readFileSync52(configPath, "utf-8"));
+        const config = JSON.parse(readFileSync53(configPath, "utf-8"));
         if (config.repoId) repoIds = [config.repoId];
       } catch {
       }
     }
-    const manifestsDir = join61(process.cwd(), ".unerr", "manifests");
-    if (repoIds.length === 0 && existsSync56(manifestsDir)) {
-      repoIds = readdirSync12(manifestsDir).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
+    const manifestsDir = join62(process.cwd(), ".unerr", "manifests");
+    if (repoIds.length === 0 && existsSync57(manifestsDir)) {
+      repoIds = readdirSync13(manifestsDir).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
     }
   }
   if (repoIds.length === 0) {
@@ -32048,13 +33079,10 @@ async function startProxy(opts = {}) {
         startupLog.perf(
           `${startupLog.fmt.cyan("Persistent graph")} ${startupLog.fmt.muted("\u2014 zero recomputation, all intelligence preserved")}`
         );
-        const { shouldReindex: shouldReindex2 } = await Promise.resolve().then(() => (init_local_snapshot(), local_snapshot_exports));
-        if (shouldReindex2(projectRoot)) {
-          needsBackgroundIndex = true;
-          startupLog.step(
-            `${startupLog.fmt.muted("Source changes detected \u2014 incremental update after MCP ready")}`
-          );
-        }
+        needsBackgroundIndex = true;
+        startupLog.step(
+          `${startupLog.fmt.muted("Background reindex will refresh graph data after MCP ready")}`
+        );
       } else {
         const { loadLocalSnapshot: loadLocalSnapshot2 } = await Promise.resolve().then(() => (init_local_snapshot(), local_snapshot_exports));
         const snapshotStart = Date.now();
@@ -32094,6 +33122,32 @@ async function startProxy(opts = {}) {
           startupLog.done(
             `Migrated snapshot to persistent graph ${startupLog.fmt.muted(`\u2192 ${dbPath}`)}`
           );
+          try {
+            const migrationUnerrDir = join62(process.cwd(), ".unerr");
+            const factStoreForMigration = await getProxyFactStore(migrationUnerrDir);
+            if (factStoreForMigration) {
+              const { detectLocalConventions: detectLocalConventions2 } = await Promise.resolve().then(() => (init_local_convention_detector(), local_convention_detector_exports));
+              const { generateFromConventions: generateFromConventions2, runFactGenerationPipeline: runFactGenerationPipeline2 } = await Promise.resolve().then(() => (init_fact_generator(), fact_generator_exports));
+              const detection = await detectLocalConventions2(localGraph.db);
+              if (detection.conventions.length > 0) {
+                const convResult = await generateFromConventions2(factStoreForMigration, detection.conventions);
+                if (convResult.created > 0 || convResult.reinforced > 0) {
+                  log21.info(
+                    `Fact generator: ${convResult.created} convention facts created, ${convResult.reinforced} reinforced`
+                  );
+                }
+              }
+              const pipelineResults = await runFactGenerationPipeline2(factStoreForMigration, migrationUnerrDir);
+              for (const r of pipelineResults) {
+                if (r.created > 0 || r.reinforced > 0) {
+                  log21.info(
+                    `Fact generator [${r.source}]: ${r.created} created, ${r.reinforced} reinforced`
+                  );
+                }
+              }
+            }
+          } catch {
+          }
         } else {
           needsBackgroundIndex = true;
           startupLog.step(
@@ -32161,7 +33215,7 @@ async function startProxy(opts = {}) {
     try {
       const { generateSessionResume: generateSessionResume2 } = await Promise.resolve().then(() => (init_session_resume(), session_resume_exports));
       const { ShadowLedger: ResumeLedger } = await Promise.resolve().then(() => (init_shadow_ledger(), shadow_ledger_exports));
-      const resumeLedger = new ResumeLedger(join61(process.cwd(), ".unerr"));
+      const resumeLedger = new ResumeLedger(join62(process.cwd(), ".unerr"));
       const ledgerEntries = resumeLedger.getRecentEntries(50);
       const resumeCtx = generateSessionResume2(ledgerEntries);
       if (resumeCtx) {
@@ -32181,7 +33235,7 @@ async function startProxy(opts = {}) {
     const { createDurabilityScorer: createDurabilityScorer2 } = await Promise.resolve().then(() => (init_durability_scorer(), durability_scorer_exports));
     const durabilityScorer = createDurabilityScorer2();
     const { ShadowLedger: DurLedger } = await Promise.resolve().then(() => (init_shadow_ledger(), shadow_ledger_exports));
-    const durLedger = new DurLedger(join61(process.cwd(), ".unerr"));
+    const durLedger = new DurLedger(join62(process.cwd(), ".unerr"));
     const durEntries = durLedger.getRecentEntries(200);
     if (durEntries.length > 0) {
       durabilityScorer.computeScores(durEntries);
@@ -32201,7 +33255,7 @@ async function startProxy(opts = {}) {
   try {
     const { detectInstableEntities: detectInstableEntities2 } = await Promise.resolve().then(() => (init_negative_knowledge(), negative_knowledge_exports));
     const { ShadowLedger: NkLedger } = await Promise.resolve().then(() => (init_shadow_ledger(), shadow_ledger_exports));
-    const nkLedger = new NkLedger(join61(process.cwd(), ".unerr"));
+    const nkLedger = new NkLedger(join62(process.cwd(), ".unerr"));
     const nkEntries = nkLedger.getRecentEntries(200);
     if (nkEntries.length > 0) {
       const antiPatterns = detectInstableEntities2(nkEntries);
@@ -32223,7 +33277,7 @@ async function startProxy(opts = {}) {
   try {
     const { CausalBridge: CausalBridge2 } = await Promise.resolve().then(() => (init_causal_bridge(), causal_bridge_exports));
     const causalBridge = new CausalBridge2(
-      join61(process.cwd(), ".unerr"),
+      join62(process.cwd(), ".unerr"),
       process.cwd()
     );
     router2.setCausalBridge(causalBridge);
@@ -32233,7 +33287,7 @@ async function startProxy(opts = {}) {
   try {
     const { learnConventions: learnConventions2 } = await Promise.resolve().then(() => (init_convention_learner(), convention_learner_exports));
     const { ShadowLedger: ConvLedger } = await Promise.resolve().then(() => (init_shadow_ledger(), shadow_ledger_exports));
-    const convLedger = new ConvLedger(join61(process.cwd(), ".unerr"));
+    const convLedger = new ConvLedger(join62(process.cwd(), ".unerr"));
     const convEntries = convLedger.getRecentEntries(100);
     if (convEntries.length > 0) {
       const learned = learnConventions2(convEntries);
@@ -32256,7 +33310,7 @@ async function startProxy(opts = {}) {
   try {
     const { computePromptDurabilityProfiles: computePromptDurabilityProfiles2 } = await Promise.resolve().then(() => (init_prompt_durability(), prompt_durability_exports));
     const { ShadowLedger: DurProfLedger } = await Promise.resolve().then(() => (init_shadow_ledger(), shadow_ledger_exports));
-    const durProfLedger = new DurProfLedger(join61(process.cwd(), ".unerr"));
+    const durProfLedger = new DurProfLedger(join62(process.cwd(), ".unerr"));
     const durProfEntries = durProfLedger.getRecentEntries(200);
     if (durProfEntries.length > 0) {
       const profiles = computePromptDurabilityProfiles2(durProfEntries);
@@ -32276,7 +33330,7 @@ async function startProxy(opts = {}) {
   }
   try {
     const { createContextLedger: createContextLedger2 } = await Promise.resolve().then(() => (init_context_ledger(), context_ledger_exports));
-    const contextLedger = createContextLedger2(join61(process.cwd(), ".unerr"));
+    const contextLedger = createContextLedger2(join62(process.cwd(), ".unerr"));
     contextLedger.load();
     contextLedger.prune();
     router2.setContextLedger(contextLedger);
@@ -32365,7 +33419,7 @@ async function startProxy(opts = {}) {
   }));
   const { ShadowLedger: ShadowLedger2 } = await Promise.resolve().then(() => (init_shadow_ledger(), shadow_ledger_exports));
   const { IntentCorrelator: IntentCorrelator2 } = await Promise.resolve().then(() => (init_intent_correlator(), intent_correlator_exports));
-  const unerrDirForLedger = join61(process.cwd(), ".unerr");
+  const unerrDirForLedger = join62(process.cwd(), ".unerr");
   const shadowLedger2 = new ShadowLedger2(unerrDirForLedger);
   const intentCorrelator = new IntentCorrelator2(unerrDirForLedger);
   log21.info(
@@ -32379,7 +33433,7 @@ async function startProxy(opts = {}) {
   process.env.UNERR_SESSION_ID = shadowLedger2.getSessionId();
   try {
     const { writeFileSync: writeFileSync36 } = await import("fs");
-    writeFileSync36(join61(unerrDirForLedger, "state", "session.id"), shadowLedger2.getSessionId(), "utf-8");
+    writeFileSync36(join62(unerrDirForLedger, "state", "session.id"), shadowLedger2.getSessionId(), "utf-8");
   } catch {
   }
   router2.setTokenFlow(tokenFlowWriter2);
@@ -32718,8 +33772,9 @@ async function startProxy(opts = {}) {
   lifecycle.send({ type: "INDEX_COMPLETE" });
   lifecycle.send({ type: "MCP_READY" });
   const { TransportMux: TransportMux2 } = await Promise.resolve().then(() => (init_transport_mux(), transport_mux_exports));
-  const sockPath = join61(stateDir, "proxy.sock");
+  const sockPath = join62(stateDir, "proxy.sock");
   const transportMux = new TransportMux2(sockPath);
+  const agentNameByClient = /* @__PURE__ */ new Map();
   transportMux.setCustomHttpHandler("/commit-context", (_url) => {
     const { getCommitTrailers: getCommitTrailers2 } = (init_git_trailers(), __toCommonJS(git_trailers_exports));
     const branch = branchContext?.currentBranch ?? "unknown";
@@ -32729,6 +33784,10 @@ async function startProxy(opts = {}) {
   });
   transportMux.setHandler(async (clientId, message) => {
     if (message.method === "initialize") {
+      const clientName = message.params?.clientInfo?.name;
+      if (clientName) {
+        agentNameByClient.set(clientId, clientName);
+      }
       return {
         jsonrpc: "2.0",
         id: message.id,
@@ -32757,6 +33816,88 @@ async function startProxy(opts = {}) {
         };
       }
       const { name, arguments: toolArgs = {} } = params;
+      toolUsageTracker2.record(name);
+      if (name === "record_fact") {
+        const factResult = await handleRecordFactProxy(toolArgs, unerrDirForLedger, shadowLedger2);
+        return { jsonrpc: "2.0", result: factResult };
+      }
+      if (name === "recall_facts") {
+        const factResult = await handleRecallFactsProxy(toolArgs, unerrDirForLedger);
+        return { jsonrpc: "2.0", result: factResult };
+      }
+      if (name === "unerr_mark_working") {
+        const branch2 = branchContext?.currentBranch ?? "unknown";
+        const headSha2 = branchContext?.headSha ?? "";
+        const snapshot = workingSnapshotStore.create({
+          commitSha: headSha2,
+          reason: toolArgs.reason ?? "manual mark",
+          branch: branch2,
+          timelineBranch: workingSnapshotStore.getTimelineBranch(),
+          sessionId: shadowLedger2.getSessionId()
+        });
+        shadowLedger2.record(name, toolArgs, { snapshot_id: snapshot.id, commit: headSha2 }, branch2, headSha2);
+        return {
+          jsonrpc: "2.0",
+          result: {
+            content: [{ type: "text", text: stringifyMcpToolJson({ snapshot_id: snapshot.id, commit_sha: snapshot.commitSha, reason: snapshot.reason, timestamp: snapshot.timestamp, branch: snapshot.branch }) }],
+            _meta: { source: "local", latency_ms: 0, format: "json" }
+          }
+        };
+      }
+      if (name === "unerr_revert_to_working_state") {
+        const { revertToWorkingState: revertToWorkingState2 } = await Promise.resolve().then(() => (init_rewind_engine(), rewind_engine_exports));
+        const revertResult = await revertToWorkingState2({
+          snapshotId: toolArgs.snapshot_id ?? "latest",
+          cwd: process.cwd(),
+          unerrDir: unerrDirForLedger,
+          graph: graphForRouter,
+          ledger: shadowLedger2,
+          snapshotStore: workingSnapshotStore,
+          dryRun: toolArgs.dry_run ?? false
+        });
+        const branch2 = branchContext?.currentBranch ?? "unknown";
+        const headSha2 = branchContext?.headSha ?? "";
+        shadowLedger2.record(name, toolArgs, { success: revertResult.success, snapshot_id: revertResult.snapshot?.id, files_restored: revertResult.rewindResult?.filesRestored.length ?? 0 }, branch2, headSha2);
+        return {
+          jsonrpc: "2.0",
+          result: {
+            content: [{ type: "text", text: stringifyMcpToolJson(revertResult) }],
+            _meta: { source: "local", latency_ms: 0, format: "json" }
+          }
+        };
+      }
+      if (name === "unerr_get_timeline") {
+        const { getTimeline: getTimeline2 } = await Promise.resolve().then(() => (init_timeline(), timeline_exports));
+        const branch2 = branchContext?.currentBranch ?? "unknown";
+        const timelineBranch = workingSnapshotStore.getTimelineBranch();
+        const timeline = getTimeline2(shadowLedger2, branch2, timelineBranch, {
+          branch: toolArgs.branch,
+          limit: toolArgs.limit,
+          tool: toolArgs.tool,
+          rootsOnly: toolArgs.roots_only
+        });
+        return {
+          jsonrpc: "2.0",
+          result: {
+            content: [{ type: "text", text: stringifyMcpToolJson(timeline) }],
+            _meta: { source: "local", latency_ms: 0, format: "json" }
+          }
+        };
+      }
+      if (localGraph) {
+        const { handleDeepDiveTool: handleDeepDiveTool2 } = await Promise.resolve().then(() => (init_deep_dive_tools(), deep_dive_tools_exports));
+        const deepDiveResult = await handleDeepDiveTool2(name, toolArgs, localGraph);
+        if (deepDiveResult) {
+          recordToolCall(stats);
+          recordLatency(stats.latency, 0);
+          pidLock.recordToolCall();
+          if (stats.localMode) recordGraphQuery(stats.localMode, name);
+          const branch2 = branchContext?.currentBranch ?? "unknown";
+          const headSha2 = branchContext?.headSha ?? "";
+          shadowLedger2.record(name, toolArgs, { tool: name, source: "local", client: clientId }, branch2, headSha2);
+          return { jsonrpc: "2.0", result: deepDiveResult };
+        }
+      }
       const result = await router2.execute(name, toolArgs);
       recordToolCall(stats);
       recordLatency(stats.latency, result._meta.latency_ms);
@@ -32829,7 +33970,7 @@ async function startProxy(opts = {}) {
     try {
       const { DriftTracker: DriftTracker2 } = await Promise.resolve().then(() => (init_drift_tracker(), drift_tracker_exports));
       const { FileHashManager: FileHashManager2 } = await Promise.resolve().then(() => (init_file_hash_state(), file_hash_state_exports));
-      const unerrDir = join61(process.cwd(), ".unerr");
+      const unerrDir = join62(process.cwd(), ".unerr");
       const fileHashManager = new FileHashManager2(unerrDir);
       _driftTracker = new DriftTracker2(
         { projectRoot: process.cwd(), repoId: repoIds[0], unerrDir },
@@ -32974,6 +34115,32 @@ async function startProxy(opts = {}) {
             `Post-index DriftTracker init failed: ${err instanceof Error ? err.message : String(err)}`
           );
         });
+        try {
+          const factStoreForGen = await getProxyFactStore(unerrDirForLedger);
+          if (factStoreForGen) {
+            const { detectLocalConventions: detectLocalConventions2 } = await Promise.resolve().then(() => (init_local_convention_detector(), local_convention_detector_exports));
+            const { generateFromConventions: generateFromConventions2 } = await Promise.resolve().then(() => (init_fact_generator(), fact_generator_exports));
+            const detection = await detectLocalConventions2(localGraph.db);
+            if (detection.conventions.length > 0) {
+              const convResult = await generateFromConventions2(factStoreForGen, detection.conventions);
+              if (convResult.created > 0 || convResult.reinforced > 0) {
+                log21.info(
+                  `Fact generator: ${convResult.created} convention facts created, ${convResult.reinforced} reinforced`
+                );
+              }
+            }
+            const { runFactGenerationPipeline: runFactGenerationPipeline2 } = await Promise.resolve().then(() => (init_fact_generator(), fact_generator_exports));
+            const pipelineResults = await runFactGenerationPipeline2(factStoreForGen, unerrDirForLedger);
+            for (const r of pipelineResults) {
+              if (r.created > 0 || r.reinforced > 0) {
+                log21.info(
+                  `Fact generator [${r.source}]: ${r.created} created, ${r.reinforced} reinforced`
+                );
+              }
+            }
+          }
+        } catch {
+        }
       },
       // onError
       (err) => {
@@ -32997,7 +34164,7 @@ async function startProxy(opts = {}) {
   }
   const { WorkspaceManifest: WorkspaceManifest2 } = await Promise.resolve().then(() => (init_workspace_manifest(), workspace_manifest_exports));
   const workspaceManifest = repoIds[0] ? new WorkspaceManifest2(
-    join61(process.cwd(), ".unerr"),
+    join62(process.cwd(), ".unerr"),
     repoIds[0],
     shadowLedger2.getSessionId()
   ) : null;
@@ -33082,7 +34249,7 @@ async function startProxy(opts = {}) {
   if (proxyMode === "parse" && parseIndex) {
     try {
       const { extractEntitiesFromSource: extractEntitiesFromSource2 } = await Promise.resolve().then(() => (init_auto_bootstrap(), auto_bootstrap_exports));
-      const allFiles = readdirSync12(process.cwd(), {
+      const allFiles = readdirSync13(process.cwd(), {
         recursive: true,
         encoding: "utf-8"
       });
@@ -33096,7 +34263,7 @@ async function startProxy(opts = {}) {
       });
       for (const file of sourceFiles.slice(0, 500)) {
         try {
-          const content = readFileSync52(join61(process.cwd(), file), "utf-8");
+          const content = readFileSync53(join62(process.cwd(), file), "utf-8");
           const entities = extractEntitiesFromSource2(file, content);
           parseIndex.addEntities(entities);
         } catch {
@@ -33158,7 +34325,7 @@ async function startProxy(opts = {}) {
   }
   const { writeFileSync: writeStatsFile } = await import("fs");
   const { computePercentiles: computePercentiles2 } = await Promise.resolve().then(() => (init_session_stats(), session_stats_exports));
-  const statsSnapshotPath = join61(stateDir, "session_stats.json");
+  const statsSnapshotPath = join62(stateDir, "session_stats.json");
   const statsSnapshotInterval = setInterval(() => {
     try {
       const total = stats.toolCallsLocal;
@@ -33196,7 +34363,7 @@ async function startProxy(opts = {}) {
     const { startDashboardServer: startDashboardServer2 } = await Promise.resolve().then(() => (init_http(), http_exports));
     const { detectIde: detectIdeDashboard } = await Promise.resolve().then(() => (init_detect(), detect_exports));
     const ideType = await detectIdeDashboard(process.cwd());
-    const unerrDirForApi = join61(process.cwd(), ".unerr");
+    const unerrDirForApi = join62(process.cwd(), ".unerr");
     dashboardHandle = await startDashboardServer2({
       system: {
         stats,
@@ -33241,12 +34408,24 @@ async function startProxy(opts = {}) {
       stateDir,
       tokenFlow: {
         unerrDir: unerrDirForApi,
-        getTokenFlowWriter: () => tokenFlowWriter2
+        getTokenFlowWriter: () => tokenFlowWriter2,
+        getAgentName: (_sessionId) => {
+          const last = [...agentNameByClient.values()].pop();
+          return last ?? server.getClientVersion?.()?.name ?? void 0;
+        }
+      },
+      reasoningQuality: {
+        unerrDir: unerrDirForApi,
+        getTokenFlowWriter: () => tokenFlowWriter2,
+        getAgentName: (_sessionId) => {
+          const last = [...agentNameByClient.values()].pop();
+          return last ?? server.getClientVersion?.()?.name ?? void 0;
+        }
       },
       temporal: await (async () => {
         try {
           const { TemporalFactStore: TemporalFactStore2 } = await Promise.resolve().then(() => (init_temporal_facts(), temporal_facts_exports));
-          const { readdirSync: readdirSync14, readFileSync: readFileSync56 } = await import("fs");
+          const { readdirSync: readdirSync15, readFileSync: readFileSync57 } = await import("fs");
           const factStore2 = await TemporalFactStore2.create(
             process.cwd()
           );
@@ -33254,10 +34433,10 @@ async function startProxy(opts = {}) {
             factStore: factStore2,
             loadRecentSessions: (limit) => {
               try {
-                const sessDir = join61(unerrDirForApi, "sessions");
-                const files = readdirSync14(sessDir).filter((f) => f.endsWith(".jsonl")).sort().slice(-limit);
+                const sessDir = join62(unerrDirForApi, "sessions");
+                const files = readdirSync15(sessDir).filter((f) => f.endsWith(".jsonl")).sort().slice(-limit);
                 return files.map((f) => {
-                  const content = readFileSync56(join61(sessDir, f), "utf-8").trim().split("\n").pop();
+                  const content = readFileSync57(join62(sessDir, f), "utf-8").trim().split("\n").pop();
                   return JSON.parse(content);
                 });
               } catch {
@@ -33330,7 +34509,7 @@ async function startProxy(opts = {}) {
         try {
           const { appendSessionHistory: appendSessionHistory2 } = (init_session_history(), __toCommonJS(session_history_exports));
           const topMech = Object.entries(tokenFlowSummary.by_mechanism).sort(([, a], [, b]) => b.tokens_saved - a.tokens_saved)[0];
-          appendSessionHistory2(join61(process.cwd(), ".unerr"), {
+          appendSessionHistory2(join62(process.cwd(), ".unerr"), {
             sessionId: shadowLedger2.getSessionId(),
             startedAt: new Date(stats.sessionStartedAt).toISOString(),
             endedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -33342,6 +34521,7 @@ async function startProxy(opts = {}) {
             dollarsSaved: router2.getSessionDollarsSaved(),
             modelId: "unknown",
             entityCount: 0,
+            agentName: agentNameByClient.values().next().value ?? server.getClientVersion?.()?.name ?? void 0,
             tokenFlowSummary: {
               by_mechanism: Object.fromEntries(
                 Object.entries(tokenFlowSummary.by_mechanism).map(([k, v]) => [
@@ -33455,7 +34635,7 @@ async function startProxy(opts = {}) {
       try {
         const correctionModule = (init_correction_detector(), __toCommonJS(correction_detector_exports));
         const detectCorrections2 = correctionModule.detectCorrections;
-        const ledgerPath = join61(
+        const ledgerPath = join62(
           process.cwd(),
           ".unerr",
           "ledger",
@@ -33473,10 +34653,49 @@ async function startProxy(opts = {}) {
             `[unerr] Learned ${patterns.length} correction pattern${patterns.length !== 1 ? "s" : ""} from this session
 `
           );
+          try {
+            const factStoreForShutdown = await getProxyFactStore(unerrDirForLedger);
+            if (factStoreForShutdown) {
+              const { generateFromNegativeKnowledge: generateFromNegativeKnowledge2 } = await Promise.resolve().then(() => (init_fact_generator(), fact_generator_exports));
+              const corrections = patterns.map((p, i) => ({
+                id: `correction-${shadowLedger2.getSessionId()}-${i}`,
+                entityKey: p.entity_key,
+                pattern: p.error_type,
+                reason: p.correction_summary,
+                detectedAt: p.last_seen,
+                rewindEntryId: shadowLedger2.getSessionId(),
+                confidence: p.confidence
+              }));
+              const negResult = await generateFromNegativeKnowledge2(factStoreForShutdown, corrections);
+              if (negResult.created > 0) {
+                process.stderr.write(
+                  `[unerr] Fact generator: ${negResult.created} negative knowledge facts created
+`
+                );
+              }
+            }
+          } catch {
+          }
         }
       } catch {
       }
     }
+    try {
+      const factStoreForSession = await getProxyFactStore(unerrDirForLedger);
+      if (factStoreForSession) {
+        const { runFactGenerationPipeline: runFactGenerationPipeline2 } = await Promise.resolve().then(() => (init_fact_generator(), fact_generator_exports));
+        const pipelineResults = await runFactGenerationPipeline2(factStoreForSession, unerrDirForLedger);
+        for (const r of pipelineResults) {
+          if (r.created > 0 || r.reinforced > 0) {
+            process.stderr.write(
+              `[unerr] Fact generator [${r.source}]: ${r.created} created, ${r.reinforced} reinforced
+`
+            );
+          }
+        }
+      }
+    } catch {
+    }
     if (workspaceManifest) {
       const orphans = intentCorrelator.getPending();
       if (orphans.length > 0) {
@@ -33639,13 +34858,13 @@ __export(session_logger_exports, {
 import { randomUUID as randomUUID2 } from "crypto";
 import {
   appendFileSync as appendFileSync9,
-  existsSync as existsSync57,
+  existsSync as existsSync58,
   mkdirSync as mkdirSync35,
-  readdirSync as readdirSync13,
+  readdirSync as readdirSync14,
   statSync as statSync11,
   unlinkSync as unlinkSync9
 } from "fs";
-import { join as join62 } from "path";
+import { join as join63 } from "path";
 import { createConsola as createConsola2 } from "consola";
 function formatTimestamp() {
   const d = /* @__PURE__ */ new Date();
@@ -33653,10 +34872,10 @@ 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 (!existsSync57(logsDir)) return;
+  if (!existsSync58(logsDir)) return;
   try {
-    const files = readdirSync13(logsDir).filter((f) => f.startsWith("session-") && f.endsWith(".log")).map((f) => {
-      const fullPath = join62(logsDir, f);
+    const files = readdirSync14(logsDir).filter((f) => f.startsWith("session-") && f.endsWith(".log")).map((f) => {
+      const fullPath = join63(logsDir, f);
       const stat2 = statSync11(fullPath);
       return {
         name: f,
@@ -33673,7 +34892,7 @@ function cleanupOldLogs(logsDir) {
         }
       }
     }
-    const remaining = files.filter((f) => existsSync57(f.path));
+    const remaining = files.filter((f) => existsSync58(f.path));
     if (remaining.length > MAX_FILES) {
       for (const file of remaining.slice(MAX_FILES)) {
         try {
@@ -33688,11 +34907,11 @@ function cleanupOldLogs(logsDir) {
 function initSessionLogger(opts = {}) {
   if (_logger) return _logger;
   const cwd = opts.cwd ?? process.cwd();
-  const logsDir = join62(cwd, ".unerr", "logs");
+  const logsDir = join63(cwd, ".unerr", "logs");
   mkdirSync35(logsDir, { recursive: true });
   cleanupOldLogs(logsDir);
   const timestamp2 = formatTimestamp();
-  _logFilePath = join62(logsDir, `session-${timestamp2}.log`);
+  _logFilePath = join63(logsDir, `session-${timestamp2}.log`);
   const levelNum = opts.level !== void 0 ? Number(opts.level) : void 0;
   const envLevel = process.env.UNERR_LOG_LEVEL;
   const resolvedLevel = levelNum ?? (envLevel ? Number(envLevel) : 3);
@@ -33766,22 +34985,22 @@ __export(setup_wizard_exports, {
   runSetup: () => runSetup
 });
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync58, mkdirSync as mkdirSync36, writeFileSync as writeFileSync33 } from "fs";
-import { join as join63 } from "path";
+import { existsSync as existsSync59, mkdirSync as mkdirSync36, writeFileSync as writeFileSync33 } from "fs";
+import { join as join64 } from "path";
 import * as clack from "@clack/prompts";
 async function runSetup(cwd) {
   const projectDir = cwd ?? process.cwd();
   clack.intro("unerr");
   clack.log.step("Project Setup");
   const repoId = await generateRepoId(projectDir);
-  const configDir = join63(projectDir, ".unerr");
+  const configDir = join64(projectDir, ".unerr");
   mkdirSync36(configDir, { recursive: true });
-  const configPath = join63(configDir, "config.json");
-  const settingsPath = join63(configDir, "settings.json");
+  const configPath = join64(configDir, "config.json");
+  const settingsPath = join64(configDir, "settings.json");
   writeFileSync33(configPath, `${JSON.stringify({ repoId }, null, 2)}
 `);
   let existingSettings = {};
-  if (existsSync58(settingsPath)) {
+  if (existsSync59(settingsPath)) {
     try {
       existingSettings = JSON.parse(
         __require("fs").readFileSync(settingsPath, "utf-8")
@@ -34390,13 +35609,13 @@ __export(session_summary_writer_exports, {
   readLastSession: () => readLastSession,
   writeSessionSummary: () => writeSessionSummary
 });
-import { existsSync as existsSync59, mkdirSync as mkdirSync37, appendFileSync as appendFileSync10, writeFileSync as writeFileSync34, readFileSync as readFileSync53 } from "fs";
-import { join as join64 } from "path";
+import { existsSync as existsSync60, mkdirSync as mkdirSync37, appendFileSync as appendFileSync10, writeFileSync as writeFileSync34, readFileSync as readFileSync54 } from "fs";
+import { join as join65 } from "path";
 function writeSessionSummary(unerrDir, ctx) {
   if (ctx.entries.length === 0) return null;
   try {
-    const sessionsDir = join64(unerrDir, "sessions");
-    if (!existsSync59(sessionsDir)) {
+    const sessionsDir = join65(unerrDir, "sessions");
+    if (!existsSync60(sessionsDir)) {
       mkdirSync37(sessionsDir, { recursive: true });
     }
     const sorted = [...ctx.entries].sort(
@@ -34440,7 +35659,7 @@ function writeSessionSummary(unerrDir, ctx) {
       token_estimate: ctx.tokenEstimate,
       branch: last.branch ?? "unknown"
     };
-    const filePath = join64(sessionsDir, `${ctx.sessionId}.jsonl`);
+    const filePath = join65(sessionsDir, `${ctx.sessionId}.jsonl`);
     appendFileSync10(filePath, `${JSON.stringify(record)}
 `, "utf-8");
     writeLastSessionPointer(unerrDir, ctx.sessionId, record);
@@ -34455,9 +35674,9 @@ function writeSessionSummary(unerrDir, ctx) {
 }
 function readLastSession(unerrDir) {
   try {
-    const pointerPath = join64(unerrDir, "state", "last_session.json");
-    if (!existsSync59(pointerPath)) return null;
-    const content = readFileSync53(pointerPath, "utf-8");
+    const pointerPath = join65(unerrDir, "state", "last_session.json");
+    if (!existsSync60(pointerPath)) return null;
+    const content = readFileSync54(pointerPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -34465,11 +35684,11 @@ function readLastSession(unerrDir) {
 }
 function writeLastSessionPointer(unerrDir, sessionId, record) {
   try {
-    const stateDir = join64(unerrDir, "state");
-    if (!existsSync59(stateDir)) {
+    const stateDir = join65(unerrDir, "state");
+    if (!existsSync60(stateDir)) {
       mkdirSync37(stateDir, { recursive: true });
     }
-    const pointerPath = join64(stateDir, "last_session.json");
+    const pointerPath = join65(stateDir, "last_session.json");
     writeFileSync34(pointerPath, JSON.stringify(record, null, 2), "utf-8");
   } catch {
   }
@@ -34667,16 +35886,33 @@ var mcp_server_exports = {};
 __export(mcp_server_exports, {
   startMcpServer: () => startMcpServer
 });
-import { existsSync as existsSync60, mkdirSync as mkdirSync38, readFileSync as readFileSync54, writeFileSync as writeFileSync35 } from "fs";
-import { join as join65 } from "path";
+import { existsSync as existsSync61, mkdirSync as mkdirSync38, readFileSync as readFileSync55, writeFileSync as writeFileSync35 } 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");
+    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");
+    process.stderr.write("[unerr] Migrated permissions: removed Read from deny list (required for Edit workflow)\n");
+  } catch {
+  }
+}
 async function startMcpServer(cwd) {
   const { Server } = await import("@modelcontextprotocol/sdk/server/index.js");
   const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
   const { ListToolsRequestSchema, CallToolRequestSchema } = await import("@modelcontextprotocol/sdk/types.js");
-  const unerrDir = join65(cwd, ".unerr");
-  if (!existsSync60(unerrDir)) {
+  const unerrDir = join66(cwd, ".unerr");
+  if (!existsSync61(unerrDir)) {
     mkdirSync38(unerrDir, { recursive: true });
   }
+  migrateAgentPermissions2(cwd);
   await initTier2Modules(unerrDir);
   const server = new Server(
     { name: "unerr-local", version: "0.1.0" },
@@ -34694,6 +35930,25 @@ async function startMcpServer(cwd) {
     if (name === "recall_facts") {
       return handleRecallFacts(args);
     }
+    const PROXY_ONLY_TOOLS = [
+      "unerr_get_timeline",
+      "unerr_revert_to_working_state",
+      "unerr_mark_working"
+    ];
+    if (PROXY_ONLY_TOOLS.includes(name)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              tool: name,
+              available: false,
+              message: `${name} requires the full unerr proxy (run 'unerr' without --mcp). The timeline/revert subsystem is not available in lightweight MCP mode.`
+            })
+          }
+        ]
+      };
+    }
     if (!graphReady || !router) {
       if (name === "file_read" || name === "file_outline") {
         try {
@@ -34773,25 +36028,6 @@ async function startMcpServer(cwd) {
         ]
       };
     }
-    const PROXY_ONLY_TOOLS = [
-      "unerr_get_timeline",
-      "unerr_revert_to_working_state",
-      "unerr_mark_working"
-    ];
-    if (PROXY_ONLY_TOOLS.includes(name)) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              tool: name,
-              available: false,
-              message: `${name} requires the full unerr proxy (run 'unerr' without --mcp). The timeline/revert subsystem is not available in lightweight MCP mode.`
-            })
-          }
-        ]
-      };
-    }
     try {
       const result = await router.execute(name, args);
       let text2 = stringifyMcpToolJson(result.content);
@@ -35079,9 +36315,9 @@ async function initTier2Modules(unerrDir) {
     tokenFlowWriter = new TokenFlowWriter2(unerrDir, sessionId);
     process.env.UNERR_SESSION_ID = sessionId;
     try {
-      const stateDir = join65(unerrDir, "state");
+      const stateDir = join66(unerrDir, "state");
       mkdirSync38(stateDir, { recursive: true });
-      writeFileSync35(join65(stateDir, "session.id"), sessionId, "utf-8");
+      writeFileSync35(join66(stateDir, "session.id"), sessionId, "utf-8");
     } catch {
     }
     log24.info(`Token flow active (session ${sessionId.slice(0, 8)})`);
@@ -35112,7 +36348,7 @@ async function initTier2Modules(unerrDir) {
   }
   try {
     const { TemporalFactStore: TemporalFactStore2 } = await Promise.resolve().then(() => (init_temporal_facts(), temporal_facts_exports));
-    const projectRoot = join65(unerrDir, "..");
+    const projectRoot = join66(unerrDir, "..");
     factStore = await TemporalFactStore2.create(projectRoot);
     log24.info("Temporal fact store active (facts.db)");
   } catch (err) {
@@ -35222,8 +36458,8 @@ function wireTier2IntoRouter(r) {
 async function loadIntelligence(cwd) {
   const projectRoot = cwd;
   try {
-    const unerrDir = join65(projectRoot, ".unerr");
-    if (!existsSync60(unerrDir)) {
+    const unerrDir = join66(projectRoot, ".unerr");
+    if (!existsSync61(unerrDir)) {
       mkdirSync38(unerrDir, { recursive: true });
     }
     const { openPersistentDb: openPersistentDb2 } = await Promise.resolve().then(() => (init_persistent_db(), persistent_db_exports));
@@ -35232,11 +36468,8 @@ async function loadIntelligence(cwd) {
     const localGraph = await CozoGraphStore2.create(db, projectRoot);
     let needsIndex = false;
     if (!isNew && await localGraph.isPopulated()) {
-      log24.info("Persistent graph loaded");
-      const { shouldReindex: shouldReindex2 } = await Promise.resolve().then(() => (init_local_snapshot(), local_snapshot_exports));
-      if (shouldReindex2(projectRoot)) {
-        needsIndex = true;
-      }
+      log24.info("Persistent graph loaded \u2014 background reindex will refresh entity data");
+      needsIndex = true;
     } else {
       const { loadLocalSnapshot: loadLocalSnapshot2 } = await Promise.resolve().then(() => (init_local_snapshot(), local_snapshot_exports));
       const migrated = await loadLocalSnapshot2(projectRoot, localGraph);
@@ -35245,11 +36478,11 @@ async function loadIntelligence(cwd) {
         await buildSearchIndex2(localGraph.db);
         const { runCommunityDetection: runCommunityDetection2, runConventionDetection: runConventionDetection2 } = await Promise.resolve().then(() => (init_local_indexer(), local_indexer_exports));
         await runCommunityDetection2(localGraph);
-        const configPath = join65(projectRoot, ".unerr", "config.json");
+        const configPath = join66(projectRoot, ".unerr", "config.json");
         let repoId = "unknown";
-        if (existsSync60(configPath)) {
+        if (existsSync61(configPath)) {
           try {
-            const config = JSON.parse(readFileSync54(configPath, "utf-8"));
+            const config = JSON.parse(readFileSync55(configPath, "utf-8"));
             repoId = config.repoId ?? repoId;
           } catch {
           }
@@ -35276,11 +36509,11 @@ async function loadIntelligence(cwd) {
     log24.info("Intelligence graph ready \u2014 tools fully operational");
     if (needsIndex) {
       try {
-        const configPath = join65(projectRoot, ".unerr", "config.json");
+        const configPath = join66(projectRoot, ".unerr", "config.json");
         let indexRepoId = "unknown";
-        if (existsSync60(configPath)) {
+        if (existsSync61(configPath)) {
           try {
-            const cfg = JSON.parse(readFileSync54(configPath, "utf-8"));
+            const cfg = JSON.parse(readFileSync55(configPath, "utf-8"));
             indexRepoId = cfg.repoId ?? indexRepoId;
           } catch {
           }
@@ -35390,8 +36623,8 @@ var init_mcp_server = __esm({
 
 // src/entrypoints/cli.ts
 init_startup_log();
-import { existsSync as existsSync61, readFileSync as readFileSync55 } from "fs";
-import { join as join66 } from "path";
+import { existsSync as existsSync62, readFileSync as readFileSync56 } from "fs";
+import { join as join67 } from "path";
 import { Command } from "commander";
 
 // src/commands/branches.ts
@@ -35832,9 +37065,9 @@ function registerDashboardCommand(program2) {
 // src/commands/debug.ts
 init_git();
 import { existsSync as existsSync9, readFileSync as readFileSync9, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
-import { arch, homedir as homedir2, platform, release } from "os";
+import { arch, homedir as homedir3, platform, release } from "os";
 import { join as join11 } from "path";
-var UNERR_DIR = join11(homedir2(), ".unerr");
+var UNERR_DIR = join11(homedir3(), ".unerr");
 function registerDebugCommand(program2) {
   program2.command("debug").description("Diagnostics dump for support").action(async () => {
     const sections = [];
@@ -35939,9 +37172,9 @@ function registerDebugCommand(program2) {
     const mcpLocations = [
       join11(process.cwd(), ".cursor", "mcp.json"),
       join11(process.cwd(), ".vscode", "mcp.json"),
-      join11(homedir2(), ".claude", "claude_desktop_config.json"),
+      join11(homedir3(), ".claude", "claude_desktop_config.json"),
       join11(
-        homedir2(),
+        homedir3(),
         "Library",
         "Application Support",
         "Cursor",
@@ -35954,7 +37187,7 @@ function registerDebugCommand(program2) {
     for (const loc of mcpLocations) {
       const exists = existsSync9(loc);
       sections.push(
-        `  ${exists ? "[x]" : "[ ]"} ${loc.replace(homedir2(), "~")}`
+        `  ${exists ? "[x]" : "[ ]"} ${loc.replace(homedir3(), "~")}`
       );
     }
     sections.push("");
@@ -37395,19 +38628,19 @@ async function buildShellDiffRiskMap(graph, stdout) {
 }
 async function tryLoadGraphForShellBoost(cwd) {
   try {
-    const { existsSync: existsSync62, readFileSync: readFileSync56 } = await import("fs");
-    const { join: join67 } = await import("path");
+    const { existsSync: existsSync63, readFileSync: readFileSync57 } = await import("fs");
+    const { join: join68 } = await import("path");
     const { gunzipSync: gunzipSync3 } = await import("zlib");
     const { unpack } = await import("msgpackr");
-    const snapshotsDir = join67(cwd, ".unerr", "snapshots");
-    let snapshotPath2 = join67(snapshotsDir, "graph.msgpack.gz");
-    if (!existsSync62(snapshotPath2)) {
-      snapshotPath2 = join67(snapshotsDir, "graph.msgpack");
+    const snapshotsDir = join68(cwd, ".unerr", "snapshots");
+    let snapshotPath2 = join68(snapshotsDir, "graph.msgpack.gz");
+    if (!existsSync63(snapshotPath2)) {
+      snapshotPath2 = join68(snapshotsDir, "graph.msgpack");
     }
-    if (!existsSync62(snapshotPath2)) return null;
+    if (!existsSync63(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 = readFileSync56(snapshotPath2);
+    const raw = readFileSync57(snapshotPath2);
     let buffer;
     try {
       buffer = gunzipSync3(raw);
@@ -40643,12 +41876,17 @@ var preReadHandler = (normalized) => {
   const input = normalized.toolInput;
   const filePath = extractFilePath2(input);
   if (!filePath) return passthrough();
+  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)
 - File structure: \`file_outline("${filePath}")\`
-- Specific function: \`get_entity\` or \`file_read\` with \`entity\` param`
+- Specific function: \`get_entity\` or \`file_read\` with \`entity\` param` + targetedReadGuidance
   );
 };
 var preGrepHandler = (normalized) => {
@@ -40700,17 +41938,20 @@ 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 oldStr = input.old_string;
   const hasSignatureChange = oldStr && /^(export\s+)?(async\s+)?function\s+\w+|^(export\s+)?class\s+\w+/.test(oldStr.trim());
   if (hasSignatureChange) {
     return nudge(
-      `You're editing a function/class signature in "${filePath}". This may break callers.
+      readPrereq + `You're editing a function/class signature in "${filePath}". This may break callers.
 - \`get_references\` on the entity you're modifying \u2014 all callers must be updated to match
 - \`get_rules "${filePath}"\` with content after editing \u2014 validate the change follows project conventions`
     );
   }
   return nudge(
-    `Before editing "${filePath}":
+    readPrereq + `Before editing "${filePath}":
 - \`get_references\` on any entity you're changing \u2014 ensure callers won't break
 - \`get_rules "${filePath}"\` with content after editing \u2014 validate against project conventions`
   );
@@ -41168,7 +42409,7 @@ function mergePreToolUseBashHook(cwd) {
     return { ok: false, path: settingsPath, action: "failed" };
   }
 }
-var DISALLOWED_TOOLS = ["Read", "Grep", "Glob"];
+var DISALLOWED_TOOLS = ["Grep", "Glob"];
 function addDisallowedTools(cwd) {
   const dir = join27(cwd, ".claude");
   const settingsPath = join27(dir, "settings.json");
@@ -41186,6 +42427,10 @@ function addDisallowedTools(cwd) {
     }
     const permissions = settings.permissions ?? {};
     const deny = Array.isArray(permissions.deny) ? [...permissions.deny] : [];
+    const readIdx = deny.indexOf("Read");
+    if (readIdx >= 0) {
+      deny.splice(readIdx, 1);
+    }
     let added = 0;
     for (const tool of DISALLOWED_TOOLS) {
       if (!deny.includes(tool)) {
@@ -41306,10 +42551,12 @@ This project has unerr MCP tools installed. You MUST use these instead of built-
 | Intent | Tool | Why |
 |--------|------|-----|
 | Reading to understand code | \`file_read\` (unerr MCP) | Auto-injects conventions, facts, drift status |
-| Reading immediately before Edit | Built-in \`Read\` | Required by Edit tool \u2014 \`file_read\` does NOT satisfy this |
+| 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.
+
 ### Tool Reference
 
 #### Graph Navigation (8 tools)
@@ -41376,7 +42623,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).
+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).
 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\`.`;
@@ -41399,6 +42646,29 @@ function writeInstructionFile(cwd, ide) {
   if (agentDef.instructionFormat === "mdc") {
     return writeMdcInstructionFile(filePath);
   }
+  if (agentDef.instructionFormat === "windsurf-rule") {
+    mkdirSync15(dirname5(filePath), { recursive: true });
+    const content = getInstructionContent();
+    const truncatedContent = content.length > 5800 ? `${content.slice(0, 5800)}
+
+[Truncated \u2014 full content exceeds Windsurf 6K limit]` : content;
+    const windsurfContent = `---
+trigger: always_on
+description: "Tool routing instructions for unerr MCP integration"
+---
+
+${truncatedContent}
+`;
+    const existed = existsSync21(filePath);
+    if (existed) {
+      const existing = readFileSync20(filePath, "utf-8");
+      if (existing === windsurfContent) {
+        return { path: filePath, action: "skipped" };
+      }
+    }
+    writeFileSync11(filePath, windsurfContent, "utf-8");
+    return { path: filePath, action: existed ? "updated" : "created" };
+  }
   if (agentDef.instructionFormat === "antigravity-rule") {
     mkdirSync15(dirname5(filePath), { recursive: true });
     const content = getInstructionContent();
@@ -41477,6 +42747,13 @@ function removeInstructionSection(cwd, ide) {
     unlinkSync3(filePath);
     return true;
   }
+  if (agentDef.instructionFormat === "windsurf-rule") {
+    if (existsSync21(filePath)) {
+      unlinkSync3(filePath);
+      return true;
+    }
+    return false;
+  }
   if (agentDef.instructionFormat === "antigravity-rule") {
     if (existsSync21(filePath)) {
       unlinkSync3(filePath);
@@ -42041,8 +43318,8 @@ async function persistPatterns(patterns, _unerrDir) {
       );
       return;
     }
-    const { readFileSync: readFileSync56 } = await import("fs");
-    const config = JSON.parse(readFileSync56(configPath, "utf-8"));
+    const { readFileSync: readFileSync57 } = await import("fs");
+    const config = JSON.parse(readFileSync57(configPath, "utf-8"));
     if (!config.repoId || !config.orgId) {
       warn("Repo not configured \u2014 cannot persist to CozoDB.");
       return;
@@ -42060,7 +43337,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 = readFileSync56(snapshotPath2);
+    const raw = readFileSync57(snapshotPath2);
     const buffer = gunzipSync2(raw);
     const envelope = unpack(buffer);
     await store.loadSnapshot(envelope);
@@ -42727,8 +44004,8 @@ function registerStatusCommand(program2) {
     try {
       const logsDir = join38(unerrDir, "logs");
       if (existsSync31(logsDir)) {
-        const { readdirSync: readdirSync14, statSync: statSync12 } = await import("fs");
-        const logs = readdirSync14(logsDir).filter((f) => f.startsWith("session-") && f.endsWith(".log")).map((f) => ({
+        const { readdirSync: readdirSync15, statSync: statSync12 } = await import("fs");
+        const logs = readdirSync15(logsDir).filter((f) => f.startsWith("session-") && f.endsWith(".log")).map((f) => ({
           name: f,
           mtime: statSync12(join38(logsDir, f)).mtimeMs
         })).sort((a, b) => b.mtime - a.mtime);
@@ -43293,17 +44570,538 @@ async function isInsideGitRepo2() {
   const { isGitRepo: isGitRepo3 } = await Promise.resolve().then(() => (init_git(), git_exports));
   return isGitRepo3(process.cwd());
 }
+var DEFINITIVE_MARKERS = [
+  // JavaScript / TypeScript
+  "package.json",
+  "tsconfig.json",
+  "jsconfig.json",
+  "deno.json",
+  "deno.jsonc",
+  "bun.lockb",
+  "bunfig.toml",
+  // Python
+  "pyproject.toml",
+  "setup.py",
+  "setup.cfg",
+  "Pipfile",
+  "hatch.toml",
+  // Rust
+  "Cargo.toml",
+  // Go
+  "go.mod",
+  // Java / Kotlin / Gradle
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  "settings.gradle",
+  "settings.gradle.kts",
+  // C# / .NET
+  "Directory.Build.props",
+  "global.json",
+  "nuget.config",
+  // Ruby
+  "Gemfile",
+  "Rakefile",
+  // PHP
+  "composer.json",
+  // Swift / Obj-C / Apple
+  "Package.swift",
+  "Podfile",
+  // C / C++
+  "CMakeLists.txt",
+  "Makefile",
+  "configure.ac",
+  "meson.build",
+  "conanfile.txt",
+  "conanfile.py",
+  "vcpkg.json",
+  // Dart / Flutter
+  "pubspec.yaml",
+  // Elixir
+  "mix.exs",
+  // Scala
+  "build.sbt",
+  "build.sc",
+  // Haskell
+  "stack.yaml",
+  "cabal.project",
+  // Clojure
+  "project.clj",
+  "deps.edn",
+  "shadow-cljs.edn",
+  // Zig
+  "build.zig",
+  "build.zig.zon",
+  // Julia
+  "Project.toml",
+  // Terraform / IaC
+  "main.tf",
+  "terraform.tf",
+  "pulumi.yaml",
+  "serverless.yml",
+  "cdk.json",
+  "sam.yaml",
+  // Containers
+  "Dockerfile",
+  "docker-compose.yml",
+  "docker-compose.yaml",
+  // Monorepo
+  "lerna.json",
+  "nx.json",
+  "turbo.json",
+  "pnpm-workspace.yaml",
+  "rush.json",
+  "pants.toml",
+  // Bazel
+  "BUILD.bazel",
+  "WORKSPACE",
+  "WORKSPACE.bazel",
+  // General build / task
+  "Justfile",
+  "Taskfile.yml",
+  // Nix
+  "flake.nix",
+  "shell.nix",
+  "default.nix",
+  // Android
+  "AndroidManifest.xml"
+];
+var STRONG_SIGNAL_FILES = [
+  // Lock files (imply a package manager was run here)
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "Pipfile.lock",
+  "poetry.lock",
+  "Gemfile.lock",
+  "composer.lock",
+  "Cargo.lock",
+  "flake.lock",
+  "pubspec.lock",
+  "mix.lock",
+  "go.sum",
+  "uv.lock",
+  "pdm.lock",
+  // CI/CD (a CI config strongly implies project root)
+  ".gitlab-ci.yml",
+  "Jenkinsfile",
+  ".travis.yml",
+  "azure-pipelines.yml",
+  "bitbucket-pipelines.yml",
+  // Editor / LSP configs (placed at project root)
+  ".editorconfig",
+  ".prettierrc",
+  ".prettierrc.json",
+  ".eslintrc",
+  ".eslintrc.json",
+  ".eslintrc.js",
+  "biome.json",
+  "biome.jsonc",
+  "pyrightconfig.json",
+  "rust-toolchain.toml",
+  ".clang-format",
+  ".clangd",
+  "compile_commands.json",
+  ".luarc.json",
+  "stylua.toml",
+  ".rubocop.yml",
+  ".php-cs-fixer.php",
+  // Environment
+  ".env",
+  ".envrc",
+  // Git-specific (at root level these are strong signals)
+  ".gitignore",
+  ".gitattributes"
+];
+var STRONG_SIGNAL_DIRS = [
+  ".git",
+  ".svn",
+  ".hg",
+  ".fossil",
+  ".bzr",
+  "_darcs",
+  // VCS
+  ".github",
+  ".circleci",
+  ".buildkite",
+  // CI/CD
+  ".idea",
+  ".vscode",
+  ".vs",
+  ".fleet",
+  ".zed"
+  // IDE
+];
+var EXTENSION_MARKERS = [
+  ".sln",
+  ".csproj",
+  ".fsproj",
+  ".vbproj",
+  // .NET
+  ".xcodeproj",
+  ".xcworkspace",
+  // Xcode (dirs)
+  ".cabal",
+  // Haskell
+  ".nimble",
+  // Nim
+  ".gemspec",
+  // Ruby
+  ".rockspec"
+  // Lua
+];
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  // Web / JS ecosystem
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".vue",
+  ".svelte",
+  ".astro",
+  // Systems
+  ".rs",
+  ".go",
+  ".c",
+  ".h",
+  ".cpp",
+  ".cc",
+  ".cxx",
+  ".hpp",
+  ".hxx",
+  ".zig",
+  // JVM
+  ".java",
+  ".kt",
+  ".kts",
+  ".scala",
+  ".sc",
+  ".clj",
+  ".cljs",
+  ".cljc",
+  // .NET
+  ".cs",
+  ".fs",
+  ".fsx",
+  ".vb",
+  // Scripting
+  ".py",
+  ".pyi",
+  ".rb",
+  ".php",
+  ".lua",
+  ".pl",
+  ".pm",
+  ".raku",
+  // Apple / Mobile
+  ".swift",
+  ".m",
+  ".mm",
+  ".dart",
+  // Functional
+  ".hs",
+  ".lhs",
+  ".ml",
+  ".mli",
+  ".re",
+  ".rei",
+  ".elm",
+  ".ex",
+  ".exs",
+  ".purs",
+  ".idr",
+  ".agda",
+  ".lean",
+  // Data / Science
+  ".r",
+  ".R",
+  ".jl",
+  // Infrastructure
+  ".tf",
+  ".hcl",
+  // Emerging / Niche
+  ".nim",
+  ".cr",
+  ".d",
+  ".v",
+  ".sol",
+  ".move",
+  ".cairo",
+  ".nr",
+  // Shell / Config as code
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".fish",
+  ".ps1"
+]);
+var ANTI_SIGNAL_FILES = [
+  ".bashrc",
+  ".zshrc",
+  ".bash_profile",
+  ".profile",
+  ".zprofile",
+  ".zshenv",
+  ".bash_history",
+  ".zsh_history"
+];
+var ANTI_SIGNAL_DIRS = [
+  ".config",
+  ".local",
+  ".cache",
+  ".ssh",
+  ".gnupg",
+  ".npm",
+  ".cargo",
+  "Desktop",
+  "Downloads",
+  "Documents",
+  "Pictures",
+  "Music",
+  "Movies",
+  "Library",
+  "Applications"
+];
+var ANTI_SIGNAL_PATHS = [
+  "/",
+  "/usr",
+  "/tmp",
+  "/var",
+  "/etc",
+  "/opt",
+  "/home",
+  "/Users",
+  "/root"
+];
+var SOURCE_DIRS = /* @__PURE__ */ new Set([
+  "src",
+  "lib",
+  "app",
+  "apps",
+  "cmd",
+  "pkg",
+  "packages",
+  "internal",
+  "modules",
+  "components",
+  "pages",
+  "routes",
+  "api",
+  "server",
+  "client",
+  "web",
+  "core",
+  "common",
+  "shared",
+  "utils",
+  "helpers",
+  "services",
+  "models",
+  "views",
+  "controllers",
+  "handlers",
+  "middleware",
+  "plugins",
+  "test",
+  "tests",
+  "spec",
+  "__tests__",
+  "e2e",
+  "integration",
+  "scripts",
+  "tools",
+  "bin",
+  "examples",
+  "samples",
+  "proto",
+  "schemas",
+  "migrations",
+  "seeds"
+]);
+var DETECTION_THRESHOLD = 5;
+async function detectProjectRoot(cwd) {
+  const { readdirSync: readdirSync15 } = await import("fs");
+  let score = 0;
+  const signals = [];
+  let hasGit = false;
+  const normalizedCwd = cwd.replace(/\\/g, "/");
+  for (const ap of ANTI_SIGNAL_PATHS) {
+    if (normalizedCwd === ap || normalizedCwd === ap + "/") {
+      return {
+        isProject: false,
+        hasGit: false,
+        reason: `System/root path: ${cwd}`,
+        score: -15,
+        signals: [`anti-path: ${ap}`]
+      };
+    }
+  }
+  let rootEntries = [];
+  try {
+    rootEntries = readdirSync15(cwd, { withFileTypes: true }).map((e) => ({
+      name: e.name,
+      isFile: e.isFile(),
+      isDir: e.isDirectory()
+    }));
+  } catch {
+    return {
+      isProject: false,
+      hasGit: false,
+      reason: "Cannot read directory",
+      score: -1,
+      signals: ["unreadable"]
+    };
+  }
+  const rootFileNames = new Set(rootEntries.filter((e) => e.isFile).map((e) => e.name));
+  const rootDirNames = new Set(rootEntries.filter((e) => e.isDir).map((e) => e.name));
+  for (const af of ANTI_SIGNAL_FILES) {
+    if (rootFileNames.has(af)) {
+      score -= 3;
+      signals.push(`anti-file: ${af}`);
+    }
+  }
+  for (const ad of ANTI_SIGNAL_DIRS) {
+    if (rootDirNames.has(ad)) {
+      score -= 2;
+      signals.push(`anti-dir: ${ad}/`);
+    }
+  }
+  for (const marker of DEFINITIVE_MARKERS) {
+    if (rootFileNames.has(marker)) {
+      score += 10;
+      signals.push(`marker: ${marker}`);
+      break;
+    }
+  }
+  if (score < DETECTION_THRESHOLD) {
+    for (const entry of rootEntries) {
+      if (!entry.isFile && !entry.isDir) continue;
+      const name = entry.name.toLowerCase();
+      for (const ext of EXTENSION_MARKERS) {
+        if (name.endsWith(ext)) {
+          score += 10;
+          signals.push(`ext-marker: ${entry.name}`);
+          break;
+        }
+      }
+      if (score >= DETECTION_THRESHOLD) break;
+    }
+  }
+  for (const vcs of STRONG_SIGNAL_DIRS.slice(0, 6)) {
+    if (rootDirNames.has(vcs)) {
+      if (vcs === ".git") hasGit = true;
+      score += 8;
+      signals.push(`vcs: ${vcs}/`);
+      break;
+    }
+  }
+  for (const sf of STRONG_SIGNAL_FILES) {
+    if (rootFileNames.has(sf)) {
+      score += 4;
+      signals.push(`strong: ${sf}`);
+      if (score >= DETECTION_THRESHOLD) break;
+    }
+  }
+  for (const sd of STRONG_SIGNAL_DIRS.slice(6)) {
+    if (rootDirNames.has(sd)) {
+      score += 4;
+      signals.push(`strong: ${sd}/`);
+      if (score >= DETECTION_THRESHOLD) break;
+    }
+  }
+  if (!hasGit) {
+    try {
+      hasGit = await isInsideGitRepo2();
+      if (hasGit) {
+        score += 6;
+        signals.push("git: inside work tree");
+      }
+    } catch {
+    }
+  }
+  if (score >= DETECTION_THRESHOLD) {
+    const topSignal2 = signals.find((s) => !s.startsWith("anti-")) ?? signals[0] ?? "unknown";
+    return { isProject: true, hasGit, reason: topSignal2, score, signals };
+  }
+  function dirHasCodeFile(dir) {
+    try {
+      const entries = readdirSync15(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isFile()) continue;
+        const dot = entry.name.lastIndexOf(".");
+        if (dot >= 0 && CODE_EXTENSIONS.has(entry.name.slice(dot).toLowerCase())) {
+          return entry.name;
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  const rootCodeFile = dirHasCodeFile(cwd);
+  if (rootCodeFile) {
+    score += 5;
+    signals.push(`code-root: ${rootCodeFile}`);
+  }
+  if (score >= DETECTION_THRESHOLD) {
+    const topSignal2 = signals.find((s) => !s.startsWith("anti-")) ?? signals[0] ?? "unknown";
+    return { isProject: true, hasGit, reason: topSignal2, score, signals };
+  }
+  for (const dirEntry of rootEntries) {
+    if (!dirEntry.isDir || dirEntry.name.startsWith(".")) continue;
+    if (!SOURCE_DIRS.has(dirEntry.name.toLowerCase())) continue;
+    const sourceDir = join67(cwd, dirEntry.name);
+    const srcCodeFile = dirHasCodeFile(sourceDir);
+    if (srcCodeFile) {
+      score += 6;
+      signals.push(`code-src: ${dirEntry.name}/${srcCodeFile}`);
+      break;
+    }
+    try {
+      const subEntries = readdirSync15(sourceDir, { withFileTypes: true });
+      let found = false;
+      for (const sub of subEntries) {
+        if (!sub.isDirectory() || sub.name.startsWith(".")) continue;
+        const deepCode = dirHasCodeFile(join67(sourceDir, sub.name));
+        if (deepCode) {
+          score += 6;
+          signals.push(`code-src: ${dirEntry.name}/${sub.name}/${deepCode}`);
+          found = true;
+          break;
+        }
+      }
+      if (found) break;
+    } catch {
+    }
+  }
+  const isProject = score >= DETECTION_THRESHOLD;
+  const topSignal = signals.find((s) => !s.startsWith("anti-")) ?? signals[0] ?? "No signals";
+  return { isProject, hasGit, reason: isProject ? topSignal : "No code files or project markers found", score, signals };
+}
 function readLocalConfig(cwd) {
-  const configPath = join66(cwd, ".unerr", "config.json");
-  if (!existsSync61(configPath)) return null;
+  const configPath = join67(cwd, ".unerr", "config.json");
+  if (!existsSync62(configPath)) return null;
   try {
-    return JSON.parse(readFileSync55(configPath, "utf-8"));
+    return JSON.parse(readFileSync56(configPath, "utf-8"));
   } catch {
     return null;
   }
 }
 async function resumeBoot(config) {
   initFileLog(process.cwd());
+  const detection = await detectProjectRoot(process.cwd());
+  if (!detection.isProject) {
+    const antiSignals = detection.signals.filter((s) => s.startsWith("anti-"));
+    process.stderr.write(
+      `\x1B[38;2;248;113;113m\u2717\x1B[0m No code project detected in this directory.
+  Found .unerr/config.json but the directory doesn't look like a project root.
+  Detection score: ${detection.score} (need ${DETECTION_THRESHOLD})
+` + (antiSignals.length > 0 ? `  Negative signals: ${antiSignals.map((s) => s.replace("anti-", "")).join(", ")}
+` : "") + "\n  unerr checks for: project files (package.json, Cargo.toml, go.mod, ...),\n  VCS directories (.git, .hg), IDE configs, CI/CD files, lock files,\n  and source code across 50+ languages.\n\n  \u25B8 Run \x1B[1munerr\x1B[0m from a project root directory.\n"
+    );
+    process.exit(1);
+  }
   const { initSessionLogger: initSessionLogger2, createSessionModuleLogger: createSessionModuleLogger2 } = await Promise.resolve().then(() => (init_session_logger(), session_logger_exports));
   initSessionLogger2();
   const log25 = createSessionModuleLogger2("boot");
@@ -43317,13 +45115,24 @@ async function firstRunBoot() {
   const { initSessionLogger: initSessionLogger2, createSessionModuleLogger: createSessionModuleLogger2 } = await Promise.resolve().then(() => (init_session_logger(), session_logger_exports));
   initSessionLogger2();
   const log25 = createSessionModuleLogger2("boot");
-  if (!await isInsideGitRepo2()) {
+  const detection = await detectProjectRoot(process.cwd());
+  if (!detection.isProject) {
+    const antiSignals = detection.signals.filter((s) => s.startsWith("anti-"));
     process.stderr.write(
-      "[unerr] Not inside a git repository. Run unerr from a project folder.\n"
+      `\x1B[38;2;248;113;113m\u2717\x1B[0m No code project detected in this directory.
+  unerr needs a folder containing source code to index.
+  Detection score: ${detection.score} (need ${DETECTION_THRESHOLD})
+` + (antiSignals.length > 0 ? `  Negative signals: ${antiSignals.map((s) => s.replace("anti-", "")).join(", ")}
+` : "") + "\n  Checked for: project files (package.json, Cargo.toml, go.mod, pyproject.toml, ...),\n  VCS directories (.git, .hg, .svn), IDE configs (.vscode, .idea),\n  CI/CD files (.github, Jenkinsfile), lock files, and source code\n  across 50+ languages in root + standard source directories.\n\n  \u25B8 Run \x1B[1munerr\x1B[0m from a project root directory.\n"
     );
     process.exit(1);
   }
-  log25.info({ msg: "First-run boot, entering local setup" });
+  if (!detection.hasGit) {
+    process.stderr.write(
+      "\x1B[38;2;251;191;36m\u26A0\x1B[0m Project detected (" + detection.reason + ") but no git repository found.\n  unerr works best with git. Consider running \x1B[1mgit init\x1B[0m first.\n  Continuing anyway...\n\n"
+    );
+  }
+  log25.info({ msg: "First-run boot, entering local setup", detection: detection.reason, score: detection.score, hasGit: detection.hasGit });
   const { runSetup: runSetup2 } = await Promise.resolve().then(() => (init_setup_wizard(), setup_wizard_exports));
   const result = await runSetup2();
   if (result.action === "setup") {
@@ -43335,15 +45144,21 @@ async function firstRunBoot() {
 }
 async function mcpBoot(cwd) {
   initFileLog(cwd);
-  if (!await isInsideGitRepo2()) {
+  const detection = await detectProjectRoot(cwd);
+  if (!detection.isProject) {
+    const antiSignals = detection.signals.filter((s) => s.startsWith("anti-"));
     process.stderr.write(
-      "[unerr] Not inside a git repository. Run unerr from a project folder.\n"
+      `\x1B[38;2;248;113;113m\u2717\x1B[0m No code project detected in this directory.
+  unerr needs a folder containing source code to index.
+  Detection score: ${detection.score} (need ${DETECTION_THRESHOLD})
+` + (antiSignals.length > 0 ? `  Negative signals: ${antiSignals.map((s) => s.replace("anti-", "")).join(", ")}
+` : "") + "\n  \u25B8 Run \x1B[1munerr --mcp\x1B[0m from a project root directory.\n"
     );
     process.exit(1);
   }
-  const stateDir = join66(cwd, ".unerr", "state");
-  const sockPath = join66(stateDir, "proxy.sock");
-  if (existsSync61(sockPath)) {
+  const stateDir = join67(cwd, ".unerr", "state");
+  const sockPath = join67(stateDir, "proxy.sock");
+  if (existsSync62(sockPath)) {
     const { PidLock: PidLock2 } = await Promise.resolve().then(() => (init_pid_lock(), pid_lock_exports));
     const pidLock = new PidLock2(stateDir);
     const probeResult = await pidLock.probe();
@@ -43367,10 +45182,10 @@ async function mcpBoot(cwd) {
     const { mkdirSync: mkdirSync39, writeFileSync: writeFileSync36 } = await import("fs");
     const { createHash: createHash5 } = await import("crypto");
     const repoId = createHash5("sha256").update(cwd).digest("hex").slice(0, 12);
-    const unerrDir = join66(cwd, ".unerr");
+    const unerrDir = join67(cwd, ".unerr");
     mkdirSync39(unerrDir, { recursive: true });
     writeFileSync36(
-      join66(unerrDir, "config.json"),
+      join67(unerrDir, "config.json"),
       JSON.stringify(
         { repoId, mode: "local", createdAt: (/* @__PURE__ */ new Date()).toISOString() },
         null,