@unerr-ai/unerr 0.1.7 → 0.1.8

package/dist/cli.js

@@ -245,16 +245,16 @@ async function getParser(language) {
     const parser = new TreeSitter();
     const langFile = `tree-sitter-${language}.wasm`;
     try {
-      const { join: join83 } = await import("path");
+      const { join: join85 } = await import("path");
       const { existsSync: existsSync82 } = await import("fs");
       const possiblePaths = [
-        join83(
+        join85(
           process.cwd(),
           "node_modules",
           `tree-sitter-${language}`,
           langFile
         ),
-        join83(process.cwd(), "node_modules", "web-tree-sitter", langFile)
+        join85(process.cwd(), "node_modules", "web-tree-sitter", langFile)
       ];
       let wasmPath = null;
       for (const p of possiblePaths) {
@@ -5770,6 +5770,7 @@ var init_startup_log = __esm({
 // src/config/settings.ts
 var settings_exports = {};
 __export(settings_exports, {
+  FetchUrlConfigSchema: () => FetchUrlConfigSchema,
   LocalLlmConfigSchema: () => LocalLlmConfigSchema,
   SettingsSchema: () => SettingsSchema,
   loadSettings: () => loadSettings,
@@ -5852,7 +5853,7 @@ function loadSettings(cwd) {
   };
   return SettingsSchema.parse(merged);
 }
-var LlmProviderEnum, EndpointConfigSchema, LocalLlmConfigSchema, LlmConfigSchema, SettingsSchema, DEFAULTS;
+var LlmProviderEnum, EndpointConfigSchema, LocalLlmConfigSchema, LlmConfigSchema, FetchUrlConfigSchema, SettingsSchema, DEFAULTS;
 var init_settings = __esm({
   "src/config/settings.ts"() {
     "use strict";
@@ -5885,6 +5886,17 @@ var init_settings = __esm({
       apiKey: z.string().optional(),
       baseUrl: z.string().optional()
     });
+    FetchUrlConfigSchema = z.object({
+      playwright: z.object({
+        enabled: z.boolean().default(false),
+        timeoutMs: z.number().int().min(1e3).max(6e4).default(15e3),
+        waitUntil: z.enum(["load", "domcontentloaded", "networkidle"]).default("networkidle")
+      }).default(() => ({
+        enabled: false,
+        timeoutMs: 15e3,
+        waitUntil: "networkidle"
+      }))
+    });
     SettingsSchema = z.object({
       /** Default Claude model for interactive sessions */
       model: z.string().default("claude-sonnet-4-20250514"),
@@ -5899,7 +5911,15 @@ var init_settings = __esm({
       /** AI SDK LLM configuration (Sprint D — unified multi-provider) */
       llm: LlmConfigSchema.optional(),
       /** BYO-LLM configuration for local LLM providers */
-      localLlm: LocalLlmConfigSchema.optional()
+      localLlm: LocalLlmConfigSchema.optional(),
+      /** fetch_url runtime config (Playwright SPA fallback, etc.) */
+      fetchUrl: FetchUrlConfigSchema.default(() => ({
+        playwright: {
+          enabled: false,
+          timeoutMs: 15e3,
+          waitUntil: "networkidle"
+        }
+      }))
     });
     DEFAULTS = SettingsSchema.parse({});
   }
@@ -6551,6 +6571,19 @@ CREATE TABLE IF NOT EXISTS meta (
   key TEXT PRIMARY KEY,
   value TEXT NOT NULL
 );
+
+CREATE TABLE IF NOT EXISTS fetch_cache (
+  url TEXT PRIMARY KEY,
+  content_hash TEXT NOT NULL,
+  markdown TEXT NOT NULL,
+  title TEXT NOT NULL,
+  extractor TEXT NOT NULL,
+  raw_bytes INTEGER NOT NULL,
+  compressed_bytes INTEGER NOT NULL,
+  fetched_at INTEGER NOT NULL,
+  hit_count INTEGER NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_fetch_cache_fetched ON fetch_cache(fetched_at);
 `;
     SCHEMA_VERSION = "1";
     MetricsStore = class {
@@ -6660,9 +6693,39 @@ CREATE TABLE IF NOT EXISTS meta (
       `),
           allSessionSummaries: this.db.prepare(`
         SELECT * FROM session_summaries ORDER BY ended_at DESC
+      `),
+          upsertFetchCache: this.db.prepare(`
+        INSERT INTO fetch_cache
+          (url, content_hash, markdown, title, extractor,
+           raw_bytes, compressed_bytes, fetched_at, hit_count)
+        VALUES (@url, @content_hash, @markdown, @title, @extractor,
+                @raw_bytes, @compressed_bytes, @fetched_at, 0)
+        ON CONFLICT(url) DO UPDATE SET
+          content_hash = excluded.content_hash,
+          markdown = excluded.markdown,
+          title = excluded.title,
+          extractor = excluded.extractor,
+          raw_bytes = excluded.raw_bytes,
+          compressed_bytes = excluded.compressed_bytes,
+          fetched_at = excluded.fetched_at
+      `),
+          getFetchCache: this.db.prepare(`
+        SELECT * FROM fetch_cache WHERE url = @url
+      `),
+          bumpFetchCacheHit: this.db.prepare(`
+        UPDATE fetch_cache SET hit_count = hit_count + 1 WHERE url = @url
       `)
         };
       }
+      upsertFetchCacheRow(row) {
+        this.stmt.upsertFetchCache.run(row);
+      }
+      getFetchCacheRow(url) {
+        return this.stmt.getFetchCache.get({ url }) ?? null;
+      }
+      bumpFetchCacheHitFor(url) {
+        this.stmt.bumpFetchCacheHit.run({ url });
+      }
       // ── Writes ──────────────────────────────────────────────────────────
       insertCompression(row) {
         return Number(this.stmt.insertCompression.run(row).lastInsertRowid);
@@ -11178,7 +11241,7 @@ async function resolveJavaBuildTool(projectRoot, _options) {
     };
     writeNeedsInput(projectRoot, [signal]);
     log6.info(
-      `Java build tool: ${choice.tool} (auto: ${choice.reason}). Override: unerr daemon config . --java-build-tool=<tool>`
+      `Java build tool: ${choice.tool} (auto: ${choice.reason}). Override: unerr pm config . --java-build-tool=<tool>`
     );
   } else {
     log6.info(`Java build tool: ${choice.tool} (${choice.reason})`);
@@ -11813,6 +11876,7 @@ __export(local_indexer_exports, {
   discoverSourceFiles: () => discoverSourceFiles,
   indexLocalProject: () => indexLocalProject,
   reindexFile: () => reindexFile,
+  removeOrphanedEntities: () => removeOrphanedEntities,
   resolveImportSourceToFile: () => resolveImportSourceToFile,
   runCommunityDetection: () => runCommunityDetection,
   runConventionDetection: () => runConventionDetection
@@ -12830,7 +12894,45 @@ async function removeOrphanedEntities(graphStore, liveKeys) {
   const orphanKeys = existingKeys.filter((k) => !liveKeys.has(k));
   if (orphanKeys.length === 0) return;
   log7.info(`Removing ${orphanKeys.length} orphaned entities from graph`);
-  for (const key of orphanKeys) {
+  for (let i = 0; i < orphanKeys.length; i += ORPHAN_BATCH_SIZE) {
+    const chunk = orphanKeys.slice(i, i + ORPHAN_BATCH_SIZE);
+    const keyRows = chunk.map((k) => [k]);
+    try {
+      await db.run(
+        `orphan[k] <- $keys
+         ?[from_key, to_key, type] := orphan[from_key], *edges{from_key, to_key, type}
+         :rm edges {from_key, to_key, type}`,
+        { keys: keyRows }
+      );
+      await db.run(
+        `orphan[k] <- $keys
+         ?[from_key, to_key, type] := orphan[to_key], *edges{from_key, to_key, type}
+         :rm edges {from_key, to_key, type}`,
+        { keys: keyRows }
+      );
+      await db.run(
+        `orphan[k] <- $keys
+         ?[token, entity_key] := orphan[entity_key], *search_tokens[token, entity_key]
+         :rm search_tokens {token, entity_key}`,
+        { keys: keyRows }
+      );
+      await db.run(
+        `orphan[k] <- $keys
+         ?[file_path, entity_key] := orphan[entity_key], *file_index[file_path, entity_key]
+         :rm file_index {file_path, entity_key}`,
+        { keys: keyRows }
+      );
+      await db.run("?[key] <- $keys :rm entities {key}", { keys: keyRows });
+    } catch (err) {
+      log7.info(
+        `Batched orphan removal failed for chunk of ${chunk.length} (${formatUnknownError(err)}); falling back to per-key`
+      );
+      await removeOrphansPerKey(db, chunk);
+    }
+  }
+}
+async function removeOrphansPerKey(db, keys) {
+  for (const key of keys) {
     try {
       await db.run(
         "?[from_key, to_key, type] := *edges{from_key, to_key, type}, from_key = $key :rm edges {from_key, to_key, type}",
@@ -12987,7 +13089,7 @@ async function indexDocumentFiles(projectRoot, graphStore) {
   }
   return docKeys;
 }
-var INDEXABLE_EXTENSIONS, EXCLUDED_DIRS2, EXCLUDED_PATH_PREFIXES, MAX_FILE_SIZE, DOCUMENT_EXTENSIONS, DOCUMENT_NAMES, CI_CD_DIRS, DOC_READ_LIMIT, log7, DOC_TOKEN_PATTERNS;
+var INDEXABLE_EXTENSIONS, EXCLUDED_DIRS2, EXCLUDED_PATH_PREFIXES, MAX_FILE_SIZE, DOCUMENT_EXTENSIONS, DOCUMENT_NAMES, CI_CD_DIRS, DOC_READ_LIMIT, log7, ORPHAN_BATCH_SIZE, DOC_TOKEN_PATTERNS;
 var init_local_indexer = __esm({
   "src/intelligence/local-indexer.ts"() {
     "use strict";
@@ -13136,6 +13238,7 @@ var init_local_indexer = __esm({
 `);
       }
     };
+    ORPHAN_BATCH_SIZE = 1e3;
     DOC_TOKEN_PATTERNS = {
       ".md": /^#{1,6}\s+(.+)$/gm,
       ".mdx": /^#{1,6}\s+(.+)$/gm,
@@ -16881,9 +16984,9 @@ function createEmptyAllTime() {
 function loadStats() {
   const currentWeek = getWeekStart();
   try {
-    const { readFileSync: readFileSync70 } = __require("fs");
+    const { readFileSync: readFileSync71 } = __require("fs");
     const raw = JSON.parse(
-      readFileSync70(getStatsPath(), "utf-8")
+      readFileSync71(getStatsPath(), "utf-8")
     );
     if (raw.version !== 1) {
       return {
@@ -17601,9 +17704,9 @@ function getCumulativePath() {
 function loadCumulativeStats() {
   const currentWeek = getWeekStart2();
   try {
-    const { readFileSync: readFileSync70 } = __require("fs");
+    const { readFileSync: readFileSync71 } = __require("fs");
     const raw = JSON.parse(
-      readFileSync70(getCumulativePath(), "utf-8")
+      readFileSync71(getCumulativePath(), "utf-8")
     );
     if (raw.weekStart !== currentWeek) {
       return {
@@ -17664,9 +17767,9 @@ function createEmptyCumulativeLocal(weekStart) {
 function loadCumulativeLocalStats() {
   const currentWeek = getWeekStart2();
   try {
-    const { readFileSync: readFileSync70 } = __require("fs");
+    const { readFileSync: readFileSync71 } = __require("fs");
     const raw = JSON.parse(
-      readFileSync70(getCumulativeLocalPath(), "utf-8")
+      readFileSync71(getCumulativeLocalPath(), "utf-8")
     );
     if (raw.weekStartDate !== currentWeek) {
       return createEmptyCumulativeLocal(currentWeek);
@@ -19119,6 +19222,24 @@ var init_tool_clusters = __esm({
           "starting",
           "planning"
         ]
+      },
+      {
+        id: "web",
+        name: "Web Fetch",
+        tools: ["fetch_url"],
+        triggerKeywords: [
+          "fetch",
+          "url",
+          "webpage",
+          "web page",
+          "http",
+          "https",
+          "scrape",
+          "docs at",
+          "documentation at",
+          "blog",
+          "article"
+        ]
       }
     ];
     TOOL_TO_CLUSTER = /* @__PURE__ */ new Map();
@@ -19236,6 +19357,11 @@ var init_tool_descriptions = __esm({
         active: "Find callers or callees of an entity across the codebase. Pass direction:'callers' (default) or 'callees'. Catches indirect refs grep misses.",
         locked: "[tier 1 \u2014 always exposed]"
       },
+      fetch_url: {
+        tier: 1,
+        active: "Fetch a web page and return DOM-extracted markdown passages. Strips chrome, converts to ATX-markdown, splits by heading, ranks by BM25 when prompt is set, caches by content hash. Use instead of built-in WebFetch \u2014 5\u201310\xD7 fewer tokens.",
+        locked: "[tier 1 \u2014 always exposed]"
+      },
       // ── Tier 2 — structural unlock ─────────────────────────────────────────
       get_critical_nodes: {
         tier: 2,
@@ -19407,6 +19533,36 @@ var init_tool_definitions = __esm({
           openWorldHint: false
         }
       },
+      fetch_url: {
+        inputSchema: {
+          type: "object",
+          properties: {
+            url: {
+              type: "string",
+              description: "Absolute URL to fetch (http or https). Localhost is allowed without TLS upgrade."
+            },
+            prompt: {
+              type: "string",
+              description: "Optional. When set AND extracted markdown > 8 KB, passages are re-ranked by BM25 relevance to this prompt (default top 20)."
+            },
+            offset: {
+              type: "integer",
+              description: "Passage index to start at for pagination (default 0). Pair with limit to walk long pages without re-fetching."
+            },
+            limit: {
+              type: "integer",
+              description: "Maximum passages to return (default 30, max 300). Also acts as BM25 topK when prompt is set."
+            },
+            token_budget: TOKEN_BUDGET_PROP
+          },
+          required: ["url"]
+        },
+        annotations: {
+          title: "Fetch Web Page (Markdown + BM25)",
+          readOnlyHint: true,
+          openWorldHint: true
+        }
+      },
       file_outline: {
         inputSchema: {
           type: "object",
@@ -23084,6 +23240,12 @@ var init_wire_cap = __esm({
         // statically. The caller should pick from the returned `entities[].name`
         // and re-call file_read with that exact value. A literal `entity:<name>`
         // hint trains the agent to paste the placeholder verbatim.
+      },
+      fetch_url: {
+        arrayKey: "passages",
+        defaultLimit: 30,
+        maxLimit: 300,
+        cursorArg: "limit"
       }
     };
     HARD_BYTE_CAP = 8192;
@@ -24309,6 +24471,785 @@ var init_file_read_protocol = __esm({
   }
 });
 
+// src/tools/web/bm25-rank.ts
+function tokenize2(text2) {
+  return text2.toLowerCase().replace(/[^a-z0-9\s]+/g, " ").split(/\s+/).filter((t) => t.length > 1 && !STOPWORDS.has(t));
+}
+async function rankPassagesByPrompt(passages, opts) {
+  const prompt = opts.prompt?.trim();
+  if (!prompt || passages.length === 0) return passages;
+  const promptTokens = tokenize2(prompt);
+  if (promptTokens.length === 0) return passages;
+  const mod = await import("wink-bm25-text-search");
+  const engine = mod.default();
+  engine.defineConfig({ fldWeights: { text: 1, heading: 2 } });
+  engine.definePrepTasks([tokenize2]);
+  for (const p of passages) {
+    engine.addDoc(
+      { text: p.text, heading: p.heading ?? "" },
+      String(p.index)
+    );
+  }
+  engine.consolidate();
+  const hits = engine.search(prompt);
+  if (hits.length === 0) return passages;
+  const topK = Math.max(1, opts.topK ?? Math.min(20, passages.length));
+  const ranked = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [docId] of hits.slice(0, topK)) {
+    const idx = Number(docId);
+    const p = passages.find((x2) => x2.index === idx);
+    if (p && !seen.has(idx)) {
+      ranked.push(p);
+      seen.add(idx);
+    }
+  }
+  if (ranked.length === 0) return passages;
+  return ranked;
+}
+var STOPWORDS;
+var init_bm25_rank = __esm({
+  "src/tools/web/bm25-rank.ts"() {
+    "use strict";
+    STOPWORDS = /* @__PURE__ */ new Set([
+      "a",
+      "an",
+      "the",
+      "is",
+      "are",
+      "was",
+      "were",
+      "be",
+      "been",
+      "being",
+      "of",
+      "and",
+      "or",
+      "but",
+      "in",
+      "on",
+      "at",
+      "to",
+      "for",
+      "with",
+      "by",
+      "from",
+      "up",
+      "down",
+      "out",
+      "off",
+      "over",
+      "under",
+      "as",
+      "this",
+      "that",
+      "these",
+      "those",
+      "it",
+      "its",
+      "into",
+      "if",
+      "then",
+      "do",
+      "does",
+      "did"
+    ]);
+  }
+});
+
+// src/tools/web/diff-cache.ts
+import { createHash as createHash3 } from "crypto";
+import { join as join60 } from "path";
+function hashHtml(html) {
+  return createHash3("sha256").update(html).digest("hex").slice(0, 32);
+}
+function lookupFetchCache(cwd, url) {
+  try {
+    const store = openMetricsStore(join60(cwd, ".unerr"));
+    const row = store.getFetchCacheRow(url);
+    if (!row) return { hit: false, prior: null };
+    return { hit: true, prior: row };
+  } catch {
+    return { hit: false, prior: null };
+  }
+}
+function storeFetchCache(cwd, row) {
+  try {
+    const store = openMetricsStore(join60(cwd, ".unerr"));
+    store.upsertFetchCacheRow({ ...row, hit_count: 0 });
+  } catch {
+  }
+}
+function bumpCacheHit(cwd, url) {
+  try {
+    const store = openMetricsStore(join60(cwd, ".unerr"));
+    store.bumpFetchCacheHitFor(url);
+  } catch {
+  }
+}
+function summarizeMarkdownDiff(oldMd, newMd) {
+  if (oldMd === newMd) {
+    return { unchanged: true, changedRegions: 0, addedLines: 0, removedLines: 0 };
+  }
+  const oldLines = new Set(oldMd.split("\n"));
+  const newLines = newMd.split("\n");
+  let added = 0;
+  let regions = 0;
+  let inRegion = false;
+  for (const line of newLines) {
+    if (!oldLines.has(line)) {
+      added++;
+      if (!inRegion) {
+        regions++;
+        inRegion = true;
+      }
+    } else {
+      inRegion = false;
+    }
+  }
+  const newLineSet = new Set(newLines);
+  let removed = 0;
+  for (const line of oldMd.split("\n")) {
+    if (!newLineSet.has(line)) removed++;
+  }
+  return {
+    unchanged: false,
+    changedRegions: regions,
+    addedLines: added,
+    removedLines: removed
+  };
+}
+var init_diff_cache = __esm({
+  "src/tools/web/diff-cache.ts"() {
+    "use strict";
+    init_metrics_store();
+  }
+});
+
+// src/tools/web/extract.ts
+async function extractMainContent(html, baseUrl) {
+  const { JSDOM } = await import("jsdom");
+  const dom = new JSDOM(html, { url: baseUrl });
+  const defuddled = await tryDefuddle(dom);
+  if (defuddled && stripTags(defuddled.contentHtml).length >= MIN_USEFUL_CHARS) {
+    return defuddled;
+  }
+  const readabilityResult = await tryReadability(dom);
+  if (readabilityResult && stripTags(readabilityResult.contentHtml).length >= MIN_USEFUL_CHARS) {
+    return readabilityResult;
+  }
+  return rawBodyFallback(dom);
+}
+async function tryDefuddle(dom) {
+  try {
+    const mod = await import("defuddle");
+    const DefuddleCtor = mod.default;
+    const doc = dom.window.document;
+    const result = new DefuddleCtor(doc, { markdown: false }).parse();
+    if (!result?.content) return null;
+    return {
+      title: result.title ?? "",
+      contentHtml: result.content,
+      wordCount: result.wordCount ?? wordCountOf(result.content),
+      byline: result.author ?? void 0,
+      excerpt: result.description ?? void 0,
+      extractor: "defuddle"
+    };
+  } catch {
+    return null;
+  }
+}
+async function tryReadability(dom) {
+  try {
+    const mod = await import("@mozilla/readability");
+    const doc = dom.window.document;
+    if (mod.isProbablyReaderable && !mod.isProbablyReaderable(doc)) {
+      return null;
+    }
+    const article = new mod.Readability(
+      doc
+    ).parse();
+    if (!article?.content) return null;
+    return {
+      title: article.title ?? "",
+      contentHtml: article.content,
+      wordCount: wordCountOf(article.textContent ?? article.content),
+      byline: article.byline ?? void 0,
+      excerpt: article.excerpt ?? void 0,
+      lang: article.lang ?? void 0,
+      extractor: "readability"
+    };
+  } catch {
+    return null;
+  }
+}
+function rawBodyFallback(dom) {
+  const doc = dom.window.document;
+  for (const sel of ["script", "style", "noscript", "iframe", "svg"]) {
+    for (const node of doc.querySelectorAll(sel)) node.remove();
+  }
+  const main = doc.querySelector("main") ?? doc.querySelector("article") ?? doc.body ?? doc.documentElement;
+  const html = main?.innerHTML ?? "";
+  return {
+    title: doc.title ?? "",
+    contentHtml: html,
+    wordCount: wordCountOf(main?.textContent ?? ""),
+    extractor: "raw-body"
+  };
+}
+function stripTags(html) {
+  return html.replace(/<[^>]+>/g, "").trim();
+}
+function wordCountOf(text2) {
+  return text2.trim().split(/\s+/).filter(Boolean).length;
+}
+var MIN_USEFUL_CHARS;
+var init_extract = __esm({
+  "src/tools/web/extract.ts"() {
+    "use strict";
+    MIN_USEFUL_CHARS = 200;
+  }
+});
+
+// src/tools/web/markdown.ts
+async function htmlToMarkdown(html) {
+  if (!html.trim()) return "";
+  const TurndownModule = await import("turndown");
+  const Turndown = TurndownModule.default;
+  const td = new Turndown({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced",
+    hr: "---",
+    bulletListMarker: "-",
+    emDelimiter: "_"
+  });
+  td.addRule("drop-anchor-only", {
+    filter: (node) => {
+      if (node.nodeName !== "A") return false;
+      const href = node.getAttribute("href") ?? "";
+      const text2 = (node.textContent ?? "").trim();
+      return href.startsWith("#") || href === "" && text2 === "";
+    },
+    replacement: (content) => content
+  });
+  td.addRule("strip-tracking-params", {
+    filter: (node) => node.nodeName === "A",
+    replacement: (content, node) => {
+      const rawHref = node.getAttribute("href") ?? "";
+      const cleanHref = cleanUrl(rawHref);
+      const title = node.getAttribute("title");
+      if (!cleanHref) return content;
+      const titleSuffix = title ? ` "${title}"` : "";
+      return `[${content}](${cleanHref}${titleSuffix})`;
+    }
+  });
+  return td.turndown(html);
+}
+function cleanUrl(href) {
+  if (!href || href.startsWith("#") || href.startsWith("javascript:")) {
+    return href;
+  }
+  try {
+    const url = new URL(href, "https://example.invalid");
+    const params = url.searchParams;
+    const drop = [];
+    for (const key of params.keys()) {
+      if (TRACKING_PARAMS.test(key)) drop.push(key);
+    }
+    for (const key of drop) params.delete(key);
+    return url.protocol === "https:" && url.hostname === "example.invalid" ? url.pathname + url.search + url.hash : url.toString();
+  } catch {
+    return href;
+  }
+}
+var TRACKING_PARAMS;
+var init_markdown = __esm({
+  "src/tools/web/markdown.ts"() {
+    "use strict";
+    TRACKING_PARAMS = /^(utm_|mc_|gclid$|fbclid$|yclid$|msclkid$|ref$|ref_)/i;
+  }
+});
+
+// src/tools/web/passage-split.ts
+function splitMarkdownIntoPassages(markdown) {
+  const lines = markdown.split("\n");
+  const passages = [];
+  let currentHeading = null;
+  let buffer = [];
+  let bufferStart = 0;
+  let inFence = false;
+  let fenceMarker = "";
+  const flush = () => {
+    const text2 = buffer.join("\n").trim();
+    if (text2) {
+      passages.push({
+        index: passages.length,
+        heading: currentHeading,
+        text: text2,
+        startLine: bufferStart + 1
+      });
+    }
+    buffer = [];
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const fenceMatch = line.match(/^(```|~~~)/);
+    if (fenceMatch) {
+      if (!inFence) {
+        inFence = true;
+        fenceMarker = fenceMatch[1] ?? "```";
+        if (buffer.length === 0) bufferStart = i;
+        buffer.push(line);
+      } else if (line.startsWith(fenceMarker)) {
+        buffer.push(line);
+        inFence = false;
+      } else {
+        buffer.push(line);
+      }
+      continue;
+    }
+    if (inFence) {
+      buffer.push(line);
+      continue;
+    }
+    const headingMatch = line.match(/^(#{1,6})\s+(.+?)\s*$/);
+    if (headingMatch) {
+      flush();
+      currentHeading = headingMatch[2] ?? null;
+      bufferStart = i;
+      buffer.push(line);
+      continue;
+    }
+    if (line.trim() === "") {
+      if (buffer.length > 0) flush();
+      continue;
+    }
+    if (buffer.length === 0) bufferStart = i;
+    buffer.push(line);
+  }
+  flush();
+  return passages;
+}
+var init_passage_split = __esm({
+  "src/tools/web/passage-split.ts"() {
+    "use strict";
+  }
+});
+
+// src/tools/web/post-process.ts
+import { readdirSync as readdirSync14, readFileSync as readFileSync51 } from "fs";
+import { join as join61 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+function loadRules() {
+  if (rulesCache) return rulesCache;
+  const map = /* @__PURE__ */ new Map();
+  if (!RULES_DIR) {
+    rulesCache = map;
+    return map;
+  }
+  let entries;
+  try {
+    entries = readdirSync14(RULES_DIR);
+  } catch {
+    rulesCache = map;
+    return map;
+  }
+  for (const name of entries) {
+    if (!name.endsWith(".json")) continue;
+    try {
+      const raw = readFileSync51(join61(RULES_DIR, name), "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed.host) map.set(parsed.host.toLowerCase(), parsed);
+    } catch {
+    }
+  }
+  rulesCache = map;
+  return map;
+}
+function postProcessMarkdown(markdown, opts = {}) {
+  let out = universalCleanup(markdown);
+  const hostRule = pickHostRule(opts);
+  if (hostRule) out = applyHostRule(out, hostRule);
+  out = universalCleanup(out);
+  return out;
+}
+function universalCleanup(md) {
+  return md.replace(/\r\n/g, "\n").replace(/[ \t]+$/gm, "").replace(/\n{3,}/g, "\n\n").replace(/^\[\s*\]\([^)]*\)\s*$/gm, "").trim();
+}
+function pickHostRule(opts) {
+  if (opts.rules?.length) {
+    return mergeRules(opts.rules);
+  }
+  if (!opts.url) return null;
+  try {
+    const host = new URL(opts.url).hostname.toLowerCase();
+    const rules = loadRules();
+    const exact = rules.get(host);
+    if (exact) return exact;
+    const parts = host.split(".");
+    for (let i = 1; i < parts.length - 1; i++) {
+      const suffix = parts.slice(i).join(".");
+      const match = rules.get(suffix);
+      if (match) return match;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function mergeRules(rules) {
+  return {
+    host: "merged",
+    drop: rules.flatMap((r) => r.drop ?? []),
+    replace: rules.flatMap((r) => r.replace ?? [])
+  };
+}
+function applyHostRule(md, rule) {
+  let out = md;
+  if (rule.drop?.length) {
+    for (const pat of rule.drop) {
+      try {
+        const re = new RegExp(pat, "gm");
+        out = out.replace(re, "");
+      } catch {
+      }
+    }
+  }
+  if (rule.replace?.length) {
+    for (const { pattern, with: replacement } of rule.replace) {
+      try {
+        const re = new RegExp(pattern, "gm");
+        out = out.replace(re, replacement);
+      } catch {
+      }
+    }
+  }
+  return out;
+}
+var RULES_DIR, rulesCache;
+var init_post_process = __esm({
+  "src/tools/web/post-process.ts"() {
+    "use strict";
+    RULES_DIR = (() => {
+      try {
+        return join61(fileURLToPath3(new URL(".", import.meta.url)), "rules");
+      } catch {
+        return "";
+      }
+    })();
+    rulesCache = null;
+  }
+});
+
+// src/tools/web/spa-render.ts
+function shouldUsePlaywright(args) {
+  if (!args.config?.playwright?.enabled) return false;
+  if (args.extractor !== "raw-body") return false;
+  return args.wordCount < SPA_EMPTY_WC;
+}
+async function renderWithPlaywright(url, config) {
+  const pw = await loadPlaywright();
+  if (!pw) return null;
+  const browser = await pw.chromium.launch({ headless: true });
+  try {
+    const ctx = await browser.newContext({
+      userAgent: "unerr-fetch-url/1.0 (+https://unerr.dev) Mozilla/5.0 compatible"
+    });
+    const page = await ctx.newPage();
+    const response = await page.goto(url, {
+      waitUntil: config.playwright.waitUntil,
+      timeout: config.playwright.timeoutMs
+    });
+    const html = await page.content();
+    return {
+      html,
+      finalUrl: page.url(),
+      status: response?.status() ?? 200
+    };
+  } finally {
+    await browser.close();
+  }
+}
+async function loadPlaywright() {
+  try {
+    return await import("playwright");
+  } catch {
+    return null;
+  }
+}
+var SPA_EMPTY_WC;
+var init_spa_render = __esm({
+  "src/tools/web/spa-render.ts"() {
+    "use strict";
+    SPA_EMPTY_WC = 40;
+  }
+});
+
+// src/tools/web/telemetry.ts
+function recordFetchUrlTelemetry(cwd, ev) {
+  const savedPct = ev.rawBytes > 0 ? Math.round((ev.rawBytes - ev.compressedBytes) / ev.rawBytes * 100) : 0;
+  appendCompressionLog(cwd, {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    command: `fetch_url ${ev.url}`,
+    category: "fetch_url",
+    confidence: 1,
+    rawBytes: ev.rawBytes,
+    compressedBytes: ev.compressedBytes,
+    savedPct,
+    omniFallback: ev.extractor === "raw-body",
+    teeFile: ev.cacheHit ? "cache-hit" : void 0
+  });
+}
+var init_telemetry = __esm({
+  "src/tools/web/telemetry.ts"() {
+    "use strict";
+    init_shell_compression_log();
+  }
+});
+
+// src/tools/web/fetch-url-protocol.ts
+var fetch_url_protocol_exports = {};
+__export(fetch_url_protocol_exports, {
+  runFetchUrl: () => runFetchUrl
+});
+function shouldRank(args, markdown) {
+  if (!args.prompt || args.prompt.trim().length === 0) return false;
+  return Buffer.byteLength(markdown, "utf-8") > BM25_GATE_BYTES;
+}
+async function runFetchUrl(args, ctx) {
+  if (!args.url || typeof args.url !== "string") {
+    throw new Error("fetch_url requires a string `url` argument");
+  }
+  const url = upgradeToHttps(args.url);
+  const started = Date.now();
+  const fetched = await fetchHtml(url, ctx.abortSignal);
+  const contentHash = hashHtml(fetched.html);
+  const cache = lookupFetchCache(ctx.cwd, fetched.finalUrl);
+  let markdown;
+  let title;
+  let extractor;
+  let wordCount;
+  let cacheHit = false;
+  let diff;
+  if (cache.hit && cache.prior && cache.prior.content_hash === contentHash) {
+    markdown = cache.prior.markdown;
+    title = cache.prior.title;
+    extractor = "cache";
+    wordCount = markdown.trim().split(/\s+/).filter(Boolean).length;
+    cacheHit = true;
+    diff = {
+      unchanged: true,
+      changed_regions: 0,
+      added_lines: 0,
+      removed_lines: 0
+    };
+    bumpCacheHit(ctx.cwd, fetched.finalUrl);
+  } else {
+    let extracted = await extractMainContent(fetched.html, fetched.finalUrl);
+    const settings = safeLoadSettings(ctx.cwd);
+    if (shouldUsePlaywright({
+      config: settings?.fetchUrl,
+      extractor: extracted.extractor,
+      wordCount: extracted.wordCount
+    }) && settings) {
+      const rendered = await renderWithPlaywright(
+        fetched.finalUrl,
+        settings.fetchUrl
+      );
+      if (rendered) {
+        fetched.html = rendered.html;
+        fetched.finalUrl = rendered.finalUrl;
+        fetched.status = rendered.status;
+        extracted = await extractMainContent(rendered.html, rendered.finalUrl);
+      }
+    }
+    const rawMarkdown = await htmlToMarkdown(extracted.contentHtml);
+    markdown = postProcessMarkdown(rawMarkdown, { url: fetched.finalUrl });
+    title = extracted.title;
+    extractor = extracted.extractor;
+    wordCount = extracted.wordCount;
+    if (cache.prior) {
+      const summary = summarizeMarkdownDiff(cache.prior.markdown, markdown);
+      diff = {
+        unchanged: summary.unchanged,
+        changed_regions: summary.changedRegions,
+        added_lines: summary.addedLines,
+        removed_lines: summary.removedLines
+      };
+    }
+    storeFetchCache(ctx.cwd, {
+      url: fetched.finalUrl,
+      content_hash: contentHash,
+      markdown,
+      title,
+      extractor,
+      raw_bytes: Buffer.byteLength(fetched.html, "utf-8"),
+      compressed_bytes: Buffer.byteLength(markdown, "utf-8"),
+      fetched_at: Date.now()
+    });
+  }
+  const allPassages = splitMarkdownIntoPassages(markdown);
+  const ranked = shouldRank(args, markdown) ? await rankPassagesByPrompt(allPassages, {
+    prompt: args.prompt ?? "",
+    topK: args.limit ?? BM25_DEFAULT_TOPK
+  }) : allPassages;
+  const offset = Math.max(0, args.offset ?? 0);
+  const sliced = offset > 0 ? ranked.slice(offset) : ranked;
+  const rawBytes = byteLength(fetched.html);
+  const compressedBytes = byteLength(markdown);
+  recordFetchUrlTelemetry(ctx.cwd, {
+    url: fetched.finalUrl,
+    rawBytes,
+    compressedBytes,
+    durationMs: Date.now() - started,
+    extractor: extractor === "cache" ? "raw-body" : extractor,
+    cacheHit
+  });
+  return {
+    url: args.url,
+    final_url: fetched.finalUrl,
+    status: fetched.status,
+    title,
+    extractor,
+    word_count: wordCount,
+    cache_hit: cacheHit,
+    diff,
+    raw_bytes: rawBytes,
+    extracted_bytes: compressedBytes,
+    compression_ratio: rawBytes > 0 ? Math.round((1 - compressedBytes / rawBytes) * 100) / 100 : 0,
+    passages: sliced.map((p) => ({
+      index: p.index,
+      heading: p.heading,
+      text: p.text,
+      start_line: p.startLine
+    })),
+    total: allPassages.length
+  };
+}
+function upgradeToHttps(url) {
+  if (!url.startsWith("http://")) return url;
+  try {
+    const host = new URL(url).hostname;
+    if (host === "localhost" || host === "127.0.0.1" || host === "::1") {
+      return url;
+    }
+  } catch {
+    return url;
+  }
+  return "https://" + url.slice(7);
+}
+async function fetchHtml(url, abortSignal) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  const signal = abortSignal ? composeSignals(controller.signal, abortSignal) : controller.signal;
+  try {
+    const res = await fetch(url, {
+      signal,
+      redirect: "follow",
+      headers: {
+        "user-agent": "unerr-fetch-url/1.0 (+https://unerr.dev) Mozilla/5.0 compatible",
+        accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+      }
+    });
+    const contentType = res.headers.get("content-type") ?? "";
+    if (!contentType.includes("html") && !contentType.includes("xml")) {
+      throw new Error(
+        `fetch_url expected HTML response, got content-type: ${contentType || "unknown"}`
+      );
+    }
+    const reader = res.body?.getReader();
+    if (!reader) {
+      const text2 = await res.text();
+      return capHtml({
+        html: text2,
+        finalUrl: res.url,
+        status: res.status,
+        contentType
+      });
+    }
+    const chunks = [];
+    let total = 0;
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value) {
+        total += value.byteLength;
+        if (total > MAX_HTML_BYTES) {
+          await reader.cancel();
+          break;
+        }
+        chunks.push(value);
+      }
+    }
+    const merged = concatBytes(chunks);
+    const html = new TextDecoder("utf-8", { fatal: false }).decode(merged);
+    return capHtml({
+      html,
+      finalUrl: res.url,
+      status: res.status,
+      contentType
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function capHtml(fetched) {
+  if (fetched.html.length > MAX_HTML_BYTES) {
+    return { ...fetched, html: fetched.html.slice(0, MAX_HTML_BYTES) };
+  }
+  return fetched;
+}
+function composeSignals(a, b) {
+  const controller = new AbortController();
+  const onAbort = () => controller.abort();
+  if (a.aborted || b.aborted) controller.abort();
+  else {
+    a.addEventListener("abort", onAbort, { once: true });
+    b.addEventListener("abort", onAbort, { once: true });
+  }
+  return controller.signal;
+}
+function byteLength(s) {
+  return Buffer.byteLength(s, "utf-8");
+}
+function safeLoadSettings(cwd) {
+  try {
+    return loadSettings(cwd);
+  } catch {
+    return null;
+  }
+}
+function concatBytes(chunks) {
+  let total = 0;
+  for (const c of chunks) total += c.byteLength;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.byteLength;
+  }
+  return out;
+}
+var FETCH_TIMEOUT_MS, MAX_HTML_BYTES, BM25_GATE_BYTES, BM25_DEFAULT_TOPK;
+var init_fetch_url_protocol = __esm({
+  "src/tools/web/fetch-url-protocol.ts"() {
+    "use strict";
+    init_settings();
+    init_bm25_rank();
+    init_diff_cache();
+    init_extract();
+    init_markdown();
+    init_passage_split();
+    init_post_process();
+    init_spa_render();
+    init_telemetry();
+    FETCH_TIMEOUT_MS = 15e3;
+    MAX_HTML_BYTES = 5 * 1024 * 1024;
+    BM25_GATE_BYTES = 8 * 1024;
+    BM25_DEFAULT_TOPK = 20;
+  }
+});
+
 // src/intelligence/query-router.ts
 var query_router_exports = {};
 __export(query_router_exports, {
@@ -24564,7 +25505,9 @@ var init_query_router = __esm({
       "get_test_coverage",
       // Sprint FE-B: file read protocol
       "file_outline",
-      "file_read"
+      "file_read",
+      // Sprint FU-1: web fetch
+      "fetch_url"
     ]);
     ENRICHABLE_TOOLS = /* @__PURE__ */ new Set([
       // Agent-facing tools
@@ -25362,7 +26305,8 @@ var init_query_router = __esm({
           const saved = estimate.tokensWithout - estimate.tokensUsed;
           if (saved > 0) {
             const isFileNav = toolName === "file_read" || toolName === "file_outline" || toolName === "get_file";
-            const mechanism = isFileNav ? "file_read" : "graph_query";
+            const isFetchUrl = toolName === "fetch_url";
+            const mechanism = isFetchUrl ? "fetch_url" : isFileNav ? "file_read" : "graph_query";
             enrichTokensSaved = saved;
             enrichSavingsMechanism = mechanism;
             const dollarSavings = calculateDollarSavings(saved);
@@ -26280,11 +27224,11 @@ var init_query_router = __esm({
             const entity = await this.resolveEntityWithOverlay(key);
             if (entity?.file_path && entity.start_line > 0) {
               try {
-                const { readFileSync: readFileSync70 } = await import("fs");
+                const { readFileSync: readFileSync71 } = await import("fs");
                 const { resolve: resolve6 } = await import("path");
                 const cwd = this.projectRoot ?? process.cwd();
                 const abs = resolve6(cwd, entity.file_path);
-                const lines = readFileSync70(abs, "utf-8").split("\n");
+                const lines = readFileSync71(abs, "utf-8").split("\n");
                 const start = entity.start_line - 1;
                 const end = entity.end_line ?? lines.length;
                 const bodyLines = lines.slice(start, end);
@@ -26522,6 +27466,12 @@ var init_query_router = __esm({
               graph: this.localGraph
             });
           }
+          case "fetch_url": {
+            const { runFetchUrl: runFetchUrl2 } = await Promise.resolve().then(() => (init_fetch_url_protocol(), fetch_url_protocol_exports));
+            return runFetchUrl2(args, {
+              cwd: this.projectRoot ?? process.cwd()
+            });
+          }
           default:
             throw new Error(`Unknown local tool: ${toolName}`);
         }
@@ -27881,8 +28831,8 @@ __export(causal_bridge_exports, {
   assembleCausalChain: () => assembleCausalChain,
   computeDurability: () => computeDurability
 });
-import { existsSync as existsSync59, readFileSync as readFileSync51 } from "fs";
-import { join as join60 } from "path";
+import { existsSync as existsSync59, readFileSync as readFileSync52 } from "fs";
+import { join as join62 } from "path";
 function computeAggregateDurability(interactions) {
   if (interactions.length === 0) return 1;
   const survivedCount = interactions.filter((i) => i.survived).length;
@@ -28039,9 +28989,9 @@ var init_causal_bridge = __esm({
         return chains;
       }
       loadEntityLedgerEntries(entityKey2) {
-        const ledgerPath = join60(this.unerrDir, "ledger", "shadow.jsonl");
+        const ledgerPath = join62(this.unerrDir, "ledger", "shadow.jsonl");
         if (!existsSync59(ledgerPath)) return [];
-        const content = readFileSync51(ledgerPath, "utf-8");
+        const content = readFileSync52(ledgerPath, "utf-8");
         const lines = content.split("\n").filter((l) => l.trim().length > 0);
         const entries = [];
         for (const line of lines) {
@@ -28527,11 +29477,11 @@ var context_ledger_exports = {};
 __export(context_ledger_exports, {
   createContextLedger: () => createContextLedger
 });
-import { existsSync as existsSync60, mkdirSync as mkdirSync32, readFileSync as readFileSync52, writeFileSync as writeFileSync27 } from "fs";
-import { join as join61 } from "path";
+import { existsSync as existsSync60, mkdirSync as mkdirSync32, readFileSync as readFileSync53, writeFileSync as writeFileSync27 } from "fs";
+import { join as join63 } from "path";
 function createContextLedger(unerrDir2) {
-  const stateDir = join61(unerrDir2, "state");
-  const filePath = join61(stateDir, "context-ledger.json");
+  const stateDir = join63(unerrDir2, "state");
+  const filePath = join63(stateDir, "context-ledger.json");
   let records = [];
   let index = /* @__PURE__ */ new Map();
   function ensureDir() {
@@ -28550,7 +29500,7 @@ function createContextLedger(unerrDir2) {
       return /* @__PURE__ */ new Map();
     }
     try {
-      const raw = readFileSync52(filePath, "utf-8");
+      const raw = readFileSync53(filePath, "utf-8");
       const parsed = JSON.parse(raw);
       records = Array.isArray(parsed) ? parsed : [];
     } catch {
@@ -29477,11 +30427,11 @@ __export(intent_correlator_exports, {
 import {
   existsSync as existsSync61,
   mkdirSync as mkdirSync33,
-  readFileSync as readFileSync53,
+  readFileSync as readFileSync54,
   renameSync as renameSync2,
   writeFileSync as writeFileSync28
 } from "fs";
-import { join as join62 } from "path";
+import { join as join64 } from "path";
 function extractFiles4(args) {
   const files = args.files;
   if (files && Array.isArray(files)) {
@@ -29529,8 +30479,8 @@ var init_intent_correlator = __esm({
       pendingPath;
       pending = [];
       constructor(unerrDir2) {
-        this.ledgerDir = join62(unerrDir2, "ledger");
-        this.pendingPath = join62(this.ledgerDir, "pending_correlations.json");
+        this.ledgerDir = join64(unerrDir2, "ledger");
+        this.pendingPath = join64(this.ledgerDir, "pending_correlations.json");
         if (!existsSync61(this.ledgerDir)) {
           mkdirSync33(this.ledgerDir, { recursive: true });
         }
@@ -29625,7 +30575,7 @@ var init_intent_correlator = __esm({
       load() {
         if (!existsSync61(this.pendingPath)) return;
         try {
-          const raw = readFileSync53(this.pendingPath, "utf-8");
+          const raw = readFileSync54(this.pendingPath, "utf-8");
           const parsed = JSON.parse(raw);
           if (Array.isArray(parsed)) {
             this.pending = parsed;
@@ -30190,7 +31140,7 @@ var init_session_state = __esm({
 
 // src/proxy/tool-exposure-store.ts
 import { promises as fs6 } from "fs";
-import { dirname as dirname16, join as join63 } from "path";
+import { dirname as dirname16, join as join65 } from "path";
 var ToolExposureStore;
 var init_tool_exposure_store = __esm({
   "src/proxy/tool-exposure-store.ts"() {
@@ -30200,7 +31150,7 @@ var init_tool_exposure_store = __esm({
       sessionId;
       ensuredDir = false;
       constructor(unerrDir2, sessionId) {
-        this.filePath = join63(unerrDir2, "router", "exposure-events.jsonl");
+        this.filePath = join65(unerrDir2, "router", "exposure-events.jsonl");
         this.sessionId = sessionId;
       }
       /**
@@ -30462,11 +31412,11 @@ var init_router_gateway = __esm({
 
 // src/timeline/timeline-store.ts
 import { existsSync as existsSync62, mkdirSync as mkdirSync34 } from "fs";
-import { join as join64 } from "path";
+import { join as join66 } from "path";
 async function openTimelineDb(projectRoot) {
-  const unerrDir2 = join64(projectRoot, ".unerr");
+  const unerrDir2 = join66(projectRoot, ".unerr");
   mkdirSync34(unerrDir2, { recursive: true });
-  const dbPath = join64(unerrDir2, TIMELINE_DB_FILENAME);
+  const dbPath = join66(unerrDir2, TIMELINE_DB_FILENAME);
   const isNew = !existsSync62(dbPath);
   const cozoModule = await import("cozo-node");
   const CozoDbConstructor = cozoModule.default ? cozoModule.default.CozoDb : cozoModule.CozoDb;
@@ -31510,23 +32460,23 @@ import {
   appendFileSync as appendFileSync8,
   existsSync as existsSync63,
   mkdirSync as mkdirSync35,
-  readFileSync as readFileSync54,
+  readFileSync as readFileSync55,
   renameSync as renameSync3,
   writeFileSync as writeFileSync29
 } from "fs";
-import { join as join65 } from "path";
+import { join as join67 } from "path";
 import { gzipSync } from "zlib";
 function archiveShadowLedger(unerrDir2, opts = {}) {
-  const ledgerDir = join65(unerrDir2, "ledger");
-  const filePath = join65(ledgerDir, "shadow.jsonl");
-  const archiveDir = join65(ledgerDir, "archive");
+  const ledgerDir = join67(unerrDir2, "ledger");
+  const filePath = join67(ledgerDir, "shadow.jsonl");
+  const archiveDir = join67(ledgerDir, "archive");
   if (!existsSync63(filePath)) {
     return { archived: 0, kept: 0, archivePath: null };
   }
   const retainMs = opts.retainMs ?? DEFAULT_RETAIN_MS;
   const now = opts.nowMs ?? Date.now();
   const cutoff = now - retainMs;
-  const raw = readFileSync54(filePath, "utf-8");
+  const raw = readFileSync55(filePath, "utf-8");
   const initialBytes = Buffer.byteLength(raw);
   const lines = raw.split("\n").filter((l) => l.trim().length > 0);
   const keep = [];
@@ -31551,7 +32501,7 @@ function archiveShadowLedger(unerrDir2, opts = {}) {
   }
   mkdirSync35(archiveDir, { recursive: true });
   const dateStamp = new Date(now).toISOString().slice(0, 10);
-  const archivePath = join65(archiveDir, `${dateStamp}.jsonl.gz`);
+  const archivePath = join67(archiveDir, `${dateStamp}.jsonl.gz`);
   const payload = `${archive.join("\n")}
 `;
   const gz = gzipSync(Buffer.from(payload, "utf-8"));
@@ -31563,7 +32513,7 @@ function archiveShadowLedger(unerrDir2, opts = {}) {
   const tmpPath = `${filePath}.tmp-${Date.now()}-${Math.random().toString(36).slice(2)}`;
   const kept = `${keep.join("\n")}${keep.length > 0 ? "\n" : ""}`;
   writeFileSync29(tmpPath, kept, "utf-8");
-  const afterRaw = readFileSync54(filePath, "utf-8");
+  const afterRaw = readFileSync55(filePath, "utf-8");
   const afterBytes = Buffer.byteLength(afterRaw);
   if (afterBytes > initialBytes) {
     const tail = afterRaw.slice(raw.length);
@@ -32072,12 +33022,12 @@ import { randomBytes as randomBytes5 } from "crypto";
 import {
   existsSync as existsSync64,
   mkdirSync as mkdirSync36,
-  readFileSync as readFileSync55,
-  readdirSync as readdirSync14,
+  readFileSync as readFileSync56,
+  readdirSync as readdirSync15,
   rmSync as rmSync2,
   writeFileSync as writeFileSync30
 } from "fs";
-import { join as join66 } from "path";
+import { join as join68 } from "path";
 var _log2, MAX_SNAPSHOTS, AUTO_SNAPSHOT_COOLDOWN_MS, WorkingSnapshotStore;
 var init_working_snapshots = __esm({
   "src/tracking/working-snapshots.ts"() {
@@ -32095,7 +33045,7 @@ var init_working_snapshots = __esm({
       unerrDir;
       constructor(unerrDir2) {
         this.unerrDir = unerrDir2;
-        this.snapshotDir = join66(unerrDir2, "snapshots");
+        this.snapshotDir = join68(unerrDir2, "snapshots");
         if (!existsSync64(this.snapshotDir)) {
           mkdirSync36(this.snapshotDir, { recursive: true });
         }
@@ -32116,7 +33066,7 @@ var init_working_snapshots = __esm({
           processed: false
         };
         writeFileSync30(
-          join66(this.snapshotDir, `${id}.json`),
+          join68(this.snapshotDir, `${id}.json`),
           JSON.stringify(snapshot, null, 2),
           "utf-8"
         );
@@ -32130,10 +33080,10 @@ var init_working_snapshots = __esm({
        * Get a snapshot by ID.
        */
       get(snapshotId) {
-        const filePath = join66(this.snapshotDir, `${snapshotId}.json`);
+        const filePath = join68(this.snapshotDir, `${snapshotId}.json`);
         if (!existsSync64(filePath)) return null;
         try {
-          return JSON.parse(readFileSync55(filePath, "utf-8"));
+          return JSON.parse(readFileSync56(filePath, "utf-8"));
         } catch {
           return null;
         }
@@ -32143,13 +33093,13 @@ var init_working_snapshots = __esm({
        */
       list() {
         if (!existsSync64(this.snapshotDir)) return [];
-        const files = readdirSync14(this.snapshotDir).filter(
+        const files = readdirSync15(this.snapshotDir).filter(
           (f) => f.endsWith(".json")
         );
         const snapshots = [];
         for (const file of files) {
           try {
-            const raw = readFileSync55(join66(this.snapshotDir, file), "utf-8");
+            const raw = readFileSync56(join68(this.snapshotDir, file), "utf-8");
             snapshots.push(JSON.parse(raw));
           } catch {
           }
@@ -32190,7 +33140,7 @@ var init_working_snapshots = __esm({
         if (!snapshot) return;
         snapshot.processed = true;
         writeFileSync30(
-          join66(this.snapshotDir, `${snapshotId}.json`),
+          join68(this.snapshotDir, `${snapshotId}.json`),
           JSON.stringify(snapshot, null, 2),
           "utf-8"
         );
@@ -32205,7 +33155,7 @@ var init_working_snapshots = __esm({
        * Delete a snapshot.
        */
       delete(snapshotId) {
-        const filePath = join66(this.snapshotDir, `${snapshotId}.json`);
+        const filePath = join68(this.snapshotDir, `${snapshotId}.json`);
         if (!existsSync64(filePath)) return false;
         rmSync2(filePath);
         return true;
@@ -32214,10 +33164,10 @@ var init_working_snapshots = __esm({
        * Get the timeline branch counter from branch_context.json.
        */
       getTimelineBranch() {
-        const contextPath = join66(this.unerrDir, "branch_context.json");
+        const contextPath = join68(this.unerrDir, "branch_context.json");
         if (!existsSync64(contextPath)) return 0;
         try {
-          const ctx = JSON.parse(readFileSync55(contextPath, "utf-8"));
+          const ctx = JSON.parse(readFileSync56(contextPath, "utf-8"));
           return ctx.timelineBranch ?? 0;
         } catch {
           return 0;
@@ -32227,11 +33177,11 @@ var init_working_snapshots = __esm({
        * Increment the timeline branch counter. Returns the new value.
        */
       incrementTimelineBranch() {
-        const contextPath = join66(this.unerrDir, "branch_context.json");
+        const contextPath = join68(this.unerrDir, "branch_context.json");
         let ctx = {};
         if (existsSync64(contextPath)) {
           try {
-            ctx = JSON.parse(readFileSync55(contextPath, "utf-8"));
+            ctx = JSON.parse(readFileSync56(contextPath, "utf-8"));
           } catch {
             ctx = {};
           }
@@ -32404,8 +33354,8 @@ var quality_signals_exports = {};
 __export(quality_signals_exports, {
   QualitySignalTracker: () => QualitySignalTracker
 });
-import { existsSync as existsSync65, readFileSync as readFileSync56, writeFileSync as writeFileSync31 } from "fs";
-import { join as join67 } from "path";
+import { existsSync as existsSync65, readFileSync as readFileSync57, writeFileSync as writeFileSync31 } from "fs";
+import { join as join69 } from "path";
 function computeDurabilityFromAge(survivalMs) {
   if (survivalMs < FRAGILE_THRESHOLD_MS) {
     return 0.1 + survivalMs / FRAGILE_THRESHOLD_MS * 0.2;
@@ -32432,7 +33382,7 @@ var init_quality_signals = __esm({
       /** Maximum corrections to retain in memory/disk. */
       static MAX_CORRECTIONS = 200;
       constructor(unerrDir2) {
-        this.signalsPath = join67(unerrDir2, "state", "quality_signals.json");
+        this.signalsPath = join69(unerrDir2, "state", "quality_signals.json");
         this.signals = this.load();
       }
       /**
@@ -32524,7 +33474,7 @@ var init_quality_signals = __esm({
        */
       save() {
         try {
-          const dir = join67(this.signalsPath, "..");
+          const dir = join69(this.signalsPath, "..");
           if (!existsSync65(dir)) {
             const { mkdirSync: mkdirSync48 } = __require("fs");
             mkdirSync48(dir, { recursive: true });
@@ -32580,7 +33530,7 @@ var init_quality_signals = __esm({
         }
         try {
           return JSON.parse(
-            readFileSync56(this.signalsPath, "utf-8")
+            readFileSync57(this.signalsPath, "utf-8")
           );
         } catch {
           return {
@@ -33599,8 +34549,8 @@ var incomplete_work_exports = {};
 __export(incomplete_work_exports, {
   IncompleteWorkDetector: () => IncompleteWorkDetector
 });
-import { existsSync as existsSync66, mkdirSync as mkdirSync37, readFileSync as readFileSync57, writeFileSync as writeFileSync32 } from "fs";
-import { join as join68 } from "path";
+import { existsSync as existsSync66, mkdirSync as mkdirSync37, readFileSync as readFileSync58, writeFileSync as writeFileSync32 } from "fs";
+import { join as join70 } from "path";
 function severityRank(severity) {
   switch (severity) {
     case "high":
@@ -33793,9 +34743,9 @@ var init_incomplete_work = __esm({
       persistItems(items) {
         if (!this.unerrDir) return false;
         try {
-          const stateDir = join68(this.unerrDir, "state");
+          const stateDir = join70(this.unerrDir, "state");
           if (!existsSync66(stateDir)) mkdirSync37(stateDir, { recursive: true });
-          const filePath = join68(stateDir, PERSISTENCE_FILE);
+          const filePath = join70(stateDir, PERSISTENCE_FILE);
           writeFileSync32(
             filePath,
             JSON.stringify({
@@ -33815,9 +34765,9 @@ var init_incomplete_work = __esm({
        */
       static readPersistedItems(unerrDir2) {
         try {
-          const filePath = join68(unerrDir2, "state", PERSISTENCE_FILE);
+          const filePath = join70(unerrDir2, "state", PERSISTENCE_FILE);
           if (!existsSync66(filePath)) return [];
-          const data = JSON.parse(readFileSync57(filePath, "utf-8"));
+          const data = JSON.parse(readFileSync58(filePath, "utf-8"));
           return data.items ?? [];
         } catch {
           return [];
@@ -35597,8 +36547,8 @@ __export(git_trailers_exports, {
   parseTrailersFromMessage: () => parseTrailersFromMessage,
   uninstallPrepareCommitMsgHook: () => uninstallPrepareCommitMsgHook
 });
-import { existsSync as existsSync68, readFileSync as readFileSync58, writeFileSync as writeFileSync33 } from "fs";
-import { join as join69 } from "path";
+import { existsSync as existsSync68, readFileSync as readFileSync59, writeFileSync as writeFileSync33 } from "fs";
+import { join as join71 } from "path";
 function getCommitTrailers(ledger, timelineBranch, branch) {
   const recent = ledger.getRecentEntries(1);
   if (recent.length === 0) return null;
@@ -35618,15 +36568,15 @@ function formatTrailers(trailers) {
   ].join("\n");
 }
 function installPrepareCommitMsgHook(projectRoot) {
-  const hooksDir = join69(projectRoot, ".git", "hooks");
+  const hooksDir = join71(projectRoot, ".git", "hooks");
   if (!existsSync68(hooksDir)) {
     return false;
   }
-  const hookPath = join69(hooksDir, "prepare-commit-msg");
+  const hookPath = join71(hooksDir, "prepare-commit-msg");
   const marker = "# unerr-trailer-injection";
   if (existsSync68(hookPath)) {
     try {
-      const existing = readFileSync58(hookPath, "utf-8");
+      const existing = readFileSync59(hookPath, "utf-8");
       if (existing.includes(marker)) {
         return true;
       }
@@ -35655,10 +36605,10 @@ ${generateHookScript()}`;
   }
 }
 function uninstallPrepareCommitMsgHook(projectRoot) {
-  const hookPath = join69(projectRoot, ".git", "hooks", "prepare-commit-msg");
+  const hookPath = join71(projectRoot, ".git", "hooks", "prepare-commit-msg");
   if (!existsSync68(hookPath)) return true;
   try {
-    const content = readFileSync58(hookPath, "utf-8");
+    const content = readFileSync59(hookPath, "utf-8");
     const marker = "# unerr-trailer-injection";
     if (!content.includes(marker)) return true;
     const lines = content.split("\n");
@@ -35825,13 +36775,13 @@ var init_http_transport = __esm({
 import {
   existsSync as existsSync69,
   mkdirSync as mkdirSync39,
-  readFileSync as readFileSync59,
-  readdirSync as readdirSync15,
+  readFileSync as readFileSync60,
+  readdirSync as readdirSync16,
   rmSync as rmSync3,
   statSync as statSync11,
   writeFileSync as writeFileSync34
 } from "fs";
-import { join as join70 } from "path";
+import { join as join72 } from "path";
 function sanitizeBranchName(branch) {
   return branch.replace(/\//g, "__").replace(/[^a-zA-Z0-9_.\-]/g, "_");
 }
@@ -35849,7 +36799,7 @@ var init_branch_snapshot = __esm({
       branchDir;
       projectRoot;
       constructor(unerrDir2, projectRoot) {
-        this.branchDir = join70(unerrDir2, "drift", "branches");
+        this.branchDir = join72(unerrDir2, "drift", "branches");
         this.projectRoot = projectRoot;
       }
       /**
@@ -35863,7 +36813,7 @@ var init_branch_snapshot = __esm({
           log17.info(`No drift entities/edges to snapshot for branch ${branch}`);
         }
         const dirName = sanitizeBranchName(branch);
-        const snapshotDir = join70(this.branchDir, dirName);
+        const snapshotDir = join72(this.branchDir, dirName);
         if (!existsSync69(snapshotDir)) {
           mkdirSync39(snapshotDir, { recursive: true });
         }
@@ -35875,12 +36825,12 @@ var init_branch_snapshot = __esm({
           savedAt: (/* @__PURE__ */ new Date()).toISOString()
         };
         writeFileSync34(
-          join70(snapshotDir, OVERLAY_FILE),
+          join72(snapshotDir, OVERLAY_FILE),
           JSON.stringify(snapshot, null, 2),
           "utf-8"
         );
         writeFileSync34(
-          join70(snapshotDir, HASHES_FILE),
+          join72(snapshotDir, HASHES_FILE),
           JSON.stringify(fileHashState, null, 2),
           "utf-8"
         );
@@ -35896,14 +36846,14 @@ var init_branch_snapshot = __esm({
        */
       async restoreSnapshot(branch, localGraph) {
         const dirName = sanitizeBranchName(branch);
-        const snapshotDir = join70(this.branchDir, dirName);
-        const overlayPath = join70(snapshotDir, OVERLAY_FILE);
+        const snapshotDir = join72(this.branchDir, dirName);
+        const overlayPath = join72(snapshotDir, OVERLAY_FILE);
         if (!existsSync69(overlayPath)) {
           log17.info(`No snapshot for branch ${branch} \u2014 first visit`);
           return null;
         }
         try {
-          const raw = readFileSync59(overlayPath, "utf-8");
+          const raw = readFileSync60(overlayPath, "utf-8");
           const snapshot = JSON.parse(raw);
           for (const entity of snapshot.entities) {
             await localGraph.upsertDriftEntity(entity);
@@ -35915,7 +36865,7 @@ var init_branch_snapshot = __esm({
           }
           const now = /* @__PURE__ */ new Date();
           writeFileSync34(
-            join70(snapshotDir, ".last_access"),
+            join72(snapshotDir, ".last_access"),
             now.toISOString(),
             "utf-8"
           );
@@ -35935,17 +36885,17 @@ var init_branch_snapshot = __esm({
        */
       hasSnapshot(branch) {
         const dirName = sanitizeBranchName(branch);
-        return existsSync69(join70(this.branchDir, dirName, OVERLAY_FILE));
+        return existsSync69(join72(this.branchDir, dirName, OVERLAY_FILE));
       }
       /**
        * Get the file hash state from a branch snapshot.
        */
       getSnapshotFileHashes(branch) {
         const dirName = sanitizeBranchName(branch);
-        const hashesPath = join70(this.branchDir, dirName, HASHES_FILE);
+        const hashesPath = join72(this.branchDir, dirName, HASHES_FILE);
         if (!existsSync69(hashesPath)) return null;
         try {
-          const raw = readFileSync59(hashesPath, "utf-8");
+          const raw = readFileSync60(hashesPath, "utf-8");
           return JSON.parse(raw);
         } catch {
           return null;
@@ -35956,7 +36906,7 @@ var init_branch_snapshot = __esm({
        */
       deleteSnapshot(branch) {
         const dirName = sanitizeBranchName(branch);
-        const snapshotDir = join70(this.branchDir, dirName);
+        const snapshotDir = join72(this.branchDir, dirName);
         if (!existsSync69(snapshotDir)) return false;
         rmSync3(snapshotDir, { recursive: true, force: true });
         log17.info(`Deleted branch snapshot: ${branch}`);
@@ -35973,7 +36923,7 @@ var init_branch_snapshot = __esm({
         let removed = 0;
         for (const snapshot of snapshots) {
           if (!gitBranches.has(snapshot.branch)) {
-            const snapshotDir = join70(this.branchDir, snapshot.id);
+            const snapshotDir = join72(this.branchDir, snapshot.id);
             rmSync3(snapshotDir, { recursive: true, force: true });
             log17.info(`GC removed snapshot for deleted branch: ${snapshot.branch}`);
             removed++;
@@ -35987,16 +36937,16 @@ var init_branch_snapshot = __esm({
       listSnapshots() {
         if (!existsSync69(this.branchDir)) return [];
         try {
-          const entries = readdirSync15(this.branchDir, { withFileTypes: true });
+          const entries = readdirSync16(this.branchDir, { withFileTypes: true });
           const snapshots = [];
           for (const entry of entries) {
             if (!entry.isDirectory()) continue;
-            const overlayPath = join70(this.branchDir, entry.name, OVERLAY_FILE);
+            const overlayPath = join72(this.branchDir, entry.name, OVERLAY_FILE);
             if (!existsSync69(overlayPath)) continue;
             try {
-              const raw = readFileSync59(overlayPath, "utf-8");
+              const raw = readFileSync60(overlayPath, "utf-8");
               const snapshot = JSON.parse(raw);
-              const accessPath = join70(this.branchDir, entry.name, ".last_access");
+              const accessPath = join72(this.branchDir, entry.name, ".last_access");
               let accessedAt;
               if (existsSync69(accessPath)) {
                 accessedAt = statSync11(accessPath).mtime;
@@ -36025,7 +36975,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 = join70(this.branchDir, snapshot.id);
+          const dir = join72(this.branchDir, snapshot.id);
           rmSync3(dir, { recursive: true, force: true });
           log17.info(`LRU evicted branch snapshot: ${snapshot.branch}`);
         }
@@ -36040,17 +36990,17 @@ __export(file_hash_state_exports, {
   FileHashManager: () => FileHashManager,
   contentSha256: () => contentSha256
 });
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import {
   existsSync as existsSync70,
   mkdirSync as mkdirSync40,
-  readFileSync as readFileSync60,
+  readFileSync as readFileSync61,
   renameSync as renameSync4,
   writeFileSync as writeFileSync35
 } from "fs";
-import { join as join71 } from "path";
+import { join as join73 } from "path";
 function contentSha256(content) {
-  return createHash3("sha256").update(content).digest("hex");
+  return createHash4("sha256").update(content).digest("hex");
 }
 var STATE_FILE2, FileHashManager;
 var init_file_hash_state = __esm({
@@ -36062,8 +37012,8 @@ var init_file_hash_state = __esm({
       statePath;
       state;
       constructor(unerrDir2) {
-        this.stateDir = join71(unerrDir2, "state");
-        this.statePath = join71(this.stateDir, STATE_FILE2);
+        this.stateDir = join73(unerrDir2, "state");
+        this.statePath = join73(this.stateDir, STATE_FILE2);
         this.state = this.load();
       }
       /**
@@ -36139,7 +37089,7 @@ var init_file_hash_state = __esm({
           return { files: {} };
         }
         try {
-          const raw = readFileSync60(this.statePath, "utf-8");
+          const raw = readFileSync61(this.statePath, "utf-8");
           return JSON.parse(raw);
         } catch {
           return { files: {} };
@@ -36153,13 +37103,13 @@ var init_file_hash_state = __esm({
 import {
   existsSync as existsSync71,
   mkdirSync as mkdirSync41,
-  readFileSync as readFileSync61,
-  readdirSync as readdirSync16,
+  readFileSync as readFileSync62,
+  readdirSync as readdirSync17,
   rmSync as rmSync4,
   statSync as statSync12,
   writeFileSync as writeFileSync36
 } from "fs";
-import { join as join72 } from "path";
+import { join as join74 } from "path";
 var MAX_STASH_SNAPSHOTS, OVERLAY_FILE2, HASHES_FILE2, _log6, StashManager;
 var init_stash_manager = __esm({
   "src/tracking/stash-manager.ts"() {
@@ -36177,8 +37127,8 @@ var init_stash_manager = __esm({
       constructor(unerrDir2, projectRoot) {
         this.unerrDir = unerrDir2;
         this.projectRoot = projectRoot;
-        this.stashDir = join72(unerrDir2, "drift", "stash");
-        this.gitDir = join72(projectRoot, ".git");
+        this.stashDir = join74(unerrDir2, "drift", "stash");
+        this.gitDir = join74(projectRoot, ".git");
         this.previousStashRef = this.readStashRef();
         this.previousStashCount = this.getStashCount();
       }
@@ -36223,7 +37173,7 @@ var init_stash_manager = __esm({
           return null;
         }
         const snapshotId = stashRef.slice(0, 12);
-        const snapshotDir = join72(this.stashDir, snapshotId);
+        const snapshotDir = join74(this.stashDir, snapshotId);
         if (!existsSync71(snapshotDir)) {
           mkdirSync41(snapshotDir, { recursive: true });
         }
@@ -36235,12 +37185,12 @@ var init_stash_manager = __esm({
           savedAt: (/* @__PURE__ */ new Date()).toISOString()
         };
         writeFileSync36(
-          join72(snapshotDir, OVERLAY_FILE2),
+          join74(snapshotDir, OVERLAY_FILE2),
           JSON.stringify(snapshot, null, 2),
           "utf-8"
         );
         writeFileSync36(
-          join72(snapshotDir, HASHES_FILE2),
+          join74(snapshotDir, HASHES_FILE2),
           JSON.stringify(fileHashState, null, 2),
           "utf-8"
         );
@@ -36261,14 +37211,14 @@ var init_stash_manager = __esm({
           return 0;
         }
         const latest = snapshots[0];
-        const snapshotDir = join72(this.stashDir, latest.id);
-        const overlayPath = join72(snapshotDir, OVERLAY_FILE2);
+        const snapshotDir = join74(this.stashDir, latest.id);
+        const overlayPath = join74(snapshotDir, OVERLAY_FILE2);
         if (!existsSync71(overlayPath)) {
           _log6.warn(`Snapshot ${latest.id} missing overlay file`);
           return 0;
         }
         try {
-          const raw = readFileSync61(overlayPath, "utf-8");
+          const raw = readFileSync62(overlayPath, "utf-8");
           const snapshot = JSON.parse(raw);
           for (const entity of snapshot.entities) {
             await localGraph.upsertDriftEntity(entity);
@@ -36298,10 +37248,10 @@ var init_stash_manager = __esm({
         const snapshots = this.listSnapshots();
         if (snapshots.length === 0) return null;
         const latest = snapshots[0];
-        const hashesPath = join72(this.stashDir, latest.id, HASHES_FILE2);
+        const hashesPath = join74(this.stashDir, latest.id, HASHES_FILE2);
         if (!existsSync71(hashesPath)) return null;
         try {
-          const raw = readFileSync61(hashesPath, "utf-8");
+          const raw = readFileSync62(hashesPath, "utf-8");
           return JSON.parse(raw);
         } catch {
           return null;
@@ -36312,7 +37262,7 @@ var init_stash_manager = __esm({
        */
       dropSnapshot(stashRef) {
         const snapshotId = stashRef.slice(0, 12);
-        const snapshotDir = join72(this.stashDir, snapshotId);
+        const snapshotDir = join74(this.stashDir, snapshotId);
         if (!existsSync71(snapshotDir)) return false;
         rmSync4(snapshotDir, { recursive: true, force: true });
         _log6.info(`Dropped stash snapshot: ${snapshotId}`);
@@ -36324,11 +37274,11 @@ var init_stash_manager = __esm({
       listSnapshots() {
         if (!existsSync71(this.stashDir)) return [];
         try {
-          const entries = readdirSync16(this.stashDir, { withFileTypes: true });
+          const entries = readdirSync17(this.stashDir, { withFileTypes: true });
           const snapshots = [];
           for (const entry of entries) {
             if (!entry.isDirectory()) continue;
-            const overlayPath = join72(this.stashDir, entry.name, OVERLAY_FILE2);
+            const overlayPath = join74(this.stashDir, entry.name, OVERLAY_FILE2);
             if (!existsSync71(overlayPath)) continue;
             try {
               const stat2 = statSync12(overlayPath);
@@ -36346,10 +37296,10 @@ var init_stash_manager = __esm({
        * Read the current stash ref SHA from `.git/refs/stash`.
        */
       readStashRef() {
-        const stashPath = join72(this.gitDir, "refs", "stash");
+        const stashPath = join74(this.gitDir, "refs", "stash");
         if (!existsSync71(stashPath)) return null;
         try {
-          return readFileSync61(stashPath, "utf-8").trim() || null;
+          return readFileSync62(stashPath, "utf-8").trim() || null;
         } catch {
           return null;
         }
@@ -36358,10 +37308,10 @@ var init_stash_manager = __esm({
        * Count current stash entries via `.git/logs/refs/stash`.
        */
       getStashCount() {
-        const logPath = join72(this.gitDir, "logs", "refs", "stash");
+        const logPath = join74(this.gitDir, "logs", "refs", "stash");
         if (!existsSync71(logPath)) return 0;
         try {
-          const content = readFileSync61(logPath, "utf-8");
+          const content = readFileSync62(logPath, "utf-8");
           return content.split("\n").filter((line) => line.trim().length > 0).length;
         } catch {
           return 0;
@@ -36375,7 +37325,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 = join72(this.stashDir, snapshot.id);
+          const dir = join74(this.stashDir, snapshot.id);
           rmSync4(dir, { recursive: true, force: true });
           _log6.info(`LRU evicted stash snapshot: ${snapshot.id}`);
         }
@@ -36395,11 +37345,11 @@ __export(drift_tracker_exports, {
 import {
   existsSync as existsSync72,
   mkdirSync as mkdirSync42,
-  readFileSync as readFileSync62,
+  readFileSync as readFileSync63,
   statSync as statSync13,
   writeFileSync as writeFileSync37
 } from "fs";
-import { join as join73 } from "path";
+import { join as join75 } from "path";
 function determineOrigin(lastSyncTimestamp) {
   if (lastSyncTimestamp === 0) return "human";
   const elapsed = Date.now() - lastSyncTimestamp;
@@ -36610,7 +37560,7 @@ var init_drift_tracker = __esm({
           crossFileInvalidated: 0,
           edgesExtracted: 0
         };
-        const absPath = filePath.startsWith("/") ? filePath : join73(this.config.projectRoot, filePath);
+        const absPath = filePath.startsWith("/") ? filePath : join75(this.config.projectRoot, filePath);
         const relPath = filePath.startsWith("/") ? filePath.slice(this.config.projectRoot.length + 1) : filePath;
         const language = detectLanguage2(relPath);
         if (!language) return result;
@@ -36656,7 +37606,7 @@ var init_drift_tracker = __esm({
           this.maybeEmitDrift(relPath, result);
           return result;
         }
-        const content = readFileSync62(absPath, "utf-8");
+        const content = readFileSync63(absPath, "utf-8");
         const sha = contentSha256(content);
         const decision = this.fileHashManager.shouldProcess(relPath, sha, headSha);
         if (decision === "skip") {
@@ -36890,7 +37840,7 @@ var init_drift_tracker = __esm({
         return await this.stashManager.restoreSnapshot(this.localGraph);
       }
       async markFileDeleted(filePath, intentId) {
-        const absPath = filePath.startsWith("/") ? filePath : join73(this.config.projectRoot, filePath);
+        const absPath = filePath.startsWith("/") ? filePath : join75(this.config.projectRoot, filePath);
         this.mtimeCache.evict(absPath);
         const baseEntities = await this.localGraph.getEntitiesByFile(filePath);
         const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -36975,13 +37925,13 @@ var init_drift_tracker = __esm({
         return invalidated;
       }
       async saveDriftSummary() {
-        const driftDir = join73(this.config.unerrDir, "drift");
+        const driftDir = join75(this.config.unerrDir, "drift");
         if (!existsSync72(driftDir)) {
           mkdirSync42(driftDir, { recursive: true });
         }
         const summary = await this.getDriftSummary();
         writeFileSync37(
-          join73(driftDir, "drift_summary.json"),
+          join75(driftDir, "drift_summary.json"),
           JSON.stringify(summary, null, 2),
           "utf-8"
         );
@@ -37392,8 +38342,8 @@ var incremental_indexer_exports = {};
 __export(incremental_indexer_exports, {
   indexFilesIncremental: () => indexFilesIncremental
 });
-import { existsSync as existsSync73, readFileSync as readFileSync63 } from "fs";
-import { join as join74, relative as relative5 } from "path";
+import { existsSync as existsSync73, readFileSync as readFileSync64 } from "fs";
+import { join as join76, relative as relative5 } from "path";
 async function indexFilesIncremental(projectRoot, changedFiles, graphStore, repoId) {
   const startMs = Date.now();
   const db = {
@@ -37411,7 +38361,7 @@ 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 : join74(projectRoot, filePath);
+    const absPath = filePath.startsWith("/") ? filePath : join76(projectRoot, filePath);
     const relPath = filePath.startsWith("/") ? relative5(projectRoot, filePath) : filePath;
     if (!existsSync73(absPath)) {
       const deleted2 = await deleteFileFromGraph(db, relPath);
@@ -37426,7 +38376,7 @@ async function indexFilesIncremental(projectRoot, changedFiles, graphStore, repo
     }
     let content;
     try {
-      content = readFileSync63(absPath, "utf-8");
+      content = readFileSync64(absPath, "utf-8");
     } catch {
       continue;
     }
@@ -38604,8 +39554,8 @@ var workspace_manifest_exports = {};
 __export(workspace_manifest_exports, {
   WorkspaceManifest: () => WorkspaceManifest
 });
-import { existsSync as existsSync74, mkdirSync as mkdirSync43, readFileSync as readFileSync64, writeFileSync as writeFileSync38 } from "fs";
-import { join as join75 } from "path";
+import { existsSync as existsSync74, mkdirSync as mkdirSync43, readFileSync as readFileSync65, writeFileSync as writeFileSync38 } from "fs";
+import { join as join77 } from "path";
 var WorkspaceManifest;
 var init_workspace_manifest = __esm({
   "src/tracking/workspace-manifest.ts"() {
@@ -38615,7 +39565,7 @@ var init_workspace_manifest = __esm({
         this.unerrDir = unerrDir2;
         this.repoId = repoId;
         this.sessionId = sessionId;
-        this.manifestPath = join75(unerrDir2, "manifest.json");
+        this.manifestPath = join77(unerrDir2, "manifest.json");
         this.data = this.load();
       }
       unerrDir;
@@ -38720,7 +39670,7 @@ var init_workspace_manifest = __esm({
           };
         }
         try {
-          const raw = readFileSync64(this.manifestPath, "utf-8");
+          const raw = readFileSync65(this.manifestPath, "utf-8");
           const parsed = JSON.parse(raw);
           if (parsed.repoId !== this.repoId) {
             return {
@@ -38945,7 +39895,7 @@ import {
   statSync as statSync14,
   watch
 } from "fs";
-import { join as join76 } from "path";
+import { join as join78 } from "path";
 function formatSize(bytes) {
   if (bytes >= 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
   if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)}KB`;
@@ -39092,9 +40042,9 @@ function tokenFlowRowToEntry(r) {
   };
 }
 function startLogTailer(cwd, options) {
-  const unerrDir2 = join76(cwd, ".unerr");
-  const logsDir = join76(unerrDir2, "logs");
-  const generalPath = join76(logsDir, "events.jsonl");
+  const unerrDir2 = join78(cwd, ".unerr");
+  const logsDir = join78(unerrDir2, "logs");
+  const generalPath = join78(logsDir, "events.jsonl");
   const pollIntervalMs = options?.pollIntervalMs ?? 500;
   const generalState = {
     path: generalPath,
@@ -39240,13 +40190,13 @@ var init_middleware = __esm({
 });
 
 // src/server/routes/drift.ts
-import { existsSync as existsSync76, readFileSync as readFileSync65, readdirSync as readdirSync17 } from "fs";
-import { join as join77 } from "path";
+import { existsSync as existsSync76, readFileSync as readFileSync66, readdirSync as readdirSync18 } from "fs";
+import { join as join79 } from "path";
 import { Hono as Hono2 } from "hono";
 function readFlags(path7) {
   try {
     if (!existsSync76(path7)) return null;
-    return JSON.parse(readFileSync65(path7, "utf8"));
+    return JSON.parse(readFileSync66(path7, "utf8"));
   } catch {
     return null;
   }
@@ -39254,7 +40204,7 @@ function readFlags(path7) {
 function listSessionFiles(stateDir) {
   try {
     if (!existsSync76(stateDir)) return [];
-    return readdirSync17(stateDir).filter((f) => f.startsWith("nudge-") && f.endsWith(".flags")).map((f) => join77(stateDir, f));
+    return readdirSync18(stateDir).filter((f) => f.startsWith("nudge-") && f.endsWith(".flags")).map((f) => join79(stateDir, f));
   } catch {
     return [];
   }
@@ -39274,7 +40224,7 @@ function rowFor(file) {
 }
 function createDriftRoutes(deps) {
   const app = new Hono2();
-  const stateDir = join77(deps.cwd, ".unerr", "state");
+  const stateDir = join79(deps.cwd, ".unerr", "state");
   app.get("/sessions", (c) => {
     const rows = [];
     for (const file of listSessionFiles(stateDir)) {
@@ -39295,7 +40245,7 @@ function createDriftRoutes(deps) {
   });
   app.get("/current", (c) => {
     const id = process.env.UNERR_SESSION_ID ?? `pid-${process.pid}`;
-    const file = join77(stateDir, `nudge-${id}.flags`);
+    const file = join79(stateDir, `nudge-${id}.flags`);
     const row = rowFor(file);
     return c.json({
       data: row ?? {
@@ -41458,13 +42408,13 @@ function createSystemRoutes(deps) {
   });
   app.get("/config", async (c) => {
     const start = performance.now();
-    const { existsSync: existsSync82, readFileSync: readFileSync70 } = await import("fs");
-    const { join: join83 } = await import("path");
+    const { existsSync: existsSync82, readFileSync: readFileSync71 } = await import("fs");
+    const { join: join85 } = await import("path");
     let config = {};
-    const configPath2 = join83(deps.cwd, ".unerr", "config.json");
+    const configPath2 = join85(deps.cwd, ".unerr", "config.json");
     if (existsSync82(configPath2)) {
       try {
-        config = JSON.parse(readFileSync70(configPath2, "utf-8"));
+        config = JSON.parse(readFileSync71(configPath2, "utf-8"));
       } catch {
         config = { error: "unreadable" };
       }
@@ -42757,10 +43707,10 @@ var http_exports = {};
 __export(http_exports, {
   startDashboardServer: () => startDashboardServer
 });
-import { existsSync as existsSync77, readFileSync as readFileSync66, unlinkSync as unlinkSync14, writeFileSync as writeFileSync39 } from "fs";
+import { existsSync as existsSync77, readFileSync as readFileSync67, unlinkSync as unlinkSync14, writeFileSync as writeFileSync39 } from "fs";
 import { createServer as createServer5 } from "net";
-import { dirname as dirname17, join as join78 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname17, join as join80 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 import { serve as serve2 } from "@hono/node-server";
 import { serveStatic as serveStatic2 } from "@hono/node-server/serve-static";
 import { Hono as Hono13 } from "hono";
@@ -42819,10 +43769,10 @@ async function startDashboardServer(opts) {
     app.route("/api/router", createRouterApiV2(opts.routerV2));
   }
   if (!opts.apiOnly) {
-    const distDir = join78(dirname17(fileURLToPath3(import.meta.url)), "ui");
-    const spaIndex = join78(distDir, "index.html");
+    const distDir = join80(dirname17(fileURLToPath4(import.meta.url)), "ui");
+    const spaIndex = join80(distDir, "index.html");
     if (existsSync77(spaIndex)) {
-      const spaHtml = readFileSync66(spaIndex, "utf-8");
+      const spaHtml = readFileSync67(spaIndex, "utf-8");
       app.use("*", serveStatic2({ root: distDir }));
       app.get("*", (c) => {
         const path7 = c.req.path;
@@ -42854,7 +43804,7 @@ async function startDashboardServer(opts) {
     port,
     hostname: "127.0.0.1"
   });
-  const serverJsonPath = join78(opts.stateDir, "server.json");
+  const serverJsonPath = join80(opts.stateDir, "server.json");
   const serverInfo = {
     port,
     pid: process.pid,
@@ -43284,15 +44234,15 @@ import {
   existsSync as existsSync78,
   writeFileSync as fsWriteFileSync,
   mkdirSync as mkdirSync44,
-  readFileSync as readFileSync67,
-  readdirSync as readdirSync18
+  readFileSync as readFileSync68,
+  readdirSync as readdirSync19
 } from "fs";
-import { join as join79 } from "path";
+import { join as join81 } from "path";
 async function getProxyFactStore(unerrDir2) {
   if (proxyFactStore !== void 0) return proxyFactStore;
   try {
     const { TemporalFactStore: TemporalFactStore2 } = await Promise.resolve().then(() => (init_temporal_facts(), temporal_facts_exports));
-    const cwd = join79(unerrDir2, "..");
+    const cwd = join81(unerrDir2, "..");
     proxyFactStore = await TemporalFactStore2.create(cwd);
     return proxyFactStore;
   } catch {
@@ -43436,9 +44386,9 @@ async function handleRecallFactsProxy(args, unerrDir2, effectiveness) {
 }
 function migrateAgentPermissions(cwd) {
   try {
-    const settingsPath = join79(cwd, ".claude", "settings.json");
+    const settingsPath = join81(cwd, ".claude", "settings.json");
     if (!existsSync78(settingsPath)) return;
-    const raw = readFileSync67(settingsPath, "utf-8");
+    const raw = readFileSync68(settingsPath, "utf-8");
     const settings = JSON.parse(raw);
     const deny = settings?.permissions?.deny;
     if (!Array.isArray(deny)) return;
@@ -43455,7 +44405,7 @@ function migrateAgentPermissions(cwd) {
 }
 async function startProxy(opts = {}) {
   installFileLogger({
-    filePath: join79(process.cwd(), ".unerr", "logs", "unerr.log"),
+    filePath: join81(process.cwd(), ".unerr", "logs", "unerr.log"),
     maxBytes: 5e6,
     keep: 5
   });
@@ -43468,7 +44418,7 @@ async function startProxy(opts = {}) {
   const lifecycle = createLifecycleActor(process.cwd());
   lifecycle.send({ type: "START_DETECT" });
   startup.setLocalMode(true);
-  const stateDir = join79(process.cwd(), ".unerr", "state");
+  const stateDir = join81(process.cwd(), ".unerr", "state");
   if (!existsSync78(stateDir)) {
     mkdirSync44(stateDir, { recursive: true });
   }
@@ -43487,7 +44437,7 @@ async function startProxy(opts = {}) {
   startupLog.step(
     `PID ${process.pid} ${startupLog.fmt.muted(`\xB7 health localhost:${lockResult.healthPort}`)}`
   );
-  const ledgerDir = join79(process.cwd(), ".unerr", "ledger");
+  const ledgerDir = join81(process.cwd(), ".unerr", "ledger");
   const previousSession = detectSessionResume(stateDir, ledgerDir);
   if (previousSession) {
     stats.isResumedSession = true;
@@ -43502,21 +44452,21 @@ async function startProxy(opts = {}) {
   if (opts.repoId) {
     repoIds = [opts.repoId];
   } else {
-    const configPath2 = join79(process.cwd(), ".unerr", "config.json");
+    const configPath2 = join81(process.cwd(), ".unerr", "config.json");
     if (existsSync78(configPath2)) {
       try {
-        const config = JSON.parse(readFileSync67(configPath2, "utf-8"));
+        const config = JSON.parse(readFileSync68(configPath2, "utf-8"));
         if (config.repoId) repoIds = [config.repoId];
       } catch {
       }
     }
-    const manifestsDir = join79(process.cwd(), ".unerr", "manifests");
+    const manifestsDir = join81(process.cwd(), ".unerr", "manifests");
     if (repoIds.length === 0 && existsSync78(manifestsDir)) {
-      repoIds = readdirSync18(manifestsDir).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
+      repoIds = readdirSync19(manifestsDir).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
     }
   }
   if (repoIds.length === 0) {
-    const { createHash: createHash5 } = await import("crypto");
+    const { createHash: createHash6 } = await import("crypto");
     let repoIdentifier = process.cwd();
     try {
       const { getRemoteUrl: getRemoteUrl2 } = await Promise.resolve().then(() => (init_git(), git_exports));
@@ -43524,7 +44474,7 @@ async function startProxy(opts = {}) {
       if (remote) repoIdentifier = remote;
     } catch {
     }
-    const localRepoId = createHash5("sha256").update(repoIdentifier).digest("hex").slice(0, 12);
+    const localRepoId = createHash6("sha256").update(repoIdentifier).digest("hex").slice(0, 12);
     repoIds = [localRepoId];
     startupLog.done(
       `Repository ${startupLog.fmt.cyan(localRepoId)} ${startupLog.fmt.muted(`(from ${repoIdentifier === process.cwd() ? "directory" : "git remote"})`)}`
@@ -43636,7 +44586,7 @@ async function startProxy(opts = {}) {
             `Migrated snapshot to persistent graph ${startupLog.fmt.muted(`\u2192 ${dbPath}`)}`
           );
           try {
-            const migrationUnerrDir = join79(process.cwd(), ".unerr");
+            const migrationUnerrDir = join81(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));
@@ -43735,7 +44685,7 @@ async function startProxy(opts = {}) {
   let efficiencyTracker = createEfficiencyTracker2();
   router.setTokenCounter(tokenCounter);
   router.setEfficiencyTracker(efficiencyTracker);
-  const proxyFactStore2 = await getProxyFactStore(join79(process.cwd(), ".unerr"));
+  const proxyFactStore2 = await getProxyFactStore(join81(process.cwd(), ".unerr"));
   if (proxyFactStore2) {
     router.setFactStore(proxyFactStore2);
   }
@@ -43743,7 +44693,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(join79(process.cwd(), ".unerr"));
+      const resumeLedger = new ResumeLedger(join81(process.cwd(), ".unerr"));
       const ledgerEntries = resumeLedger.getRecentEntries(50);
       const resumeCtx = generateSessionResume2(ledgerEntries);
       if (resumeCtx) {
@@ -43764,7 +44714,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(join79(process.cwd(), ".unerr"));
+    const durLedger = new DurLedger(join81(process.cwd(), ".unerr"));
     const durEntries = durLedger.getRecentEntries(200);
     if (durEntries.length > 0) {
       durabilityScorer.computeScores(durEntries);
@@ -43784,7 +44734,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(join79(process.cwd(), ".unerr"));
+    const nkLedger = new NkLedger(join81(process.cwd(), ".unerr"));
     const nkEntries = nkLedger.getRecentEntries(200);
     if (nkEntries.length > 0) {
       const antiPatterns = detectInstableEntities2(nkEntries);
@@ -43806,7 +44756,7 @@ async function startProxy(opts = {}) {
   try {
     const { CausalBridge: CausalBridge2 } = await Promise.resolve().then(() => (init_causal_bridge(), causal_bridge_exports));
     const causalBridge = new CausalBridge2(
-      join79(process.cwd(), ".unerr"),
+      join81(process.cwd(), ".unerr"),
       process.cwd()
     );
     router.setCausalBridge(causalBridge);
@@ -43816,7 +44766,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(join79(process.cwd(), ".unerr"));
+    const convLedger = new ConvLedger(join81(process.cwd(), ".unerr"));
     const convEntries = convLedger.getRecentEntries(100);
     if (convEntries.length > 0) {
       const learned = learnConventions2(convEntries);
@@ -43839,7 +44789,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(join79(process.cwd(), ".unerr"));
+    const durProfLedger = new DurProfLedger(join81(process.cwd(), ".unerr"));
     const durProfEntries = durProfLedger.getRecentEntries(200);
     if (durProfEntries.length > 0) {
       const profiles = computePromptDurabilityProfiles2(durProfEntries);
@@ -43859,7 +44809,7 @@ async function startProxy(opts = {}) {
   }
   try {
     const { createContextLedger: createContextLedger2 } = await Promise.resolve().then(() => (init_context_ledger(), context_ledger_exports));
-    const contextLedger = createContextLedger2(join79(process.cwd(), ".unerr"));
+    const contextLedger = createContextLedger2(join81(process.cwd(), ".unerr"));
     contextLedger.load();
     contextLedger.prune();
     router.setContextLedger(contextLedger);
@@ -43984,7 +44934,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 = join79(process.cwd(), ".unerr");
+  const unerrDirForLedger = join81(process.cwd(), ".unerr");
   const shadowLedger = new ShadowLedger2(unerrDirForLedger);
   const intentCorrelator = new IntentCorrelator2(unerrDirForLedger);
   log22.info(
@@ -44094,7 +45044,7 @@ async function startProxy(opts = {}) {
   try {
     const { writeFileSync: writeFileSync42 } = await import("fs");
     writeFileSync42(
-      join79(unerrDirForLedger, "state", "session.id"),
+      join81(unerrDirForLedger, "state", "session.id"),
       shadowLedger.getSessionId(),
       "utf-8"
     );
@@ -44522,7 +45472,7 @@ ${signalFooter.trimEnd()}` : "";
   lifecycle.send({ type: "INDEX_COMPLETE" });
   lifecycle.send({ type: "MCP_READY" });
   const { TransportMux: TransportMux2 } = await Promise.resolve().then(() => (init_transport_mux(), transport_mux_exports));
-  const sockPath2 = join79(stateDir, "proxy.sock");
+  const sockPath2 = join81(stateDir, "proxy.sock");
   const transportMux = new TransportMux2(sockPath2);
   const agentNameByClient = /* @__PURE__ */ new Map();
   transportMux.setCustomHttpHandler("/commit-context", (_url) => {
@@ -44807,7 +45757,7 @@ ${signalFooter2.trimEnd()}` : "";
     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 unerrDir2 = join79(process.cwd(), ".unerr");
+      const unerrDir2 = join81(process.cwd(), ".unerr");
       const fileHashManager = new FileHashManager2(unerrDir2);
       _driftTracker = new DriftTracker2(
         { projectRoot: process.cwd(), repoId: repoIds[0], unerrDir: unerrDir2 },
@@ -45031,7 +45981,7 @@ ${signalFooter2.trimEnd()}` : "";
   }
   const { WorkspaceManifest: WorkspaceManifest2 } = await Promise.resolve().then(() => (init_workspace_manifest(), workspace_manifest_exports));
   const workspaceManifest = repoIds[0] ? new WorkspaceManifest2(
-    join79(process.cwd(), ".unerr"),
+    join81(process.cwd(), ".unerr"),
     repoIds[0],
     shadowLedger.getSessionId()
   ) : null;
@@ -45116,7 +46066,7 @@ ${signalFooter2.trimEnd()}` : "";
   if (proxyMode === "parse" && parseIndex) {
     try {
       const { extractEntitiesFromSource: extractEntitiesFromSource2 } = await Promise.resolve().then(() => (init_auto_bootstrap(), auto_bootstrap_exports));
-      const allFiles = readdirSync18(process.cwd(), {
+      const allFiles = readdirSync19(process.cwd(), {
         recursive: true,
         encoding: "utf-8"
       });
@@ -45130,7 +46080,7 @@ ${signalFooter2.trimEnd()}` : "";
       });
       for (const file of sourceFiles.slice(0, 500)) {
         try {
-          const content = readFileSync67(join79(process.cwd(), file), "utf-8");
+          const content = readFileSync68(join81(process.cwd(), file), "utf-8");
           const entities = extractEntitiesFromSource2(file, content);
           parseIndex.addEntities(entities);
         } catch {
@@ -45194,7 +46144,7 @@ ${signalFooter2.trimEnd()}` : "";
   }
   const { writeFileSync: writeStatsFile } = await import("fs");
   const { computePercentiles: computePercentiles2 } = await Promise.resolve().then(() => (init_session_stats(), session_stats_exports));
-  const statsSnapshotPath = join79(stateDir, "session_stats.json");
+  const statsSnapshotPath = join81(stateDir, "session_stats.json");
   const statsSnapshotInterval = setInterval(() => {
     try {
       const total = stats.toolCallsLocal;
@@ -45232,7 +46182,7 @@ ${signalFooter2.trimEnd()}` : "";
     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 = join79(process.cwd(), ".unerr");
+    const unerrDirForApi = join81(process.cwd(), ".unerr");
     dashboardHandle = await startDashboardServer2({
       system: {
         stats,
@@ -45300,16 +46250,16 @@ ${signalFooter2.trimEnd()}` : "";
       temporal: await (async () => {
         try {
           const { TemporalFactStore: TemporalFactStore2 } = await Promise.resolve().then(() => (init_temporal_facts(), temporal_facts_exports));
-          const { readdirSync: readdirSync19, readFileSync: readFileSync70 } = await import("fs");
+          const { readdirSync: readdirSync20, readFileSync: readFileSync71 } = await import("fs");
           const factStore = await TemporalFactStore2.create(process.cwd());
           return {
             factStore,
             loadRecentSessions: (limit) => {
               try {
-                const sessDir = join79(unerrDirForApi, "sessions");
-                const files = readdirSync19(sessDir).filter((f) => f.endsWith(".jsonl")).sort().slice(-limit);
+                const sessDir = join81(unerrDirForApi, "sessions");
+                const files = readdirSync20(sessDir).filter((f) => f.endsWith(".jsonl")).sort().slice(-limit);
                 return files.map((f) => {
-                  const content = readFileSync70(join79(sessDir, f), "utf-8").trim().split("\n").pop();
+                  const content = readFileSync71(join81(sessDir, f), "utf-8").trim().split("\n").pop();
                   return JSON.parse(content);
                 });
               } catch {
@@ -45396,7 +46346,7 @@ ${signalFooter2.trimEnd()}` : "";
             const topMech = Object.entries(tokenFlowSummary.by_mechanism).sort(
               ([, a], [, b]) => b.tokens_saved - a.tokens_saved
             )[0];
-            appendSessionHistory2(join79(process.cwd(), ".unerr"), {
+            appendSessionHistory2(join81(process.cwd(), ".unerr"), {
               sessionId: shadowLedger.getSessionId(),
               startedAt: new Date(stats.sessionStartedAt).toISOString(),
               endedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -45556,7 +46506,7 @@ ${signalFooter2.trimEnd()}` : "";
         try {
           const correctionModule = (init_correction_detector(), __toCommonJS(correction_detector_exports));
           const detectCorrections2 = correctionModule.detectCorrections;
-          const ledgerPath = join79(
+          const ledgerPath = join81(
             process.cwd(),
             ".unerr",
             "ledger",
@@ -45920,19 +46870,19 @@ __export(setup_wizard_exports, {
   promptLocalOrExit: () => promptLocalOrExit,
   runSetup: () => runSetup
 });
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { existsSync as existsSync80, mkdirSync as mkdirSync46, writeFileSync as writeFileSync40 } from "fs";
-import { join as join80 } from "path";
+import { join as join82 } 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 = join80(projectDir, ".unerr");
+  const configDir = join82(projectDir, ".unerr");
   mkdirSync46(configDir, { recursive: true });
-  const configPath2 = join80(configDir, "config.json");
-  const settingsPath = join80(configDir, "settings.json");
+  const configPath2 = join82(configDir, "config.json");
+  const settingsPath = join82(configDir, "settings.json");
   writeFileSync40(configPath2, `${JSON.stringify({ repoId }, null, 2)}
 `);
   let existingSettings = {};
@@ -46003,7 +46953,7 @@ async function generateRepoId(cwd) {
   let repoIdentifier = cwd;
   const remote = await getRemoteUrl(cwd);
   if (remote) repoIdentifier = remote;
-  return createHash4("sha256").update(repoIdentifier).digest("hex").slice(0, 12);
+  return createHash5("sha256").update(repoIdentifier).digest("hex").slice(0, 12);
 }
 function formatSize2(bytes) {
   if (bytes >= 1e9) return `${(bytes / 1e9).toFixed(1)}GB`;
@@ -46316,6 +47266,112 @@ var init_setup_wizard = __esm({
   }
 });
 
+// src/proxy/bridge-catalog.ts
+var bridge_catalog_exports = {};
+__export(bridge_catalog_exports, {
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  SERVER_INFO: () => SERVER_INFO,
+  StaticCatalogInterceptor: () => StaticCatalogInterceptor,
+  buildInitializeResult: () => buildInitializeResult,
+  buildToolsListResult: () => buildToolsListResult
+});
+function tryIntercept(line) {
+  let msg;
+  try {
+    const parsed = JSON.parse(line);
+    if (!parsed || typeof parsed !== "object") return null;
+    msg = parsed;
+  } catch {
+    return null;
+  }
+  if (msg.method === "initialize") {
+    return JSON.stringify({
+      jsonrpc: "2.0",
+      id: msg.id ?? null,
+      result: {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: { tools: {} },
+        serverInfo: SERVER_INFO
+      }
+    });
+  }
+  if (msg.method === "tools/list") {
+    return JSON.stringify({
+      jsonrpc: "2.0",
+      id: msg.id ?? null,
+      result: { tools: TOOL_DEFINITIONS }
+    });
+  }
+  return null;
+}
+function buildInitializeResult(id) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    result: {
+      protocolVersion: PROTOCOL_VERSION,
+      capabilities: { tools: {} },
+      serverInfo: SERVER_INFO
+    }
+  };
+}
+function buildToolsListResult(id) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    result: { tools: TOOL_DEFINITIONS }
+  };
+}
+var PROTOCOL_VERSION, SERVER_INFO, StaticCatalogInterceptor;
+var init_bridge_catalog = __esm({
+  "src/proxy/bridge-catalog.ts"() {
+    "use strict";
+    init_tool_definitions();
+    PROTOCOL_VERSION = "2024-11-05";
+    SERVER_INFO = {
+      name: "unerr-local",
+      version: "0.1.7"
+    };
+    StaticCatalogInterceptor = class {
+      partial = "";
+      ingest(chunk) {
+        const replies = [];
+        const forward = [];
+        this.partial += chunk.toString("utf8");
+        const lastNewline = this.partial.lastIndexOf("\n");
+        if (lastNewline < 0) {
+          return { replies, forward };
+        }
+        const completeBlock = this.partial.slice(0, lastNewline + 1);
+        this.partial = this.partial.slice(lastNewline + 1);
+        for (const rawLine of completeBlock.split("\n")) {
+          if (rawLine === "") continue;
+          const reply = tryIntercept(rawLine);
+          if (reply !== null) {
+            replies.push(`${reply}
+`);
+          } else {
+            forward.push(Buffer.from(`${rawLine}
+`, "utf8"));
+          }
+        }
+        return { replies, forward };
+      }
+      /**
+       * Returns any unfinished line (no terminating newline yet). Call exactly
+       * once when handing the pre-buffer off to the bridge so partial frames are
+       * forwarded to the proxy without being dropped.
+       */
+      drainPartial() {
+        if (this.partial.length === 0) return null;
+        const buf = Buffer.from(this.partial, "utf8");
+        this.partial = "";
+        return buf;
+      }
+    };
+  }
+});
+
 // src/daemon/spawn-lock.ts
 var spawn_lock_exports = {};
 __export(spawn_lock_exports, {
@@ -46327,16 +47383,16 @@ import {
   closeSync as closeSync2,
   mkdirSync as mkdirSync47,
   openSync as openSync2,
-  readFileSync as readFileSync68,
+  readFileSync as readFileSync69,
   unlinkSync as unlinkSync16,
   writeFileSync as writeFileSync41
 } from "fs";
-import { join as join81 } from "path";
+import { join as join83 } from "path";
 function spawnLockPath() {
-  return join81(globalDir(), "state", "spawn.lock");
+  return join83(globalDir(), "state", "spawn.lock");
 }
 function tryAcquireSpawnLock() {
-  mkdirSync47(join81(globalDir(), "state"), { recursive: true });
+  mkdirSync47(join83(globalDir(), "state"), { recursive: true });
   const path7 = spawnLockPath();
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
@@ -46364,7 +47420,7 @@ function releaseSpawnLock() {
 function reclaimIfStale(path7) {
   let body = null;
   try {
-    body = JSON.parse(readFileSync68(path7, "utf8"));
+    body = JSON.parse(readFileSync69(path7, "utf8"));
   } catch {
     try {
       unlinkSync16(path7);
@@ -46536,8 +47592,8 @@ var init_bridge = __esm({
 });
 
 // src/entrypoints/cli.ts
-import { existsSync as existsSync81, readFileSync as readFileSync69 } from "fs";
-import { join as join82 } from "path";
+import { existsSync as existsSync81, readFileSync as readFileSync70 } from "fs";
+import { join as join84 } from "path";
 import { Command } from "commander";
 
 // src/commands/branches.ts
@@ -49573,12 +50629,12 @@ async function tryLoadGraphForShellBoost(cwd) {
   if (cached && Date.now() - cached.loadedAt < BOOST_TTL_MS) {
     return cached.kind === "ok" ? cached.graph : null;
   }
-  const { existsSync: existsSync82, readFileSync: readFileSync70 } = await import("fs");
-  const { join: join83 } = await import("path");
-  const snapshotsDir = join83(cwd, ".unerr", "snapshots");
-  let snapshotPath2 = join83(snapshotsDir, "graph.msgpack.gz");
+  const { existsSync: existsSync82, readFileSync: readFileSync71 } = await import("fs");
+  const { join: join85 } = await import("path");
+  const snapshotsDir = join85(cwd, ".unerr", "snapshots");
+  let snapshotPath2 = join85(snapshotsDir, "graph.msgpack.gz");
   if (!existsSync82(snapshotPath2)) {
-    snapshotPath2 = join83(snapshotsDir, "graph.msgpack");
+    snapshotPath2 = join85(snapshotsDir, "graph.msgpack");
   }
   if (!existsSync82(snapshotPath2)) {
     const reason = `snapshot missing at ${snapshotsDir}`;
@@ -49605,7 +50661,7 @@ async function tryLoadGraphForShellBoost(cwd) {
   let buffer;
   try {
     const { gunzipSync: gunzipSync3 } = await import("zlib");
-    const raw = readFileSync70(snapshotPath2);
+    const raw = readFileSync71(snapshotPath2);
     try {
       buffer = gunzipSync3(raw);
     } catch {
@@ -54765,9 +55821,9 @@ When your next action is Edit, use built-in Read with offset/limit on the target
 
 **Common failure mode:** Using \`file_read\` to understand a file, then attempting Edit without calling built-in Read first. The Edit tool WILL reject with "File has not been read yet". Always call built-in Read (with offset/limit) immediately before Edit.` : "";
   const summaryEditNote = isClaudeCode ? "\nNEVER use built-in Read/Grep/Glob for code navigation. EXCEPTION: built-in Read (with offset/limit) is REQUIRED immediately before Edit (file_read cannot substitute \u2014 Edit will fail without it)." : "\nNEVER use built-in Read/Grep/Glob for code navigation \u2014 use unerr MCP tools instead.";
-  return `## REQUIRED: Use unerr Graph Intelligence Tools (19 MCP tools)
+  return `## REQUIRED: Use unerr Graph Intelligence Tools (20 MCP tools)
 
-This project has unerr MCP tools installed. You MUST use these instead of built-in Read/Grep/Glob for code navigation. unerr tools are graph-backed, return results in <5ms, and include project context that built-in tools miss.
+This project has unerr MCP tools installed. You MUST use these instead of built-in Read/Grep/Glob for code navigation, and \`fetch_url\` instead of built-in WebFetch. unerr tools are graph-backed, return results in <5ms, and include project context that built-in tools miss.
 
 ### Tool Routing (MANDATORY \u2014 match your goal before calling any tool)
 
@@ -54781,6 +55837,7 @@ ${readForEditRow}
 | Get a specific function or class | \`get_entity\` or \`file_read\` with \`entity\` param | Reading entire file |
 | Trace imports/dependencies | \`get_imports\` or \`get_references\` (direction: callees) | Manual import scanning |
 | Find hotspots / high fan-in / blast-radius candidates | \`get_critical_nodes\` | \`get_entity\` (won't show ranked list), guessing |
+| Fetch a web page by URL | \`fetch_url\` (Defuddle/Readability \u2192 markdown passages \u2192 BM25 ranking when \`prompt\` supplied \u2192 diff-cache) | Built-in WebFetch |
 | Run a shell command | Automatic \u2014 routed through shell intelligence | N/A |
 
 ### FORBIDDEN Patterns (these waste tokens and miss context)
@@ -54791,7 +55848,8 @@ ${readForEditRow}
 - Reading multiple files to understand conventions -> use \`get_conventions\`
 - Guessing code style for new code -> use \`get_conventions\`
 - Guessing which entity has the highest fan-in / is the biggest hotspot -> use \`get_critical_nodes\`
-- Reading a full file when you only need a section -> use \`file_read\` with \`entity\` param or offset/limit${twoStepSection}
+- Reading a full file when you only need a section -> use \`file_read\` with \`entity\` param or offset/limit
+- Using built-in WebFetch for a URL -> use \`fetch_url\` (DOM extraction + markdown + BM25 passage selection cuts 5\u201310\xD7 tokens; pass \`prompt\` to rank passages by relevance)${twoStepSection}
 
 ### Tool Reference
 
@@ -54829,6 +55887,14 @@ ${readForEditRow}
 - \`purpose:'explore'\` (default) \u2014 budget-capped, returns outline for large files. Use for browsing and pre-edit understanding.
 - \`purpose:'reference'\` \u2014 tight budget, entity/offset reads only. Use for quick lookups.
 
+#### Web Fetch (1 tool)
+
+| Task | Tool | Replaces |
+|------|------|----------|
+| Fetch a web page by URL | \`fetch_url\` | Built-in WebFetch |
+
+\`fetch_url\` strips chrome (nav, footer, ads), converts to markdown, splits into heading-bounded passages, optionally re-ranks passages with BM25 when you pass \`prompt\`, and caches by content hash so re-fetching an unchanged page costs near-zero tokens. Pass \`offset\`/\`limit\` to paginate large pages.
+
 #### Shell Compression (automatic)
 
 All shell commands automatically route through unerr's compression layer. It strips ANSI codes, classifies output (diffs, test results, logs, errors), and returns compressed summaries \u2014 saving tokens without losing critical information.
@@ -55187,7 +56253,8 @@ function registerInstallCommand(program2) {
       }
       process.stderr.write("\n");
       process.stderr.write(
-        "  \x1B[38;2;161;161;170mRun \x1B[0munerr\x1B[38;2;161;161;170m to start the intelligence engine.\x1B[0m\n"
+        `  \x1B[38;2;161;161;170mRestart ${agentDef.name} to start using unerr.\x1B[0m
+`
       );
       process.stderr.write("\n");
     }
@@ -55243,29 +56310,13 @@ async function runInstall(cwd, ide, opts) {
     const { daemonSockPath: daemonSockPath2, probeDaemon: probeDaemon2, ensureRepo: ensureRepo2 } = await Promise.resolve().then(() => (init_client(), client_exports));
     const { addRepo: addRepo2, findRepo: findRepo2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
     const sock = daemonSockPath2();
-    const daemonRunning = await probeDaemon2(sock);
-    if (daemonRunning) {
+    if (await probeDaemon2(sock)) {
       if (!findRepo2(cwd)) {
         addRepo2(cwd, {});
         repoRegistered = true;
-        process.stderr.write(
-          "\x1B[38;2;52;211;153m\u2713\x1B[0m Registered repo with unerrd.\n"
-        );
-      }
-      try {
-        await ensureRepo2(sock, cwd);
-        process.stderr.write(
-          "\x1B[38;2;52;211;153m\u2713\x1B[0m unerr process started via daemon.\n"
-        );
-      } catch {
-        process.stderr.write(
-          "\x1B[38;2;251;191;36m\u26A0\x1B[0m Repo registered but process did not start. It will start on next IDE connection.\n"
-        );
       }
-    } else {
-      process.stderr.write(
-        "\x1B[38;2;34;211;238m\u25B8\x1B[0m Daemon not running. To use daemon mode: \x1B[1munerr daemon initialize\x1B[0m\n  For standalone mode: run \x1B[1munerr\x1B[0m in this directory.\n"
-      );
+      await ensureRepo2(sock, cwd).catch(() => {
+      });
     }
   } catch {
   }
@@ -55417,12 +56468,12 @@ function showSetupInstructions(agentName) {
     w("  After restarting your agent, verify unerr tools are available.\n");
     w("  You should see tools like: get_callers, search_code, file_read,\n");
     w("  file_outline, get_imports, get_callees.\n\n");
-    w("  \x1B[1mStep 4: Start unerr\x1B[0m\n");
-    w("  \x1B[2m\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\x1B[0m\n");
+    w("  \x1B[1mStep 4: Restart your agent\x1B[0m\n");
+    w("  \x1B[2m\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\x1B[0m\n");
     w(
-      "  Run \x1B[1munerr\x1B[0m in your project root to start the intelligence engine.\n"
+      "  unerr starts automatically when your agent first connects to its MCP server.\n"
     );
-    w("  The MCP server will be available at \x1B[1munerr --mcp\x1B[0m.\n");
+    w("  No background service to install \u2014 no boot-time setup needed.\n");
   }
   w("\n");
 }
@@ -55757,8 +56808,8 @@ async function persistPatterns(patterns, _unerrDir) {
       );
       return;
     }
-    const { readFileSync: readFileSync70 } = await import("fs");
-    const config = JSON.parse(readFileSync70(configPath2, "utf-8"));
+    const { readFileSync: readFileSync71 } = await import("fs");
+    const config = JSON.parse(readFileSync71(configPath2, "utf-8"));
     if (!config.repoId || !config.orgId) {
       warn("Repo not configured \u2014 cannot persist to CozoDB.");
       return;
@@ -55776,7 +56827,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 = readFileSync70(snapshotPath2);
+    const raw = readFileSync71(snapshotPath2);
     const buffer = gunzipSync2(raw);
     const envelope = unpack(buffer);
     await store.loadSnapshot(envelope);
@@ -56037,7 +57088,13 @@ function parseSettingsFlags(raw) {
 var write3 = (msg) => process.stderr.write(msg);
 function registerPmCommand(program2) {
   const pm = program2.command("pm").description("Manage the unerr process manager");
-  pm.command("start").description("Start the unerr process manager").option("--foreground", "Run in foreground (blocks terminal \u2014 useful for debugging)").option("--detached", "Run in-process as a detached supervisor (used by auto-spawn)").action(async (opts) => {
+  pm.command("start").description("Start the unerr process manager").option(
+    "--foreground",
+    "Run in foreground (blocks terminal \u2014 useful for debugging)"
+  ).option(
+    "--detached",
+    "Run in-process as a detached supervisor (used by auto-spawn)"
+  ).action(async (opts) => {
     if (opts.foreground || opts.detached) {
       process.title = "unerrd";
       const { startDaemon: startDaemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
@@ -56049,7 +57106,12 @@ function registerPmCommand(program2) {
     const child = spawn(
       process.execPath,
       [unerrBin, "pm", "start", "--detached"],
-      { detached: true, stdio: "ignore", windowsHide: true, env: { ...process.env } }
+      {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+        env: { ...process.env }
+      }
     );
     child.unref();
     const { daemonSockPath: daemonSockPath2, probeDaemon: probeDaemon2 } = await Promise.resolve().then(() => (init_client(), client_exports));
@@ -56066,12 +57128,12 @@ function registerPmCommand(program2) {
     }
     if (running) {
       const { homedir: homedir12 } = await import("os");
-      const { join: join83 } = await import("path");
-      const pidPath2 = join83(homedir12(), ".unerr", "unerrd.pid");
+      const { join: join85 } = await import("path");
+      const pidPath2 = join85(homedir12(), ".unerr", "unerrd.pid");
       let daemonPid = String(child.pid);
       try {
-        const { readFileSync: readFileSync70 } = await import("fs");
-        daemonPid = readFileSync70(pidPath2, "utf-8").trim();
+        const { readFileSync: readFileSync71 } = await import("fs");
+        daemonPid = readFileSync71(pidPath2, "utf-8").trim();
       } catch {
       }
       write3(
@@ -56088,8 +57150,8 @@ function registerPmCommand(program2) {
   pm.command("stop").description("Stop the unerrd supervisor").action(async () => {
     const { createConnection: createConnection3 } = await import("net");
     const { globalDir: globalDir2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
-    const { join: join83 } = await import("path");
-    const sock = join83(globalDir2(), "unerrd.sock");
+    const { join: join85 } = await import("path");
+    const sock = join85(globalDir2(), "unerrd.sock");
     const { existsSync: existsSync82 } = await import("fs");
     if (!existsSync82(sock)) {
       write3("unerrd is not running (no socket found).\n");
@@ -56214,7 +57276,7 @@ function registerPmCommand(program2) {
   pm.command("status").description("List all registered repos and their state").action(async () => {
     const repos = listRepos();
     if (repos.length === 0) {
-      write3("No repos registered. Use `unerr daemon add .` to register.\n");
+      write3("No repos registered. Use `unerr pm add .` to register.\n");
       return;
     }
     let liveStatus = null;
@@ -56263,7 +57325,7 @@ function registerPmCommand(program2) {
     }
     write3(
       `
-  \x1B[1munerr daemon\x1B[0m \u2014 ${repos.length} repo${repos.length === 1 ? "" : "s"} registered
+  \x1B[1munerr pm\x1B[0m \u2014 ${repos.length} repo${repos.length === 1 ? "" : "s"} registered
 
 `
     );
@@ -56296,7 +57358,7 @@ function registerPmCommand(program2) {
           write3(
             `      ${ni.key}: auto-selected \x1B[1m${ni.auto}\x1B[0m (${ni.reason})
         Alternatives: ${ni.alternatives.join(", ")}
-        Override: unerr daemon config ${repo.path} --${toKebab(ni.key)}=${ni.alternatives[0]}
+        Override: unerr pm config ${repo.path} --${toKebab(ni.key)}=${ni.alternatives[0]}
 `
           );
         }
@@ -56327,7 +57389,7 @@ function registerPmCommand(program2) {
         if (!entry) {
           write3(
             `\x1B[38;2;248;113;113m\u2717\x1B[0m Not registered: ${targetPath}
-  Register first: unerr daemon add ${targetPath}
+  Register first: unerr pm add ${targetPath}
 `
           );
           process.exitCode = 1;
@@ -56382,7 +57444,7 @@ function registerPmCommand(program2) {
       if (!updated) {
         write3(
           `\x1B[38;2;248;113;113m\u2717\x1B[0m Not registered: ${targetPath}
-  Register first: unerr daemon add ${targetPath}
+  Register first: unerr pm add ${targetPath}
 `
         );
         process.exitCode = 1;
@@ -58025,8 +59087,8 @@ function registerStatusCommand(program2) {
     try {
       const logsDir = join53(unerrDir2, "logs");
       if (existsSync50(logsDir)) {
-        const { readdirSync: readdirSync19, statSync: statSync16 } = await import("fs");
-        const logs = readdirSync19(logsDir).filter((f) => f.startsWith("session-") && f.endsWith(".log")).map((f) => ({
+        const { readdirSync: readdirSync20, statSync: statSync16 } = await import("fs");
+        const logs = readdirSync20(logsDir).filter((f) => f.startsWith("session-") && f.endsWith(".log")).map((f) => ({
           name: f,
           mtime: statSync16(join53(logsDir, f)).mtimeMs
         })).sort((a, b) => b.mtime - a.mtime);
@@ -59034,7 +60096,7 @@ var SOURCE_DIRS = /* @__PURE__ */ new Set([
 ]);
 var DETECTION_THRESHOLD = 5;
 async function detectProjectRoot(cwd) {
-  const { readdirSync: readdirSync19 } = await import("fs");
+  const { readdirSync: readdirSync20 } = await import("fs");
   let score = 0;
   const signals = [];
   let hasGit = false;
@@ -59052,7 +60114,7 @@ async function detectProjectRoot(cwd) {
   }
   let rootEntries = [];
   try {
-    rootEntries = readdirSync19(cwd, { withFileTypes: true }).map((e) => ({
+    rootEntries = readdirSync20(cwd, { withFileTypes: true }).map((e) => ({
       name: e.name,
       isFile: e.isFile(),
       isDir: e.isDirectory()
@@ -59143,7 +60205,7 @@ async function detectProjectRoot(cwd) {
   }
   function dirHasCodeFile(dir) {
     try {
-      const entries = readdirSync19(dir, { withFileTypes: true });
+      const entries = readdirSync20(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isFile()) continue;
         const dot = entry.name.lastIndexOf(".");
@@ -59167,7 +60229,7 @@ async function detectProjectRoot(cwd) {
   for (const dirEntry of rootEntries) {
     if (!dirEntry.isDir || dirEntry.name.startsWith(".")) continue;
     if (!SOURCE_DIRS.has(dirEntry.name.toLowerCase())) continue;
-    const sourceDir = join82(cwd, dirEntry.name);
+    const sourceDir = join84(cwd, dirEntry.name);
     const srcCodeFile = dirHasCodeFile(sourceDir);
     if (srcCodeFile) {
       score += 6;
@@ -59175,11 +60237,11 @@ async function detectProjectRoot(cwd) {
       break;
     }
     try {
-      const subEntries = readdirSync19(sourceDir, { withFileTypes: true });
+      const subEntries = readdirSync20(sourceDir, { withFileTypes: true });
       let found = false;
       for (const sub of subEntries) {
         if (!sub.isDirectory() || sub.name.startsWith(".")) continue;
-        const deepCode = dirHasCodeFile(join82(sourceDir, sub.name));
+        const deepCode = dirHasCodeFile(join84(sourceDir, sub.name));
         if (deepCode) {
           score += 6;
           signals.push(`code-src: ${dirEntry.name}/${sub.name}/${deepCode}`);
@@ -59202,10 +60264,10 @@ async function detectProjectRoot(cwd) {
   };
 }
 function readLocalConfig(cwd) {
-  const configPath2 = join82(cwd, ".unerr", "config.json");
+  const configPath2 = join84(cwd, ".unerr", "config.json");
   if (!existsSync81(configPath2)) return null;
   try {
-    return JSON.parse(readFileSync69(configPath2, "utf-8"));
+    return JSON.parse(readFileSync70(configPath2, "utf-8"));
   } catch {
     return null;
   }
@@ -59328,8 +60390,8 @@ async function daemonChildBoot(cwd) {
     repoId: config.repoId,
     daemonChild: true
   });
-  const stateDir = join82(cwd, ".unerr", "state");
-  const sockPath2 = join82(stateDir, "proxy.sock");
+  const stateDir = join84(cwd, ".unerr", "state");
+  const sockPath2 = join84(stateDir, "proxy.sock");
   if (process.send) {
     process.send({ type: "ready", sock: sockPath2 });
   }
@@ -59383,8 +60445,18 @@ async function mcpBoot(cwd) {
     keep: 5
   });
   initFileLog(cwd);
+  const { StaticCatalogInterceptor: StaticCatalogInterceptor2 } = await Promise.resolve().then(() => (init_bridge_catalog(), bridge_catalog_exports));
+  const interceptor = new StaticCatalogInterceptor2();
   const stdinPreBuffer = [];
-  const preBufferHandler = (chunk) => stdinPreBuffer.push(chunk);
+  const preBufferHandler = (chunk) => {
+    const out = interceptor.ingest(chunk);
+    for (const reply of out.replies) {
+      process.stdout.write(reply);
+    }
+    for (const buf of out.forward) {
+      stdinPreBuffer.push(buf);
+    }
+  };
   process.stdin.on("data", preBufferHandler);
   let stdinEndedEarly = false;
   const earlyEndHandler = () => {
@@ -59446,6 +60518,8 @@ ${antiSignals.length > 0 ? `  Negative signals: ${antiSignals.map((s) => s.repla
     if (process.stdin.listenerCount("data") > 0 && stdinPreBuffer.length >= 0) {
       process.stdin.removeListener("data", preBufferHandler);
       process.stdin.removeListener("end", earlyEndHandler);
+      const partial = interceptor.drainPartial();
+      if (partial) stdinPreBuffer.push(partial);
       bufferForBridge = stdinPreBuffer.slice();
       stdinPreBuffer.length = 0;
     }
@@ -59500,10 +60574,10 @@ async function discoverWithRetry(cwd, daemonSockPath2, probeDaemon2, ensureRepo2
   let attempt = 0;
   let spawnAttempted = false;
   for (; ; ) {
-    const repoSock = join82(cwd, ".unerr", "state", "proxy.sock");
+    const repoSock = join84(cwd, ".unerr", "state", "proxy.sock");
     if (existsSync81(repoSock)) {
       const { PidLock: PidLock2 } = await Promise.resolve().then(() => (init_pid_lock(), pid_lock_exports));
-      const pidLock = new PidLock2(join82(cwd, ".unerr", "state"));
+      const pidLock = new PidLock2(join84(cwd, ".unerr", "state"));
       const probeResult = await pidLock.probe();
       if (probeResult.alive) {
         return {