token-goat 2.6.36 → 2.8.0

package/dist/{token-goat-chunk-UFOVM7ZN.mjs → token-goat-chunk-2F6TFBZE.mjs}

@@ -19,6 +19,7 @@ import {
   detectLanguage,
   displaySafePath,
   displaySafeText,
+  ensureDataDirPrivate,
   ensureDirSync,
   escapeRegExp,
   extractEnv,
@@ -89,7 +90,7 @@ import {
   withFileLock,
   writeIfDifferent,
   writeJsonSettings
-} from "./token-goat-chunk-V465YKOR.mjs";
+} from "./token-goat-chunk-44Y77VHR.mjs";
 import {
   registerReset
 } from "./token-goat-chunk-AO2QD2AG.mjs";
@@ -113,15 +114,221 @@ function createLazyModuleLoader(load3, errorLabel) {
   };
 }
 
+// src/xml_parser.ts
+var MAX_XML_DEPTH = 512;
+var NAMED_ENTITIES = {
+  lt: "<",
+  gt: ">",
+  amp: "&",
+  quot: '"',
+  apos: "'"
+};
+function decodeXmlEntities(text) {
+  if (!text.includes("&")) return text;
+  return text.replace(/&(#[xX][0-9a-fA-F]+|#[0-9]+|[a-zA-Z_][\w.:-]*);/g, (whole, body) => {
+    if (body.charCodeAt(0) === 35) {
+      const isHex = body.charCodeAt(1) === 120 || body.charCodeAt(1) === 88;
+      const digits = isHex ? body.slice(2) : body.slice(1);
+      const code = parseInt(digits, isHex ? 16 : 10);
+      if (!Number.isFinite(code) || code < 0 || code > 1114111) return whole;
+      if (code >= 55296 && code <= 57343) return whole;
+      return String.fromCodePoint(code);
+    }
+    const named = NAMED_ENTITIES[body];
+    return named ?? whole;
+  });
+}
+function newFrame(name) {
+  return { name, children: /* @__PURE__ */ new Map(), text: [], attrs: [] };
+}
+function finishFrame(frame) {
+  const text = frame.text.join("");
+  if (frame.children.size === 0 && frame.attrs.length === 0) return text;
+  const obj = {};
+  for (const [key, value] of frame.children) obj[key] = value;
+  if (text.length > 0) obj["#text"] = text;
+  for (const [key, value] of frame.attrs) obj[`@_${key}`] = value;
+  return obj;
+}
+function addChild(parent, name, value) {
+  const existing = parent.children.get(name);
+  if (existing === void 0 && !parent.children.has(name)) {
+    parent.children.set(name, value);
+    return;
+  }
+  if (Array.isArray(existing)) {
+    existing.push(value);
+    return;
+  }
+  parent.children.set(name, [existing, value]);
+}
+var WHITESPACE = /* @__PURE__ */ new Set([" ", "	", "\n", "\r"]);
+function findTagEnd(src, from) {
+  let quote = "";
+  for (let i = from; i < src.length; i++) {
+    const ch = src[i];
+    if (quote !== "") {
+      if (ch === quote) quote = "";
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === ">") return i;
+  }
+  return -1;
+}
+function skipDeclaration(src, from) {
+  let quote = "";
+  let inSubset = false;
+  for (let i = from + 2; i < src.length; i++) {
+    const ch = src[i];
+    if (quote !== "") {
+      if (ch === quote) quote = "";
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "[") inSubset = true;
+    else if (ch === "]") inSubset = false;
+    else if (ch === ">" && !inSubset) return i + 1;
+  }
+  return src.length;
+}
+function parseTagBody(body) {
+  let i = 0;
+  while (i < body.length && !WHITESPACE.has(body[i])) i++;
+  const name = body.slice(0, i);
+  const attrs = [];
+  while (i < body.length) {
+    while (i < body.length && WHITESPACE.has(body[i])) i++;
+    if (i >= body.length) break;
+    const nameStart = i;
+    while (i < body.length && !WHITESPACE.has(body[i]) && body[i] !== "=") i++;
+    const attrName = body.slice(nameStart, i);
+    if (attrName.length === 0) {
+      i++;
+      continue;
+    }
+    while (i < body.length && WHITESPACE.has(body[i])) i++;
+    if (body[i] !== "=") {
+      attrs.push([attrName, ""]);
+      continue;
+    }
+    i++;
+    while (i < body.length && WHITESPACE.has(body[i])) i++;
+    const quote = body[i];
+    if (quote === '"' || quote === "'") {
+      const valueStart = i + 1;
+      const valueEnd = body.indexOf(quote, valueStart);
+      const end = valueEnd === -1 ? body.length : valueEnd;
+      attrs.push([attrName, decodeXmlEntities(body.slice(valueStart, end))]);
+      i = end + 1;
+    } else {
+      const valueStart = i;
+      while (i < body.length && !WHITESPACE.has(body[i])) i++;
+      attrs.push([attrName, decodeXmlEntities(body.slice(valueStart, i))]);
+    }
+  }
+  return { name, attrs };
+}
+function parseXml(xml) {
+  const src = xml.charCodeAt(0) === 65279 ? xml.slice(1) : xml;
+  const root = newFrame("");
+  const stack = [root];
+  const len = src.length;
+  let i = 0;
+  const top = () => stack[stack.length - 1];
+  const pushText = (from, to) => {
+    if (to > from) top().text.push(decodeXmlEntities(src.slice(from, to)));
+  };
+  const closeElement = (name) => {
+    let target = -1;
+    for (let k = stack.length - 1; k >= 1; k--) {
+      if (stack[k].name === name) {
+        target = k;
+        break;
+      }
+    }
+    if (target === -1) return;
+    while (stack.length > target) {
+      const frame = stack.pop();
+      addChild(top(), frame.name, finishFrame(frame));
+    }
+  };
+  while (i < len) {
+    const lt = src.indexOf("<", i);
+    if (lt === -1) {
+      pushText(i, len);
+      break;
+    }
+    pushText(i, lt);
+    if (src.startsWith("<!--", lt)) {
+      const end2 = src.indexOf("-->", lt + 4);
+      i = end2 === -1 ? len : end2 + 3;
+      continue;
+    }
+    if (src.startsWith("<![CDATA[", lt)) {
+      const end2 = src.indexOf("]]>", lt + 9);
+      top().text.push(src.slice(lt + 9, end2 === -1 ? len : end2));
+      i = end2 === -1 ? len : end2 + 3;
+      continue;
+    }
+    if (src.startsWith("<!", lt)) {
+      i = skipDeclaration(src, lt);
+      continue;
+    }
+    if (src.startsWith("<?", lt)) {
+      const end2 = src.indexOf("?>", lt + 2);
+      const { name: name2, attrs: attrs2 } = parseTagBody(src.slice(lt + 2, end2 === -1 ? len : end2));
+      if (name2.length > 0) {
+        const frame2 = newFrame(`?${name2}`);
+        frame2.attrs = attrs2;
+        addChild(top(), frame2.name, finishFrame(frame2));
+      }
+      i = end2 === -1 ? len : end2 + 2;
+      continue;
+    }
+    if (src.startsWith("</", lt)) {
+      const end2 = src.indexOf(">", lt + 2);
+      closeElement(src.slice(lt + 2, end2 === -1 ? len : end2).trim());
+      i = end2 === -1 ? len : end2 + 1;
+      continue;
+    }
+    const end = findTagEnd(src, lt + 1);
+    const tagEnd = end === -1 ? len : end;
+    let body = src.slice(lt + 1, tagEnd);
+    const selfClosing = body.endsWith("/");
+    if (selfClosing) body = body.slice(0, -1);
+    const { name, attrs } = parseTagBody(body);
+    i = end === -1 ? len : end + 1;
+    if (name.length === 0) continue;
+    const frame = newFrame(name);
+    frame.attrs = attrs;
+    if (selfClosing) {
+      addChild(top(), name, finishFrame(frame));
+      continue;
+    }
+    if (stack.length > MAX_XML_DEPTH) {
+      throw new Error(`XML nesting deeper than ${MAX_XML_DEPTH} elements; refusing to parse (this file is not something any office application produces)`);
+    }
+    stack.push(frame);
+  }
+  while (stack.length > 1) {
+    const frame = stack.pop();
+    addChild(top(), frame.name, finishFrame(frame));
+  }
+  return Object.fromEntries(root.children);
+}
+
 // src/ooxml_extract.ts
 var loadFflate = createLazyModuleLoader(
   async () => await import("fflate"),
   "office-file reading disabled (fflate unavailable)"
 );
-var loadXmlParser = createLazyModuleLoader(
-  async () => await import("fast-xml-parser"),
-  "office-file reading disabled (fast-xml-parser unavailable)"
-);
 var MAX_OOXML_INPUT_BYTES = 50 * 1024 * 1024;
 function accessFailureMessage(err, filePath) {
   const code = err?.code;
@@ -159,15 +366,7 @@ function decodeZipEntry(entries, entryPath) {
   return new TextDecoder("utf-8").decode(bytes);
 }
 async function parseOoxmlPart(xmlText2) {
-  const fxp = await loadXmlParser();
-  if (!fxp) throw new Error("fast-xml-parser is not installed; run `npm install fast-xml-parser` to enable this command");
-  const parser = new fxp.XMLParser({
-    ignoreAttributes: false,
-    preserveOrder: false,
-    trimValues: false,
-    parseTagValue: false
-  });
-  return parser.parse(xmlText2);
+  return parseXml(xmlText2);
 }
 function pushTextValue(runs, val) {
   if (Array.isArray(val)) {
@@ -345,9 +544,9 @@ async function notesPathFor(entries, slidePath) {
   }
   return null;
 }
-async function parseSlide(entries, path30) {
-  const xml = decodeZipEntry(entries, path30);
-  if (xml === null) throw new Error(`missing part: ${path30}`);
+async function parseSlide(entries, path31) {
+  const xml = decodeZipEntry(entries, path31);
+  if (xml === null) throw new Error(`missing part: ${path31}`);
   return parseOoxmlPart(xml);
 }
 async function notesTextFor(entries, notesPath) {
@@ -363,8 +562,8 @@ async function pptxOutline(filePath) {
   const { entries, slidePaths } = await listSlideParts(filePath);
   const out = [];
   for (let i = 0; i < slidePaths.length; i++) {
-    const path30 = slidePaths[i];
-    const parsed = await parseSlide(entries, path30);
+    const path31 = slidePaths[i];
+    const parsed = await parseSlide(entries, path31);
     const shapes = slideShapes(parsed);
     const titleShape = shapes.find((s) => {
       const t = shapePlaceholderType(s);
@@ -373,7 +572,7 @@ async function pptxOutline(filePath) {
     const title = titleShape !== void 0 ? shapeText(titleShape) : "";
     const allText = collectTextRuns(parsed, "a:t").join(" ");
     const bodyChars = Math.max(0, allText.length - title.length);
-    const hasNotes = (await notesTextFor(entries, await notesPathFor(entries, path30))).length > 0;
+    const hasNotes = (await notesTextFor(entries, await notesPathFor(entries, path31))).length > 0;
     out.push({ slide: i + 1, title, bodyChars, hasNotes });
   }
   return out;
@@ -383,13 +582,13 @@ async function pptxSlideText(filePath, slideNumber, includeNotes) {
   if (slideNumber < 1 || slideNumber > slidePaths.length) {
     throw new Error(`slide ${slideNumber} out of range (this deck has ${slidePaths.length} slides)`);
   }
-  const path30 = slidePaths[slideNumber - 1];
-  const parsed = await parseSlide(entries, path30);
+  const path31 = slidePaths[slideNumber - 1];
+  const parsed = await parseSlide(entries, path31);
   const shapes = slideShapes(parsed);
   const blocks = [...shapes.map(shapeText).filter((t) => t.length > 0), ...tableRowBlocks(parsed)];
   const lines2 = [`# Slide ${slideNumber}`, ...blocks];
   if (includeNotes) {
-    const notes = await notesTextFor(entries, await notesPathFor(entries, path30));
+    const notes = await notesTextFor(entries, await notesPathFor(entries, path31));
     if (notes.length > 0) lines2.push("", "## Speaker notes", notes);
   }
   return lines2.join("\n\n");
@@ -3023,19 +3222,30 @@ var CLAUDE_CODE_EVENT_NAMES = {
   notification: "Notification",
   stop: "Stop",
   pre_compact: "PreCompact",
+  post_compact: "PostCompact",
   user_prompt_submit: "UserPromptSubmit",
   subagent_stop: "SubagentStop",
-  session_start: "SessionStart"
+  session_start: "SessionStart",
+  // Claude Code has no separate failure event -- a failed tool arrives on PostToolUse there,
+  // and only Copilot splits it out. This entry exists because the map is exhaustive over
+  // HookEventName, and it is a spelling for the response envelope rather than a claim that
+  // Claude Code will ever send this event. Nothing iterates this map to build install config,
+  // so naming an event Claude Code does not have cannot register one.
+  post_tool_use_failure: "PostToolUseFailure"
 };
 var EVENTS_WITHOUT_ADDITIONAL_CONTEXT = /* @__PURE__ */ new Set([
   "notification",
   "pre_compact"
 ]);
-function serializeOutput(output, eventName) {
+var EVENTS_WITH_RAW_STDOUT_CONTEXT = /* @__PURE__ */ new Set(["pre_compact"]);
+function serializeOutput(output, eventName, harness) {
   switch (output.hookType) {
     case "deny":
       return JSON.stringify({ decision: "block", reason: output.message });
     case "context":
+      if (EVENTS_WITH_RAW_STDOUT_CONTEXT.has(eventName) && harness === "claudecode") {
+        return output.context;
+      }
       if (EVENTS_WITHOUT_ADDITIONAL_CONTEXT.has(eventName)) {
         return JSON.stringify({ systemMessage: output.context });
       }
@@ -3499,6 +3709,7 @@ var _bashOutputs = /* @__PURE__ */ new Map();
 var _grepQueries = /* @__PURE__ */ new Map();
 var _globQueries = /* @__PURE__ */ new Map();
 var _lastTabContext = null;
+var _seenImageHashes = [];
 var _outstandingAgentSpawns = [];
 var _outstandingAgentSpawnsAtLoad = [];
 var _bashReruns = /* @__PURE__ */ new Set();
@@ -3698,6 +3909,18 @@ function setLastTabContext(text) {
 function getLastTabContext() {
   return _lastTabContext;
 }
+var MAX_SEEN_IMAGE_HASHES = 16;
+function hasSeenImage(hash2) {
+  return _seenImageHashes.includes(hash2);
+}
+function recordSeenImage(hash2) {
+  const at = _seenImageHashes.indexOf(hash2);
+  if (at !== -1) _seenImageHashes.splice(at, 1);
+  _seenImageHashes.push(hash2);
+  if (_seenImageHashes.length > MAX_SEEN_IMAGE_HASHES) {
+    _seenImageHashes.splice(0, _seenImageHashes.length - MAX_SEEN_IMAGE_HASHES);
+  }
+}
 var MAX_OUTSTANDING_AGENT_SPAWNS = 30;
 function recordOutstandingAgentSpawn(prompt) {
   _outstandingAgentSpawns.push({ prompt, ts: Date.now() });
@@ -3811,6 +4034,7 @@ function exportSessionState() {
     globQueries: Array.from(_globQueries.entries()),
     outstandingAgentSpawns: _outstandingAgentSpawns.map((e) => [e.prompt, e.ts]),
     ..._lastTabContext !== null ? { lastTabContext: _lastTabContext } : {},
+    ..._seenImageHashes.length > 0 ? { seenImageHashes: [..._seenImageHashes] } : {},
     ..._compactedAt > 0 ? { compactedAt: _compactedAt } : {}
   };
 }
@@ -3836,6 +4060,7 @@ function importSessionState(s) {
   _outstandingAgentSpawns = (s.outstandingAgentSpawns ?? []).map(([prompt, ts]) => ({ prompt, ts }));
   _outstandingAgentSpawnsAtLoad = [..._outstandingAgentSpawns];
   _lastTabContext = s.lastTabContext ?? null;
+  _seenImageHashes = [...s.seenImageHashes ?? []];
   _compactedAt = s.compactedAt ?? 0;
 }
 registerReset(() => {
@@ -3857,6 +4082,7 @@ registerReset(() => {
   _outstandingAgentSpawns = [];
   _outstandingAgentSpawnsAtLoad = [];
   _lastTabContext = null;
+  _seenImageHashes = [];
   _compactedAt = 0;
   _sessionId = null;
 });
@@ -3879,9 +4105,11 @@ const VALID_HOOK_EVENTS = new Set([
   'notification',
   'stop',
   'pre_compact',
+  'post_compact',
   'user_prompt_submit',
   'subagent_stop',
   'session_start',
+  'post_tool_use_failure',
 ])`;
 var SHIM_TRY_IN_PROCESS = `// Attempts the in-process hook call: import()s dist/token-goat-hook.mjs (a sibling of
 // the baked token-goat entry path, built with zero load-time side effects -- unlike
@@ -4030,6 +4258,7 @@ var HOOK_EVENT_MAP = [
   ["PreToolUse", "pre_tool_use"],
   ["PostToolUse", "post_tool_use"],
   ["PreCompact", "pre_compact"],
+  ["PostCompact", "post_compact"],
   ["UserPromptSubmit", "user_prompt_submit"],
   ["SubagentStop", "subagent_stop"],
   ["SessionStart", "session_start"]
@@ -4346,9 +4575,11 @@ const HOOK_EVENT_NAME_MAP = {
   notification: 'Notification',
   stop: 'Stop',
   pre_compact: 'PreCompact',
+  post_compact: 'PostCompact',
   user_prompt_submit: 'UserPromptSubmit',
   subagent_stop: 'SubagentStop',
   session_start: 'SessionStart',
+  post_tool_use_failure: 'PostToolUseFailure',
 }
 
 function stripTg(value) {
@@ -4729,10 +4960,19 @@ const path = require('node:path')
 const { pathToFileURL } = require('node:url')
 
 // Copilot event name -> token-goat internal HookEventName (src/types.ts's
-// HOOK_EVENTS). Only these seven have a token-goat handler; every other real
-// Copilot event (sessionEnd, postToolUseFailure, subagentStart,
-// errorOccurred, notification, permissionRequest) is left unimplemented
+// HOOK_EVENTS). Only these eight have a token-goat handler; every other real
+// Copilot event (sessionEnd, subagentStart, errorOccurred, notification,
+// permissionRequest) is left unimplemented
 // rather than guessed at, and falls through to the default no-op below.
+// postToolUseFailure is the newest of the eight and the only one whose channel
+// costs tokens instead of saving them: it fires instead of postToolUse when a
+// tool result is a failure, and accepts only additionalContext back --
+// modifiedResult and suppressOutput are not honored there, so a failed result
+// still cannot be fenced, compressed or shrunk. It is wired anyway because
+// additionalContext demonstrably reaches the model (see the postToolUseFailure
+// branch in translate() for the bundle offset), and hooks_tool_failure.ts
+// spends that channel only on an exact repeat failure, where staying silent
+// costs a whole wasted retry.
 // 'sessionStart' was previously a permanent no-op on the stated grounds that
 // token-goat has no internal session_start handler. That was simply wrong --
 // hooks_session_start.ts has long emitted the command-routing reminder that
@@ -4752,6 +4992,7 @@ const COPILOT_TO_TG_EVENT = {
   agentStop: 'stop',
   subagentStop: 'subagent_stop',
   userPromptSubmitted: 'user_prompt_submit',
+  postToolUseFailure: 'post_tool_use_failure',
 }
 
 // Copilot built-in tool name -> token-goat internal tool name. Confirmed via
@@ -4766,9 +5007,47 @@ const COPILOT_TO_TG_EVENT = {
 // MCP-server tool invocations (<server-name>-<tool-name>) have no
 // token-goat equivalent and are passed through unmapped (safe no-op for
 // handlers that don't recognize the name).
+// 'read_bash'/'read_powershell' are the background-shell output pollers, and
+// they are the exact shape of Claude Code's BashOutput: Copilot's shell tool
+// is async, so a long-running command is started once and then re-read over
+// and over within one turn, each read returning the accumulated output again.
+// hooks_bashoutput.ts already collapses that into a delta (or a short
+// "unchanged" marker) for Claude Code, and now does the same here. Both the
+// names and the argument key were read out of the shipping 1.0.80 bundle
+// rather than guessed: the builtin tool-name table in
+// prebuilds/win32-x64/runtime.node lists read_bash/stop_bash/list_bash and
+// read_powershell/stop_powershell/list_powershell, and the poller's own input
+// schema in app.js is {shellId, delay} -- so the shell id needs the
+// POLL_ID_ARG_KEY remap below to reach postBashOutputHandler, which reads
+// 'bash_id'. read_shell/stop_shell/list_shells, which an earlier static sweep
+// of the same binary suggested were the real names, are internal Rust
+// identifiers (tool_read_shell_prepare_input, tool_list_shells_descriptor,
+// PreparedStopShellInput, and the serde field names of the shell config
+// struct), never wire tool names, so they are deliberately absent here.
+// stop_bash/list_bash and their powershell twins stay unmapped because
+// token-goat has no KillShell-equivalent handler for them to reach; a mapping
+// would be pure decoration.
+// 'bash'/'powershell' stay exactly as they were. The same sweep suggested the
+// executor had been renamed to write_bash/write_powershell and that this
+// mapping was dead, and that is not what the bundle says: app.js resolves the
+// executor as shellConfig?.shellToolName ?? "bash" (with "powershell" as the
+// Windows default of the same config), and its command lives under 'command'
+// exactly as hooks_bash.ts expects. write_bash/write_powershell are real tool
+// names, but they are a different tool -- their schema is {shellId, input,
+// delay} and the bundle files them under the subtype "write_shell", i.e. send
+// stdin to an already-running shell, not run a command. Mapping them to Bash
+// would label a stdin write as a shell execution, so they are left unmapped.
+// 'task', 'read_agent' and 'memory'-family tools are likewise left alone:
+// task's result is assembled in the native addon and its shape is unknown,
+// read_agent is an incremental poll that postAgentHandler is not written for,
+// and the real tool names behind memory were never confirmed. Each would put
+// a handler that rewrites model-visible output in front of a payload shape
+// nobody has seen, which is worse than leaving the compression on the table.
 const TOOL_TO_TG = {
   bash: 'Bash',
   powershell: 'Bash',
+  read_bash: 'BashOutput',
+  read_powershell: 'BashOutput',
   view: 'Read',
   create: 'Write',
   edit: 'Edit',
@@ -4809,6 +5088,17 @@ const FILE_PATH_ARG_KEY = {
   create: 'path',
 }
 
+// read_bash/read_powershell send the background shell's id under 'shellId' (confirmed
+// against the poller's input schema in the shipping 1.0.80 app.js: {shellId, delay});
+// postBashOutputHandler reads 'bash_id'. Without this the tool-name mapping above would
+// be inert -- the handler bails on a missing bash_id and every poll would keep costing
+// the full accumulated output. Same keying convention as FILE_PATH_ARG_KEY: the ORIGINAL
+// Copilot tool name, since that is what the argument shape belongs to.
+const POLL_ID_ARG_KEY = {
+  read_bash: 'shellId',
+  read_powershell: 'shellId',
+}
+
 // Copilot spawns a brand-new process for every single hook invocation (no long-lived plugin
 // process the way OpenClaw's is -- OPENCLAW_HOOK_SCRIPT's own \`copilot-\${process.pid}-\${Date.now()}\`
 // fallback is safe there specifically because that process lives for the whole session, so the
@@ -4825,13 +5115,19 @@ function stableFallbackSessionId(cwd) {
 }
 
 function remapToolInput(copilotToolName, input) {
+  if (!input || typeof input !== 'object') return input
+  let out = input
+  // Add the canonical key alongside the original rather than renaming it, so nothing that
+  // might read the original 'path'/'shellId' key elsewhere (e.g. a future handler) loses it.
   const pathKey = FILE_PATH_ARG_KEY[copilotToolName]
-  if (pathKey === undefined || !input || typeof input !== 'object' || !(pathKey in input)) {
-    return input
+  if (pathKey !== undefined && pathKey in out) {
+    out = Object.assign({}, out, { file_path: out[pathKey] })
+  }
+  const idKey = POLL_ID_ARG_KEY[copilotToolName]
+  if (idKey !== undefined && idKey in out) {
+    out = Object.assign({}, out, { bash_id: out[idKey] })
   }
-  // Add file_path alongside the original key rather than renaming it, so nothing that
-  // might read the original 'path' key elsewhere (e.g. a future handler) loses it.
-  return Object.assign({}, input, { file_path: input[pathKey] })
+  return out
 }
 
 // Attempts the in-process hook call: import()s dist/token-goat-hook.mjs (a sibling of
@@ -4983,7 +5279,46 @@ function translate(copilotEvent, resp) {
   }
 
   if (copilotEvent === 'postToolUse') {
-    // Confirmed against https://docs.github.com/en/copilot/reference/hooks-reference: postToolUse accepts modifiedResult ({resultType: 'success', textResultForLlm: string}) to replace the tool output, and additionalContext can coexist with it in the same response -- token-goat's rewriteOutput producers (compression, injection fencing, image shrink) map to modifiedResult here; resultType is hardcoded 'success' since token-goat never intends to fail the tool call. Emitted camelCase-only, not the snake_case "VS Code compatible" variant the inbound side handles around line 247: the hooks reference doc selects that format by registering the event name in PascalCase, and COPILOT_CLI_HOOK_EVENTS (copilot_cli_install.ts) registers every event this shim handles in camelCase, so a token-goat-installed hook can never be in that mode and a snake_case response would be wrong here, not merely redundant.
+    // Verified against the shipping @github/copilot 1.0.80 bundle, not against the docs page.
+    // NativeHookPipelineProcessor.postToolExecution (app.js offset 2043150) gates on
+    // toolResult.resultType === "success", then does n.toolResultJson && CSr(e.toolResult,
+    // n.toolResultJson), where CSr (offset 2032350) is an in-place Object.assign; the mutated
+    // object is re-serialized back to native in the postTool callback at offset 1793926. So
+    // modifiedResult IS honored on this event, and token-goat's rewriteOutput producers
+    // (compression, injection fencing, image shrink) really do reach the model. resultType is
+    // hardcoded 'success' because success is the only branch this event ever runs on.
+    //
+    // additionalContext on THIS event is dropped on the JS path. grep -abo "onAdditionalContext:"
+    // app.js returns nothing, so the callback is never supplied, and the two "onAdditionalContext?"
+    // call sites (offsets 2041896 and 2043300) are both no-ops. preToolsExecution (offset 2041832)
+    // additionally pushes each context into an array that IS drained into the native return
+    // payload (additional_contexts, offset 1791950); postToolExecution has no such push and its
+    // native return payload (offset 1793926) has no additional_contexts key. Residual, stated
+    // honestly: the native hookProcessorPostToolUse might fold additionalContext into the
+    // toolResultJson it returns, and that was NOT verified. The evidence leans against it, since
+    // the failure sibling path appends its context explicitly in JS via
+    // hookAppendPostToolUseFailureContext and there is no success-path counterpart. The
+    // out.additionalContext below is kept as cheap best-effort, not as a channel anything should
+    // depend on -- see src/pending_context.ts, whose whole design depended on it.
+    //
+    // Failed tool calls never reach this event. postToolUse and postToolUseFailure are two
+    // distinct hook events (both listed in the runtime.node hook-event enum at offset 101618150),
+    // and the shipped copilot-sdk/types.d.ts says onPostToolUse "does not fire for non-success
+    // results". The failure event cannot carry a fence either: PostToolUseFailureHookInput carries
+    // only a stringified error message, not the tool result, and PostToolUseFailureHookOutput
+    // consumes only additionalContext -- "modifiedResult or suppressOutput are not honored for
+    // failure hooks". rejected/denied/timeout results trigger no post hook at all. So on Copilot,
+    // the output of a failed tool call reaches the model unfenced, uncompressed and unshrunk, and
+    // no response shape this shim could emit changes that. That gap is real and still open. What
+    // is now wired is the narrower thing that IS possible there: the postToolUseFailure branch
+    // below carries advisory text alongside the failure, and never rewrites it.
+    //
+    // Emitted camelCase-only. The inbound side around line 247 also tolerates a snake_case "VS
+    // Code compatible" shape, and this comment used to justify the camelCase choice by claiming
+    // PascalCase event registration selects the snake_case response format. That reasoning is
+    // UNVERIFIED in 1.0.80: every hook-response field in the native string tables is camelCase,
+    // and the snake_case hits in the bundle are unrelated internal Rust identifiers. camelCase
+    // stays because it is what the bundle reads; the old justification is no longer asserted.
     const hso = resp && resp.hookSpecificOutput
     const updatedToolOutput = hso && hso.updatedToolOutput
     const context = extractContext(resp)
@@ -4995,6 +5330,25 @@ function translate(copilotEvent, resp) {
     return out
   }
 
+  if (copilotEvent === 'postToolUseFailure') {
+    // The failed-tool twin of postToolUse, and the only response field it accepts is
+    // additionalContext: the shipped copilot-sdk/types.d.ts says "modifiedResult or suppressOutput
+    // are not honored for failure hooks", so nothing here can fence, compress or shrink the failed
+    // output -- that gap is real and stays open. What is NOT open, and was the reason this event
+    // went unwired for so long, is whether additionalContext reaches the model at all. It does:
+    // app.js 1.0.80 at offset 2043380 either folds it into textResultForLlm (when
+    // appendFailureContextToToolResult is set) or has the native
+    // hookAppendPostToolUseFailureContext push {content, source:'system'} onto
+    // toolResult.newMessages. That is the exact opposite of postToolUse, whose additionalContext
+    // the JS side drops on the floor, so neither event's behaviour generalises to the other.
+    //
+    // Because this channel spends tokens rather than saving them, the handler behind it
+    // (hooks_tool_failure.ts) is silent on a first failure and speaks only on an exact repeat.
+    const context = extractContext(resp)
+    if (context) return { additionalContext: context }
+    return {}
+  }
+
   if (copilotEvent === 'sessionStart') {
     // sessionStart has no tool result to modify -- only additionalContext applies, and it's the
     // one channel that reaches the model before it picks its first read tool, so this is where
@@ -5018,12 +5372,47 @@ function translate(copilotEvent, resp) {
     return { decision: 'allow' }
   }
 
-  // preCompact / userPromptSubmitted: confirmed against the hooks reference
-  // doc that both are notification-only -- Copilot never reads a response
-  // body for either, so any additionalContext/systemMessage token-goat
-  // produces has no surfacing channel here. This still routes through the
-  // token-goat hook call above so the internal handler's own side effects keep
-  // running; only the response is discarded.
+  if (copilotEvent === 'userPromptSubmitted') {
+    // Copilot's own hooks reference says command-hook output here "is dropped, including
+    // modifiedPrompt", and this branch used to believe it and return nothing. That is wrong for
+    // additionalContext on 1.0.80, established by experiment rather than by reading: a config-file
+    // command hook (at <cwd>/.github/hooks/, the project scope -- the user scope ~/.copilot/hooks/
+    // was never exercised) returned {"additionalContext":"<marker>"} and the marker turned up
+    // verbatim inside the session's user.message.transformedContent, wrapped in a
+    // <system_reminder> block. What settles that it reached the model rather than only the on-disk
+    // record is the billing: the provider's returned usage charged ~140 input tokens for a turn
+    // whose raw content field is 35 bytes, so the marker's bytes were paid for whichever field
+    // carried them. (The weaker argument first offered for this -- that transformedContent carries
+    // an envelope the content field lacks, 29 B vs 195 B -- was measured on the control turn that
+    // had no marker in it, and proves nothing about the marker.) That the model sees it is the
+    // whole point: hook.start/hook.end records also persist and reach nothing.
+    //
+    // Scope of the finding, stated honestly: demonstrated ONCE on 1.0.80, not shown to be
+    // reliable. Of two turns in that experiment, one delivered the marker and one fired a
+    // userPromptSubmitted hook that produced no output and never ran the script; no explanation
+    // was established and the rate is unknown. A hint that silently fails to arrive costs nothing
+    // and breaks nothing here, which is why the direct return is still the right default.
+    //
+    // modifiedPrompt is NOT claimed to work and is not wanted: rewriting a user's prompt is far
+    // more invasive than anything token-goat does, so only additionalContext is forwarded.
+    //
+    // This is also the write end of any post-compaction channel. Copilot has no postCompact hook.
+    // Whether the summary is recoverable from events.jsonl is NOT settled -- the emit()/
+    // emitEphemeral() distinction does not gate the writer, and the real decision is in native
+    // code; see COPILOT_NO_POST_COMPACT_REASON in ../bridges_status.ts for what was and was not
+    // established. The read end that IS confirmed is preCompact, which fires as a notification, so
+    // a manifest can be built there and drained here without reading the event log at all.
+    const context = extractContext(resp)
+    if (context) return { additionalContext: context }
+    return {}
+  }
+
+  // preCompact is the genuine notification-only case, and the contrast with userPromptSubmitted
+  // above is why this fallthrough is worth a comment at all. The hooks reference marks it
+  // "No -- notification only" for output processing, and unlike the additionalContext claim that
+  // turned out to be false, this one is confirmed in the shipping bundle: both preCompact call
+  // sites in app.js (1.0.79 and re-checked in 1.0.80) await the hook and never assign its result.
+  // There is no field to aim at here, so nothing to reconsider on the next version bump.
   return {}
 }
 
@@ -5065,7 +5454,8 @@ var COPILOT_CLI_HOOK_EVENTS = [
   "preCompact",
   "agentStop",
   "subagentStop",
-  "userPromptSubmitted"
+  "userPromptSubmitted",
+  "postToolUseFailure"
 ];
 function copilotCliUserRoot() {
   const override = process.env["COPILOT_HOME"];
@@ -5078,6 +5468,23 @@ function copilotCliUserHooksDir() {
 function copilotCliProjectHooksDir() {
   return path5.join(process.cwd(), ".github", "hooks");
 }
+function copilotCliCacheRoot() {
+  const override = process.env["COPILOT_CACHE_HOME"];
+  if (override !== void 0 && override.trim() !== "") return path5.resolve(override);
+  const home = os3.homedir();
+  if (process.platform === "darwin") return path5.join(home, "Library", "Caches", "copilot");
+  if (process.platform === "win32") {
+    const local = process.env["LOCALAPPDATA"];
+    const base2 = local !== void 0 && local.trim() !== "" ? local : path5.join(home, ".cache");
+    return path5.join(base2, "copilot");
+  }
+  const xdg = process.env["XDG_CACHE_HOME"];
+  const base = xdg !== void 0 && xdg.trim() !== "" ? xdg : path5.join(home, ".cache");
+  return path5.join(base, "copilot");
+}
+function copilotCliMcpToolsDir() {
+  return path5.join(copilotCliCacheRoot(), "mcp-tools");
+}
 function copilotCliHooksDir(opts = {}) {
   return opts.local === true ? copilotCliProjectHooksDir() : copilotCliUserHooksDir();
 }
@@ -6006,11 +6413,15 @@ function sessionFileStem(sessionId) {
   return `${saltedStemPrefix(sessionId.slice(0, sep))}${digest}`;
 }
 function sessionPath(sessionId) {
+  return sessionSidecarPath(sessionId, ".json");
+}
+function sessionSidecarPath(sessionId, suffix) {
   if (!sessionId) return null;
   const safe = sessionFileStem(sessionId);
   if (!safe) return null;
+  if (suffix.includes("/") || suffix.includes("\\") || suffix.includes("..")) return null;
   const dir = path10.join(tokenGoatHome(), SESSIONS_SUBDIR);
-  const candidate = path10.join(dir, `${safe}.json`);
+  const candidate = path10.join(dir, `${safe}${suffix}`);
   try {
     const rel = path10.relative(dir, candidate);
     if (rel.startsWith("..")) return null;
@@ -6099,6 +6510,7 @@ function coerce(raw) {
   ) : [];
   const cliReads = Array.isArray(o["cliReads"]) ? o["cliReads"].filter((h) => typeof h === "string") : [];
   const bashReruns = Array.isArray(o["bashReruns"]) ? o["bashReruns"].filter((h) => typeof h === "string") : [];
+  const seenImageHashes = Array.isArray(o["seenImageHashes"]) ? o["seenImageHashes"].filter((h) => typeof h === "string") : [];
   const pendingLargeFileHints = Array.isArray(o["pendingLargeFileHints"]) ? o["pendingLargeFileHints"].filter(
     (p) => Array.isArray(p) && p.length === 2 && typeof p[0] === "string" && typeof p[1] === "number"
   ) : [];
@@ -6126,6 +6538,7 @@ function coerce(raw) {
     globQueries,
     outstandingAgentSpawns,
     ...typeof o["lastTabContext"] === "string" ? { lastTabContext: o["lastTabContext"] } : {},
+    ...seenImageHashes.length > 0 ? { seenImageHashes } : {},
     ...typeof o["compactedAt"] === "number" ? { compactedAt: o["compactedAt"] } : {},
     ...typeof o["created_ts"] === "number" ? { created_ts: o["created_ts"] } : {}
   };
@@ -6233,12 +6646,21 @@ function mergeSessionState(disk, mem) {
     grepQueries: mergePairs(disk.grepQueries ?? [], mem.grepQueries ?? []),
     globQueries: mergePairs(disk.globQueries ?? [], mem.globQueries ?? []),
     outstandingAgentSpawns: mergeOutstandingAgentSpawns(disk.outstandingAgentSpawns ?? [], mem.outstandingAgentSpawns ?? []),
+    // An accumulating collection, so union rather than pick a winner: two hook processes can
+    // each see a screenshot the other never did. Disk first, then mem, so the order stays
+    // oldest-to-newest and the cap evicts the oldest -- the same policy recordSeenImage applies
+    // in memory, applied again here because a union of two capped lists can exceed the cap.
+    seenImageHashes: mergeSeenImageHashes(disk.seenImageHashes ?? [], mem.seenImageHashes ?? []),
     // Last-seen scalar, not an accumulating collection: prefer mem's value (this process's freshest observation) over disk's, since a newer write always supersedes an older one.
     ...mem.lastTabContext !== void 0 ? { lastTabContext: mem.lastTabContext } : disk.lastTabContext !== void 0 ? { lastTabContext: disk.lastTabContext } : {},
     // Prefer the value already on disk: it marks the original creation time, and must never be bumped forward to the merge's "now". `mem` never carries one (it is not tracked in memory), so this is really "keep whatever disk has".
     ...disk.created_ts !== void 0 ? { created_ts: disk.created_ts } : mem.created_ts !== void 0 ? { created_ts: mem.created_ts } : {}
   };
 }
+function mergeSeenImageHashes(disk, mem) {
+  const merged = Array.from(/* @__PURE__ */ new Set([...disk, ...mem]));
+  return merged.length > MAX_SEEN_IMAGE_HASHES ? merged.slice(merged.length - MAX_SEEN_IMAGE_HASHES) : merged;
+}
 function capFiles(s, max) {
   if (s.files.length <= max) return s;
   const kept = [...s.files].sort((a, b) => b.lastReadAt - a.lastReadAt).slice(0, max);
@@ -7075,6 +7497,19 @@ async function probeImageMeta(input) {
     return null;
   }
 }
+async function imageQualifiesForShrink(input) {
+  if (input.length >= DEFAULT_SIZE_THRESHOLD_BYTES) return true;
+  const sharp = await loadSharp();
+  if (sharp === null) return false;
+  try {
+    const cfg = loadConfig().image_shrink;
+    const limitInputPixels = cfg.max_image_pixels > 0 ? cfg.max_image_pixels : false;
+    const meta = await sharp(input, { limitInputPixels }).metadata();
+    return Math.max(meta.width ?? 0, meta.height ?? 0) > DEFAULT_MAX_DIMENSION;
+  } catch {
+    return false;
+  }
+}
 async function shrinkImage(input, opts) {
   const cfg = loadConfig().image_shrink;
   const maxDimension = opts?.maxDimension ?? DEFAULT_MAX_DIMENSION;
@@ -7196,7 +7631,6 @@ async function preReadImageHandler(event) {
   pruneShrinkCache();
   const stat2 = statInfo(filePath);
   if (stat2 === null) return passOutput();
-  const size = stat2.size;
   const quality = loadConfig().image_shrink.jpeg_quality;
   const cached = findCachedShrink(filePath, stat2.size, stat2.mtimeMs, quality);
   if (cached !== null) {
@@ -7223,34 +7657,13 @@ async function preReadImageHandler(event) {
     } catch {
     }
   }
-  let input = null;
-  let qualifies = size >= DEFAULT_SIZE_THRESHOLD_BYTES;
-  if (!qualifies) {
-    try {
-      input = fs16.readFileSync(filePath);
-    } catch {
-      return passOutput();
-    }
-    const sharp = await loadSharp();
-    if (sharp === null) return passOutput();
-    try {
-      const cfg = loadConfig().image_shrink;
-      const limitInputPixels = cfg.max_image_pixels > 0 ? cfg.max_image_pixels : false;
-      const meta = await sharp(input, { limitInputPixels }).metadata();
-      const longestEdge = Math.max(meta.width ?? 0, meta.height ?? 0);
-      qualifies = longestEdge > DEFAULT_MAX_DIMENSION;
-    } catch {
-      return passOutput();
-    }
-  }
-  if (!qualifies) return passOutput();
-  if (input === null) {
-    try {
-      input = fs16.readFileSync(filePath);
-    } catch {
-      return passOutput();
-    }
+  let input;
+  try {
+    input = fs16.readFileSync(filePath);
+  } catch {
+    return passOutput();
   }
+  if (!await imageQualifiesForShrink(input)) return passOutput();
   const result = await shrinkImage(input, { quality, sizeThresholdBytes: 0 });
   if (result === null) {
     recordStat("image_shrink_skipped");
@@ -7261,30 +7674,432 @@ async function preReadImageHandler(event) {
 }
 registerHook("pre_tool_use", preReadImageHandler, { toolName: "Read" });
 
-// src/embeddings.ts
+// src/embed_model.ts
+import { createHash as createHash4 } from "node:crypto";
+import * as fs17 from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-var _require2 = createRequire3(import.meta.url);
-var _transformer = null;
-var _transformerError = null;
-var _transformerLoadAttempted = false;
-function ensureTransformerLoaded() {
-  if (_transformerLoadAttempted) return;
-  _transformerLoadAttempted = true;
-  try {
-    _transformer = _require2("@xenova/transformers");
-    if (loadConfig().network.offline) {
-      const env = _transformer.env;
-      if (env) env["allowRemoteModels"] = false;
+import * as path13 from "node:path";
+import { pipeline } from "node:stream/promises";
+
+// src/embed_tokenizer.ts
+var MAX_SEQUENCE_TOKENS = 512;
+var UnsupportedTokenizerError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UnsupportedTokenizerError";
+  }
+};
+function fail(message) {
+  throw new UnsupportedTokenizerError(message);
+}
+function asRecord(value, path31) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) fail(`${path31} is not an object`);
+  return value;
+}
+function asString(value, path31) {
+  if (typeof value !== "string") fail(`${path31} is not a string`);
+  return value;
+}
+function asArray2(value, path31) {
+  if (!Array.isArray(value)) fail(`${path31} is not an array`);
+  return value;
+}
+function expectValue(actual, wanted, path31) {
+  if (actual !== wanted) fail(`${path31} is ${JSON.stringify(actual)}, expected ${JSON.stringify(wanted)}`);
+}
+function isChinese(cp) {
+  return cp >= 19968 && cp <= 40959 || cp >= 13312 && cp <= 19903 || cp >= 131072 && cp <= 173791 || cp >= 173824 && cp <= 177983 || cp >= 177984 && cp <= 178207 || cp >= 178208 && cp <= 183983 || cp >= 63744 && cp <= 64255 || cp >= 194560 && cp <= 195103;
+}
+var PUNCTUATION = new RegExp("\\p{P}", "u");
+function isPunctuation(ch) {
+  const cp = ch.codePointAt(0) ?? 0;
+  if (cp >= 33 && cp <= 47 || cp >= 58 && cp <= 64 || cp >= 91 && cp <= 96 || cp >= 123 && cp <= 126) {
+    return true;
+  }
+  return PUNCTUATION.test(ch);
+}
+var CONTROL = new RegExp("\\p{Cc}|\\p{Cf}|\\p{Co}|\\p{Cs}", "u");
+function isControl(ch) {
+  if (ch === "	" || ch === "\n" || ch === "\r") return false;
+  return CONTROL.test(ch);
+}
+var SPACE_SEPARATOR = new RegExp("\\p{Zs}", "u");
+function isWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || SPACE_SEPARATOR.test(ch);
+}
+var COMBINING_MARK = /[\u0300-\u036f]/gu;
+function normalize(text) {
+  let out = "";
+  for (const ch of text) {
+    const cp = ch.codePointAt(0) ?? 0;
+    if (cp === 0 || cp === 65533 || isControl(ch)) continue;
+    if (isWhitespace(ch)) {
+      out += " ";
+      continue;
     }
-  } catch (e) {
-    _transformerError = e instanceof Error ? e : new Error(String(e));
+    if (isChinese(cp)) {
+      out += ` ${ch} `;
+      continue;
+    }
+    out += ch;
   }
+  return out.normalize("NFD").replace(COMBINING_MARK, "").toLowerCase();
+}
+function preTokenize(text) {
+  const words = [];
+  for (const piece of text.split(/\s+/)) {
+    if (!piece) continue;
+    let buf = "";
+    for (const ch of piece) {
+      if (isPunctuation(ch)) {
+        if (buf) {
+          words.push(buf);
+          buf = "";
+        }
+        words.push(ch);
+      } else {
+        buf += ch;
+      }
+    }
+    if (buf) words.push(buf);
+  }
+  return words;
+}
+function readSpec(raw) {
+  const spec = asRecord(raw, "tokenizer.json");
+  const normalizer = asRecord(spec["normalizer"], "normalizer");
+  expectValue(normalizer["type"], "BertNormalizer", "normalizer.type");
+  expectValue(normalizer["clean_text"], true, "normalizer.clean_text");
+  expectValue(normalizer["handle_chinese_chars"], true, "normalizer.handle_chinese_chars");
+  expectValue(normalizer["lowercase"], true, "normalizer.lowercase");
+  const stripAccents = normalizer["strip_accents"];
+  if (stripAccents !== null && stripAccents !== true) {
+    fail(`normalizer.strip_accents is ${JSON.stringify(stripAccents)}, expected null or true`);
+  }
+  expectValue(asRecord(spec["pre_tokenizer"], "pre_tokenizer")["type"], "BertPreTokenizer", "pre_tokenizer.type");
+  const model = asRecord(spec["model"], "model");
+  expectValue(model["type"], "WordPiece", "model.type");
+  expectValue(model["continuing_subword_prefix"], "##", "model.continuing_subword_prefix");
+  const post = asRecord(spec["post_processor"], "post_processor");
+  expectValue(post["type"], "TemplateProcessing", "post_processor.type");
+  const template = asArray2(post["single"], "post_processor.single").map((part) => {
+    const special = asRecord(part, "post_processor.single[]")["SpecialToken"];
+    return special === void 0 ? "A" : asString(asRecord(special, "SpecialToken")["id"], "SpecialToken.id");
+  }).join(" ");
+  if (template !== "[CLS] A [SEP]") fail(`post_processor.single is "${template}", expected "[CLS] A [SEP]"`);
+  const vocab = /* @__PURE__ */ new Map();
+  for (const [token, id] of Object.entries(asRecord(model["vocab"], "model.vocab"))) {
+    if (typeof id !== "number" || !Number.isInteger(id)) fail(`model.vocab["${token}"] is not an integer id`);
+    vocab.set(token, id);
+  }
+  const maxChars = model["max_input_chars_per_word"];
+  if (maxChars !== void 0 && (typeof maxChars !== "number" || !Number.isInteger(maxChars) || maxChars < 1)) {
+    fail("model.max_input_chars_per_word is not a positive integer");
+  }
+  return {
+    vocab,
+    unkToken: asString(model["unk_token"], "model.unk_token"),
+    maxInputCharsPerWord: typeof maxChars === "number" ? maxChars : 100
+  };
 }
+var BertWordPiece = class _BertWordPiece {
+  vocab;
+  maxInputCharsPerWord;
+  clsId;
+  sepId;
+  padId;
+  unkId;
+  /** @param raw the parsed contents of a tokenizer.json. */
+  constructor(raw) {
+    const spec = readSpec(raw);
+    this.vocab = spec.vocab;
+    this.maxInputCharsPerWord = spec.maxInputCharsPerWord;
+    this.clsId = this.requireToken("[CLS]");
+    this.sepId = this.requireToken("[SEP]");
+    this.padId = this.requireToken("[PAD]");
+    this.unkId = this.requireToken(spec.unkToken);
+  }
+  /** Parse and validate in one step, for the common case of reading the file off disk. */
+  static fromJson(json) {
+    let parsed;
+    try {
+      parsed = JSON.parse(json);
+    } catch (err) {
+      throw new UnsupportedTokenizerError(`tokenizer.json is not valid JSON: ${err.message}`);
+    }
+    return new _BertWordPiece(parsed);
+  }
+  requireToken(token) {
+    const id = this.vocab.get(token);
+    if (id === void 0) fail(`model.vocab is missing the ${token} token`);
+    return id;
+  }
+  /** Greedy longest-match-first over one whitespace- and punctuation-free word. */
+  wordToIds(word, into) {
+    if (word.length > this.maxInputCharsPerWord) {
+      into.push(this.unkId);
+      return;
+    }
+    const pieces = [];
+    let start = 0;
+    while (start < word.length) {
+      let end = word.length;
+      let found = -1;
+      while (start < end) {
+        const sub = start === 0 ? word.slice(start, end) : `##${word.slice(start, end)}`;
+        const id = this.vocab.get(sub);
+        if (id !== void 0) {
+          found = id;
+          break;
+        }
+        end--;
+      }
+      if (found === -1) {
+        into.push(this.unkId);
+        return;
+      }
+      pieces.push(found);
+      start = end;
+    }
+    for (const id of pieces) into.push(id);
+  }
+  /**
+   * `[CLS] ... [SEP]`, cut to `maxLength` tokens.
+   *
+   * The cut is taken after the markers are added, not before, which means a sequence long enough to
+   * be truncated ends on an ordinary token and has no [SEP] at all. That is what the reference does
+   * and therefore what the model has been fed all along, so it is deliberate rather than an
+   * oversight: keeping the [SEP] would be the more defensible sequence and a different one, and a
+   * tokenizer whose whole justification is producing identical ids does not get to improve on them.
+   * The oracle carries two cases that reach the limit; both end mid-text.
+   */
+  encode(text, maxLength = MAX_SEQUENCE_TOKENS) {
+    if (!Number.isInteger(maxLength) || maxLength < 2) {
+      throw new RangeError(`maxLength must be an integer >= 2 (both markers), got ${maxLength}`);
+    }
+    const ids = [this.clsId];
+    for (const word of preTokenize(normalize(text))) {
+      this.wordToIds(word, ids);
+      if (ids.length >= maxLength) return ids.slice(0, maxLength);
+    }
+    ids.push(this.sepId);
+    return ids.length > maxLength ? ids.slice(0, maxLength) : ids;
+  }
+};
+
+// src/embed_model.ts
+var _require2 = createRequire3(import.meta.url);
 var DEFAULT_MODEL = "Xenova/bge-small-en-v1.5";
 var DEFAULT_DIM = 384;
 var PINNED_MODEL_REVISION = "ea104dacec62c0de699686887e3f920caeb4f3e3";
+var MODEL_FILES = [
+  {
+    name: "tokenizer.json",
+    sha256: "d241a60d5e8f04cc1b2b3e9ef7a4921b27bf526d9f6050ab90f9267a1f9e5c66",
+    bytes: 711396
+  },
+  {
+    name: "onnx/model_quantized.onnx",
+    sha256: "6c9c6101a956d62dfb5e7190c538226c0c5bb9cb27b651234b6df063ee7dbfe4",
+    bytes: 34014426
+  }
+];
+function modelDir() {
+  return path13.join(dataDir(), "models", ...DEFAULT_MODEL.split("/"), PINNED_MODEL_REVISION);
+}
+function downloadUrl(file) {
+  return `https://huggingface.co/${DEFAULT_MODEL}/resolve/${PINNED_MODEL_REVISION}/${file.name}`;
+}
+var _ort = null;
+var _ortError = null;
+var _ortLoadAttempted = false;
+function ensureRuntimeLoaded() {
+  if (_ortLoadAttempted) return;
+  _ortLoadAttempted = true;
+  try {
+    _ort = _require2("onnxruntime-node");
+  } catch (e) {
+    _ortError = e instanceof Error ? e : new Error(String(e));
+  }
+}
+function isRuntimeAvailable() {
+  ensureRuntimeLoaded();
+  return _ort !== null && _ortError === null;
+}
+function runtimeLoadError() {
+  ensureRuntimeLoaded();
+  return _ortError;
+}
+function runtimeVersion() {
+  ensureRuntimeLoaded();
+  if (_ort === null) return "unknown";
+  try {
+    let dir = path13.dirname(_require2.resolve("onnxruntime-node"));
+    for (let depth = 0; depth < 6; depth++) {
+      const manifest = path13.join(dir, "package.json");
+      if (fs17.existsSync(manifest)) {
+        const parsed = JSON.parse(fs17.readFileSync(manifest, "utf8"));
+        if (parsed.name === "onnxruntime-node" && typeof parsed.version === "string") return parsed.version;
+      }
+      const up = path13.dirname(dir);
+      if (up === dir) break;
+      dir = up;
+    }
+  } catch {
+  }
+  return "unknown";
+}
+function sha256Of(filePath) {
+  return new Promise((resolve10, reject) => {
+    const hash2 = createHash4("sha256");
+    const stream = fs17.createReadStream(filePath);
+    stream.on("error", reject);
+    stream.on("data", (chunk) => hash2.update(chunk));
+    stream.on("end", () => resolve10(hash2.digest("hex")));
+  });
+}
+async function download(file, target) {
+  const url = downloadUrl(file);
+  const response = await fetch(url, { redirect: "follow" });
+  if (!response.ok) throw new Error(`GET ${url} returned ${response.status} ${response.statusText}`);
+  if (!response.body) throw new Error(`GET ${url} returned no body`);
+  const temp = `${target}.${process.pid}.partial`;
+  const hash2 = createHash4("sha256");
+  let written = 0;
+  const out = fs17.createWriteStream(temp);
+  try {
+    await pipeline(async function* () {
+      for await (const chunk of response.body) {
+        written += chunk.byteLength;
+        if (written > file.bytes) throw new Error(`${file.name} is longer than the pinned ${file.bytes} bytes`);
+        hash2.update(chunk);
+        yield chunk;
+      }
+    }, out);
+    if (written !== file.bytes) {
+      throw new Error(`${file.name} is ${written} bytes, expected the pinned ${file.bytes}`);
+    }
+    const digest = hash2.digest("hex");
+    if (digest !== file.sha256) {
+      throw new Error(`${file.name} has sha256 ${digest}, expected the pinned ${file.sha256}`);
+    }
+    fs17.renameSync(temp, target);
+  } catch (e) {
+    await new Promise((resolve10) => {
+      if (out.closed) resolve10();
+      else out.once("close", () => resolve10());
+    });
+    try {
+      fs17.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
+    } catch {
+    }
+    throw e;
+  }
+}
+async function ensureModelFiles(modelName = DEFAULT_MODEL) {
+  if (modelName !== DEFAULT_MODEL) {
+    throw new Error(
+      `Only ${DEFAULT_MODEL} is supported: its files are pinned to a revision and to a sha256 each, and "${modelName}" has neither, so there would be nothing to check the download against.`
+    );
+  }
+  ensureDataDirPrivate();
+  const dir = modelDir();
+  const offline = loadConfig().network.offline;
+  for (const file of MODEL_FILES) {
+    const target = path13.join(dir, file.name);
+    if (fs17.existsSync(target)) {
+      const digest = await sha256Of(target);
+      if (digest === file.sha256) continue;
+      fs17.rmSync(target, { force: true });
+    }
+    if (offline) {
+      throw new Error(
+        `Offline mode is on (network.offline): refusing to download ${file.name} for the embedding model. Copy the pinned files into ${dir} on a connected machine to use semantic search here.`
+      );
+    }
+    fs17.mkdirSync(path13.dirname(target), { recursive: true });
+    console.warn(
+      `Downloading the embedding model, once (${file.name}, ${Math.round(file.bytes / 1024 / 1024)} MB) into ${dir}`
+    );
+    await download(file, target);
+  }
+  return dir;
+}
+function poolAndNormalize(hidden, seq, dim) {
+  const pooled = new Float64Array(dim);
+  for (let t = 0; t < seq; t++) {
+    const base = t * dim;
+    for (let d = 0; d < dim; d++) pooled[d] = (pooled[d] ?? 0) + (hidden[base + d] ?? 0);
+  }
+  let sumOfSquares = 0;
+  for (let d = 0; d < dim; d++) {
+    const mean = (pooled[d] ?? 0) / seq;
+    pooled[d] = mean;
+    sumOfSquares += mean * mean;
+  }
+  const norm = Math.sqrt(sumOfSquares);
+  const out = new Float32Array(dim);
+  if (norm === 0 || !Number.isFinite(norm)) return out;
+  for (let d = 0; d < dim; d++) out[d] = (pooled[d] ?? 0) / norm;
+  return out;
+}
+var EmbeddingModel = class _EmbeddingModel {
+  constructor(tokenizer, session, tensorFactory) {
+    this.tokenizer = tokenizer;
+    this.session = session;
+    this.tensorFactory = tensorFactory;
+  }
+  tokenizer;
+  session;
+  tensorFactory;
+  static async load(modelName = DEFAULT_MODEL) {
+    if (!isRuntimeAvailable()) {
+      throw new Error(`onnxruntime-node is not available: ${_ortError?.message ?? "unknown error"}`);
+    }
+    const dir = await ensureModelFiles(modelName);
+    const tokenizer = BertWordPiece.fromJson(fs17.readFileSync(path13.join(dir, "tokenizer.json"), "utf8"));
+    const ort = _ort;
+    const session = await ort.InferenceSession.create(path13.join(dir, "onnx", "model_quantized.onnx"));
+    return new _EmbeddingModel(tokenizer, session, ort.Tensor);
+  }
+  /** Embed one text. Sequences are run singly, so there is no padding and no mask to get wrong. */
+  async embed(text) {
+    const ids = this.tokenizer.encode(text);
+    const length = ids.length;
+    const feeds = {
+      input_ids: new this.tensorFactory("int64", BigInt64Array.from(ids, BigInt), [1, length]),
+      attention_mask: new this.tensorFactory("int64", new BigInt64Array(length).fill(1n), [1, length])
+    };
+    if (this.session.inputNames.includes("token_type_ids")) {
+      feeds["token_type_ids"] = new this.tensorFactory("int64", new BigInt64Array(length), [1, length]);
+    }
+    const outputName = this.session.outputNames[0];
+    if (outputName === void 0) throw new Error("the model declares no outputs");
+    const output = (await this.session.run(feeds))[outputName];
+    if (!output) throw new Error(`the model produced no ${outputName}`);
+    const [, seq, dim] = output.dims;
+    if (seq === void 0 || dim === void 0) {
+      throw new Error(`expected a [batch, sequence, dimension] output, got [${output.dims.join(", ")}]`);
+    }
+    if (dim !== DEFAULT_DIM) {
+      throw new Error(`the model produced ${dim}-dimension vectors, expected ${DEFAULT_DIM}`);
+    }
+    return poolAndNormalize(output.data, seq, dim);
+  }
+};
+registerReset(() => {
+  _ort = null;
+  _ortError = null;
+  _ortLoadAttempted = false;
+});
+
+// src/embeddings.ts
 var QUERY_INSTRUCTION_PREFIX = "Represent this sentence for searching relevant passages: ";
 var _extractorCache = /* @__PURE__ */ new Map();
+var inHousePipelineFn = async (_task, modelName) => {
+  const model = await EmbeddingModel.load(modelName);
+  return async (text) => ({ data: await model.embed(text) });
+};
 var _pipelineFnOverride = null;
 registerReset(() => {
   _extractorCache.clear();
@@ -7303,8 +8118,7 @@ async function buildExtractorWithRetry(pipelineFn, modelName) {
   let lastError;
   for (let attempt = 1; attempt <= PIPELINE_RETRY_ATTEMPTS; attempt++) {
     try {
-      const pipelineOptions = modelName === DEFAULT_MODEL ? { revision: PINNED_MODEL_REVISION } : void 0;
-      return await pipelineFn("feature-extraction", modelName, pipelineOptions);
+      return await pipelineFn("feature-extraction", modelName);
     } catch (e) {
       lastError = e;
       if (attempt < PIPELINE_RETRY_ATTEMPTS) await sleep(PIPELINE_RETRY_DELAY_MS * attempt);
@@ -7356,25 +8170,23 @@ var _MIN_TOKEN_LEN = 3;
 var OVER_FETCH_FACTOR = 4;
 var MAX_OVER_FETCH = 100;
 function isAvailable() {
-  ensureTransformerLoaded();
-  return _transformer !== null && _transformerError === null;
+  return isRuntimeAvailable();
+}
+function embeddingBackendLoadError() {
+  return runtimeLoadError();
 }
 async function embedTexts(texts, modelName = DEFAULT_MODEL) {
   if (!isAvailable()) {
     throw new Error(
-      `Transformer not available: ${_transformerError?.message ?? "unknown error"}`
+      `Embedding backend not available: ${runtimeLoadError()?.message ?? "unknown error"}`
     );
   }
   if (texts.length === 0) {
     return [];
   }
-  if (!_transformer || typeof _transformer !== "object") {
-    throw new Error("Transformer module is unavailable");
-  }
   let extractorPromise = _extractorCache.get(modelName);
   if (!extractorPromise) {
-    const transformerObj = _transformer;
-    const pipelineFn = _pipelineFnOverride ?? transformerObj["pipeline"];
+    const pipelineFn = _pipelineFnOverride ?? inHousePipelineFn;
     extractorPromise = buildExtractorWithRetry(pipelineFn, modelName);
     _extractorCache.set(modelName, extractorPromise);
     extractorPromise.catch(() => {
@@ -7586,6 +8398,7 @@ async function upsertChunks(db, chunks) {
     deleteFileEmbeddings(db, filePath);
     return "unavailable";
   }
+  ensureEmbeddingProvenance(db);
   const texts = chunks.map((c) => c.text);
   const embeddings = await embedTexts(texts);
   const chunkInsertStmt = db.prepare(`
@@ -7656,7 +8469,6 @@ function fetchScopedHits(db, queryVec, k, maxDistance, rootDir) {
 }
 async function searchSemantic(db, query, topK = 8, modelName = DEFAULT_MODEL, maxDistance = DEFAULT_DISTANCE_THRESHOLD, rootDir) {
   if (!isAvailable()) {
-    console.warn("Embeddings not available; semantic search disabled");
     return [];
   }
   if (query.trim().length === 0) {
@@ -7665,6 +8477,7 @@ async function searchSemantic(db, query, topK = 8, modelName = DEFAULT_MODEL, ma
   if (!chunkVectorsTableExists(db)) {
     return [];
   }
+  ensureEmbeddingProvenance(db, modelName);
   const queryEmbeddings = await embedTexts([`${QUERY_INSTRUCTION_PREFIX}${query}`], modelName);
   if (queryEmbeddings.length === 0) {
     return [];
@@ -7813,6 +8626,44 @@ function deleteFileEmbeddings(db, filePath) {
   }
   db.prepare(`DELETE FROM chunks WHERE ${pathEqClause("file_path")}`).run(folded);
 }
+function resetAllEmbeddings(db) {
+  const paths = db.prepare("SELECT DISTINCT file_path FROM chunks").pluck().all();
+  const clearEmbedSha = db.prepare(`UPDATE files SET embed_sha = NULL WHERE ${pathEqClause("path")}`);
+  const tx = db.transaction(() => {
+    for (const p of paths) deleteFileEmbeddings(db, p);
+    for (const p of paths) clearEmbedSha.run(foldPath(p));
+  });
+  tx.immediate();
+  return paths.length;
+}
+function embeddingProvenance(modelName = DEFAULT_MODEL) {
+  const revision = modelName === DEFAULT_MODEL ? PINNED_MODEL_REVISION.slice(0, 12) : "unpinned";
+  return `${modelName}@${revision}/${backendId()}`;
+}
+function backendId() {
+  return `onnxruntime-node@${majorMinor(runtimeVersion())}`;
+}
+function majorMinor(version) {
+  const parts = version.split(".");
+  return parts.length >= 2 ? `${parts[0]}.${parts[1]}` : version;
+}
+var _provenanceChecked = /* @__PURE__ */ new WeakSet();
+function ensureEmbeddingProvenance(db, modelName = DEFAULT_MODEL) {
+  if (_provenanceChecked.has(db)) return;
+  _provenanceChecked.add(db);
+  const current = embeddingProvenance(modelName);
+  const stored = db.prepare("SELECT provenance FROM embedding_provenance WHERE id = 1").pluck().get();
+  if (stored === current) return;
+  const cleared = resetAllEmbeddings(db);
+  db.prepare(
+    "INSERT INTO embedding_provenance (id, provenance) VALUES (1, ?) ON CONFLICT(id) DO UPDATE SET provenance = excluded.provenance"
+  ).run(current);
+  if (cleared > 0) {
+    console.warn(
+      `Embedding stack changed (${stored ?? "unrecorded"} -> ${current}); discarded ${cleared} file${cleared === 1 ? "" : "s"} worth of vectors because old and new ones are not comparable. Run \`token-goat index\` to rebuild them.`
+    );
+  }
+}
 function _extractQueryTokens(query) {
   const tokens = /* @__PURE__ */ new Set();
   const matches = query.matchAll(_TOKEN_RE);
@@ -7849,17 +8700,19 @@ function _pathPriorityPenalty(filePath) {
 }
 
 // src/hooks_read.ts
-import * as fs22 from "node:fs";
-import * as path18 from "node:path";
+import * as fs23 from "node:fs";
+import * as path19 from "node:path";
 
 // src/compact.ts
-import * as fs17 from "node:fs";
-import * as path13 from "node:path";
+import * as fs18 from "node:fs";
+import * as path14 from "node:path";
 
 // src/overflow_guard.ts
+function estimateTokensFromLength(length) {
+  return Math.max(1, Math.floor(Math.max(0, length) / 3) + 1);
+}
 function estimateTokens(text) {
-  const stripped = stripAnsiCodes(text);
-  return Math.max(1, Math.floor(stripped.length / 3) + 1);
+  return estimateTokensFromLength(stripAnsiCodes(text).length);
 }
 function trimToBudget(text, budgetTokens, command) {
   const markerMarginTokens = 64;
@@ -8116,7 +8969,7 @@ function inferSessionGoal(cache, maxTokens = 80) {
     const dirCounts = new Counter();
     for (const fpath of editedPaths) {
       try {
-        let parent = path13.dirname(fpath);
+        let parent = path14.dirname(fpath);
         if (parent === ".") {
           parent = "root";
         } else if (parent.startsWith("./")) {
@@ -8192,11 +9045,11 @@ function isNoisePath(inputPath) {
 }
 function findLatestSessionId() {
   try {
-    const sessionsDir = path13.join(tokenGoatHome(), "sessions");
-    if (!fs17.existsSync(sessionsDir)) {
+    const sessionsDir = path14.join(tokenGoatHome(), "sessions");
+    if (!fs18.existsSync(sessionsDir)) {
       return null;
     }
-    const files = fs17.readdirSync(sessionsDir);
+    const files = fs18.readdirSync(sessionsDir);
     const jsonFiles = files.filter((f) => f.endsWith(".json") && !f.includes(AGENT_SALT_MARKER));
     if (jsonFiles.length === 0) {
       return null;
@@ -8206,9 +9059,9 @@ function findLatestSessionId() {
       return null;
     }
     let latestFile = firstFile;
-    let latestMtime = fs17.statSync(path13.join(sessionsDir, firstFile)).mtimeMs;
+    let latestMtime = fs18.statSync(path14.join(sessionsDir, firstFile)).mtimeMs;
     for (const file of jsonFiles) {
-      const mtime = fs17.statSync(path13.join(sessionsDir, file)).mtimeMs;
+      const mtime = fs18.statSync(path14.join(sessionsDir, file)).mtimeMs;
       if (mtime > latestMtime) {
         latestFile = file;
         latestMtime = mtime;
@@ -8230,37 +9083,37 @@ function eventCount(cache) {
 function writeSessionManifest(projectHash, sessionId, manifestJson) {
   const safeSessionId = sanitizeIdForFilename(sessionId, 64);
   if (!safeSessionId) return;
-  const sessionsDir = path13.join(dataDir(), "projects", projectHash, "sessions");
-  if (!fs17.existsSync(sessionsDir)) {
+  const sessionsDir = path14.join(dataDir(), "projects", projectHash, "sessions");
+  if (!fs18.existsSync(sessionsDir)) {
     ensureDirSync(sessionsDir);
   }
-  const dest = path13.join(sessionsDir, `${safeSessionId}.json`);
+  const dest = path14.join(sessionsDir, `${safeSessionId}.json`);
   atomicWriteText(dest, JSON.stringify(manifestJson));
 }
 function readAllSessionManifests(projectHash, maxAgeSecs = 3600) {
-  const sessionsDir = path13.join(dataDir(), "projects", projectHash, "sessions");
-  if (!fs17.existsSync(sessionsDir)) {
+  const sessionsDir = path14.join(dataDir(), "projects", projectHash, "sessions");
+  if (!fs18.existsSync(sessionsDir)) {
     return [];
   }
   const now = Date.now() / 1e3;
   const results = [];
   try {
-    const files = fs17.readdirSync(sessionsDir);
+    const files = fs18.readdirSync(sessionsDir);
     for (const file of files) {
       if (!file.endsWith(".json")) {
         continue;
       }
       try {
-        const fullPath = path13.join(sessionsDir, file);
-        const stat2 = fs17.statSync(fullPath);
+        const fullPath = path14.join(sessionsDir, file);
+        const stat2 = fs18.statSync(fullPath);
         if (now - stat2.mtimeMs / 1e3 > maxAgeSecs) {
           try {
-            fs17.unlinkSync(fullPath);
+            fs18.unlinkSync(fullPath);
           } catch {
           }
           continue;
         }
-        const text = fs17.readFileSync(fullPath, "utf8");
+        const text = fs18.readFileSync(fullPath, "utf8");
         const data = JSON.parse(text);
         if (typeof data === "object" && data !== null && "files" in data) {
           results.push(data);
@@ -8431,8 +9284,8 @@ function buildManifestWithCount(sessionId, opts) {
 }
 
 // src/snapshots.ts
-import * as fs18 from "node:fs";
-import * as path14 from "node:path";
+import * as fs19 from "node:fs";
+import * as path15 from "node:path";
 var MAX_SNAPSHOTS_PER_SESSION = 150;
 var MAX_SNAPSHOT_BYTES = 256 * 1024;
 var SNAPSHOT_TRUNCATE_BYTES = 50 * 1024;
@@ -8442,10 +9295,10 @@ var VALID_KINDS = /* @__PURE__ */ new Set([KIND_READ, KIND_PREDICTIVE]);
 function sessionDir(sessionId) {
   if (!sessionId) return null;
   const safe = sanitizeIdForFilename(sessionId, 64, "anon");
-  const base = path14.join(tokenGoatHome(), "session_snapshots");
-  const candidate = path14.join(base, safe);
+  const base = path15.join(tokenGoatHome(), "session_snapshots");
+  const candidate = path15.join(base, safe);
   try {
-    const rel = path14.relative(base, candidate);
+    const rel = path15.relative(base, candidate);
     if (rel.startsWith("..")) return null;
   } catch {
     return null;
@@ -8458,7 +9311,7 @@ function pathKey(filePath) {
 function snapshot_path(sessionId, filePath) {
   const d = sessionDir(sessionId);
   if (!d) return null;
-  return path14.join(d, `${pathKey(filePath)}.bin`);
+  return path15.join(d, `${pathKey(filePath)}.bin`);
 }
 function kindSidecarPath(snapshotPath) {
   return snapshotPath + ".kind";
@@ -8466,11 +9319,11 @@ function kindSidecarPath(snapshotPath) {
 function writeSnapshotKind(sidecarPath, kind) {
   try {
     const safeKind = VALID_KINDS.has(kind) ? kind : KIND_READ;
-    const dir = path14.dirname(sidecarPath);
-    if (!fs18.existsSync(dir)) {
+    const dir = path15.dirname(sidecarPath);
+    if (!fs19.existsSync(dir)) {
       ensureDirSync(dir);
     }
-    fs18.writeFileSync(sidecarPath, safeKind, "utf8");
+    fs19.writeFileSync(sidecarPath, safeKind, "utf8");
     return true;
   } catch {
     return false;
@@ -8479,12 +9332,12 @@ function writeSnapshotKind(sidecarPath, kind) {
 function evictOldest(d, maxCount) {
   try {
     const entries = [];
-    const files = fs18.readdirSync(d);
+    const files = fs19.readdirSync(d);
     for (const file of files) {
-      const fullPath = path14.join(d, file);
+      const fullPath = path15.join(d, file);
       if (!file.endsWith(".bin")) continue;
       try {
-        const stat2 = fs18.statSync(fullPath);
+        const stat2 = fs19.statSync(fullPath);
         entries.push([fullPath, stat2.mtimeMs]);
       } catch {
         continue;
@@ -8496,10 +9349,10 @@ function evictOldest(d, maxCount) {
     const over = entries.length - maxCount;
     for (const [p] of entries.slice(0, over)) {
       try {
-        fs18.unlinkSync(p);
+        fs19.unlinkSync(p);
         removed++;
         try {
-          fs18.unlinkSync(kindSidecarPath(p));
+          fs19.unlinkSync(kindSidecarPath(p));
         } catch {
         }
       } catch {
@@ -8528,10 +9381,10 @@ function store(sessionId, filePath, content, opts = {}) {
   if (!p) return null;
   const sha = fingerprintContent(stored);
   try {
-    const isNewEntry = !fs18.existsSync(p);
+    const isNewEntry = !fs19.existsSync(p);
     if (!isNewEntry) {
       try {
-        const existing = fs18.readFileSync(p);
+        const existing = fs19.readFileSync(p);
         if (Buffer.from(existing).equals(stored)) {
           return {
             path: p,
@@ -8542,8 +9395,8 @@ function store(sessionId, filePath, content, opts = {}) {
       } catch {
       }
     }
-    const dir = path14.dirname(p);
-    if (!fs18.existsSync(dir)) {
+    const dir = path15.dirname(p);
+    if (!fs19.existsSync(dir)) {
       ensureDirSync(dir);
     }
     if (isNewEntry) {
@@ -8563,9 +9416,9 @@ function store(sessionId, filePath, content, opts = {}) {
 }
 function load(sessionId, filePath, opts = {}) {
   const p = snapshot_path(sessionId, filePath);
-  if (!p || !fs18.existsSync(p)) return null;
+  if (!p || !fs19.existsSync(p)) return null;
   try {
-    const stat2 = fs18.statSync(p);
+    const stat2 = fs19.statSync(p);
     if (stat2.size > MAX_SNAPSHOT_BYTES) {
       return null;
     }
@@ -8573,7 +9426,7 @@ function load(sessionId, filePath, opts = {}) {
     return null;
   }
   try {
-    const data = fs18.readFileSync(p);
+    const data = fs19.readFileSync(p);
     if (opts.expected_sha) {
       const actualSha = fingerprintContent(data);
       if (actualSha.toLowerCase() !== opts.expected_sha.toLowerCase()) {
@@ -8586,31 +9439,31 @@ function load(sessionId, filePath, opts = {}) {
   }
 }
 function removeEligibleSnapshotFile(fullPath, file, cutoff) {
-  const stat2 = fs18.lstatSync(fullPath);
+  const stat2 = fs19.lstatSync(fullPath);
   if ((stat2.mode & 61440) === 40960) return false;
   if (cutoff !== void 0 && stat2.mtimeMs >= cutoff) return false;
-  fs18.unlinkSync(fullPath);
+  fs19.unlinkSync(fullPath);
   return file.endsWith(".bin");
 }
 function cleanup_stale(maxAgeHours = 24) {
-  const base = path14.join(tokenGoatHome(), "session_snapshots");
-  if (!fs18.existsSync(base)) return 0;
+  const base = path15.join(tokenGoatHome(), "session_snapshots");
+  if (!fs19.existsSync(base)) return 0;
   const cutoff = Date.now() - maxAgeHours * 3600 * 1e3;
   let removed = 0;
   try {
-    const sessionDirs = fs18.readdirSync(base);
+    const sessionDirs = fs19.readdirSync(base);
     for (const sessionDir2 of sessionDirs) {
-      const sessionPath2 = path14.join(base, sessionDir2);
+      const sessionPath2 = path15.join(base, sessionDir2);
       try {
-        const stat2 = fs18.statSync(sessionPath2);
+        const stat2 = fs19.statSync(sessionPath2);
         if (!stat2.isDirectory()) continue;
       } catch {
         continue;
       }
       try {
-        const files = fs18.readdirSync(sessionPath2);
+        const files = fs19.readdirSync(sessionPath2);
         for (const file of files) {
-          const fullPath = path14.join(sessionPath2, file);
+          const fullPath = path15.join(sessionPath2, file);
           try {
             if (removeEligibleSnapshotFile(fullPath, file, cutoff)) removed++;
           } catch {
@@ -8618,7 +9471,7 @@ function cleanup_stale(maxAgeHours = 24) {
           }
         }
         try {
-          fs18.rmdirSync(sessionPath2);
+          fs19.rmdirSync(sessionPath2);
         } catch {
         }
       } catch {
@@ -8654,11 +9507,11 @@ function buildPackageManifestHint(options) {
     return null;
   }
 }
-function _sanitizeHintPath(path30) {
-  if (typeof path30 !== "string") {
+function _sanitizeHintPath(path31) {
+  if (typeof path31 !== "string") {
     return "???";
   }
-  return path30.replace(/[\x00]/g, "").slice(0, 200);
+  return path31.replace(/[\x00]/g, "").slice(0, 200);
 }
 
 // src/hints/lang_patterns.ts
@@ -9286,33 +10139,33 @@ function dispatchFileTypeHandler(filePath, content, contentLengthHint) {
 }
 
 // src/doc_compact.ts
-import * as fs19 from "fs";
-import * as path15 from "path";
+import * as fs20 from "fs";
+import * as path16 from "path";
 var defaultSentencesPerSection = 2;
 var headerPrefix = "<!-- token-goat doc-compact source-hash:";
 var headerRegex = /^<!-- token-goat doc-compact source-hash:(\S+) source:(.+?) -->\r?$/;
 var compactSubdir = "doc_compacts";
 function sourceHash(filePath) {
   try {
-    return fingerprintContent(fs19.readFileSync(filePath));
+    return fingerprintContent(fs20.readFileSync(filePath));
   } catch {
     return "";
   }
 }
 function _compactSlug(absPathStr) {
   const h = fingerprintContent(foldPath(absPathStr)).slice(0, 12);
-  const ext = path15.extname(absPathStr);
-  const stem = path15.basename(absPathStr, ext);
+  const ext = path16.extname(absPathStr);
+  const stem = path16.basename(absPathStr, ext);
   const safeStem = sanitizeIdForFilename(stem, 32);
   return `${h}_${safeStem}`;
 }
 function compactPathFor(sourcePath) {
   const abs = resolveIndexPath(sourcePath);
-  return path15.join(dataDir(), compactSubdir, `${_compactSlug(abs)}.md`);
+  return path16.join(dataDir(), compactSubdir, `${_compactSlug(abs)}.md`);
 }
 function readCompactHeader(compactPath) {
   try {
-    const text = fs19.readFileSync(compactPath, "utf-8");
+    const text = fs20.readFileSync(compactPath, "utf-8");
     const firstLine = text.split("\n")[0] || "";
     const m = firstLine.match(headerRegex);
     if (!m || !m[1] || !m[2]) return null;
@@ -9331,8 +10184,8 @@ function isCompactFresh(compactPath, sourcePath) {
 }
 function markCompactStale(compactPath) {
   try {
-    if (!fs19.existsSync(compactPath)) return false;
-    const text = fs19.readFileSync(compactPath, "utf-8");
+    if (!fs20.existsSync(compactPath)) return false;
+    const text = fs20.readFileSync(compactPath, "utf-8");
     const lines2 = text.split("\n");
     if (!lines2[0]) return false;
     const m = lines2[0].match(headerRegex);
@@ -9347,7 +10200,7 @@ function markCompactStale(compactPath) {
 }
 function readCompactBody(compactPath) {
   try {
-    const text = fs19.readFileSync(compactPath, "utf-8");
+    const text = fs20.readFileSync(compactPath, "utf-8");
     const lines2 = text.split("\n");
     if (lines2.length < 2) return null;
     const body = lines2.slice(1).join("\n").trimStart();
@@ -9357,14 +10210,14 @@ function readCompactBody(compactPath) {
   }
 }
 function writeCompact(compactPath, sourcePath, compactBody, sourceRel) {
-  const srcPath = path15.resolve(sourcePath);
+  const srcPath = path16.resolve(sourcePath);
   const sha = sourceHash(srcPath);
-  const displayRel = sourceRel || path15.basename(srcPath);
+  const displayRel = sourceRel || path16.basename(srcPath);
   const header = `${headerPrefix}${sha} source:${displayRel} -->
 `;
   const fullText = header + compactBody.trimStart();
-  const dir = path15.dirname(compactPath);
-  if (!fs19.existsSync(dir)) {
+  const dir = path16.dirname(compactPath);
+  if (!fs20.existsSync(dir)) {
     ensureDirSync(dir);
   }
   atomicWriteText(compactPath, fullText);
@@ -9488,7 +10341,7 @@ function extractDocCompact(body, heading) {
 }
 function compactDoc(filePath, heading) {
   try {
-    const body = fs19.readFileSync(filePath, "utf-8");
+    const body = fs20.readFileSync(filePath, "utf-8");
     const compact = extractDocCompact(body, heading);
     return compact || null;
   } catch {
@@ -9498,21 +10351,21 @@ function compactDoc(filePath, heading) {
 
 // src/evidence_cache.ts
 import crypto2 from "node:crypto";
-import fs20 from "node:fs";
-import path16 from "node:path";
+import fs21 from "node:fs";
+import path17 from "node:path";
 var MAX_ENTRIES = 500;
 var MAX_TEXT_BYTES = 128 * 1024;
 var MAX_SEMANTIC_CANDIDATES = 100;
 var CACHE_FILE = "workspace-evidence.json";
 function cachePath() {
-  return path16.join(dataDir(), CACHE_FILE);
+  return path17.join(dataDir(), CACHE_FILE);
 }
 function hash(text) {
   return crypto2.createHash("sha256").update(text).digest("hex");
 }
 function load2() {
   try {
-    const parsed = JSON.parse(fs20.readFileSync(cachePath(), "utf8"));
+    const parsed = JSON.parse(fs21.readFileSync(cachePath(), "utf8"));
     if (!Array.isArray(parsed)) return [];
     return parsed.filter(
       (entry) => typeof entry === "object" && entry !== null && typeof entry.id === "string" && typeof entry.projectRoot === "string" && typeof entry.source === "string" && (entry.representation === "file" || entry.representation === "tool-output") && typeof entry.contentHash === "string" && typeof entry.text === "string" && typeof entry.createdAt === "number" && (entry.embedding === void 0 || typeof entry.embedding === "string")
@@ -9524,7 +10377,7 @@ function load2() {
 function save(entries) {
   try {
     ensureDirSync(dataDir());
-    fs20.writeFileSync(cachePath(), JSON.stringify(entries.slice(0, MAX_ENTRIES)), "utf8");
+    fs21.writeFileSync(cachePath(), JSON.stringify(entries.slice(0, MAX_ENTRIES)), "utf8");
   } catch {
   }
 }
@@ -9615,7 +10468,7 @@ function buildDeltaCapsule(projectRoot, limit = 8) {
   const root = normalizePath(projectRoot);
   const changed = load2().filter((entry) => entry.projectRoot === root && entry.representation === "file").filter((entry) => {
     try {
-      return hash(fs20.readFileSync(entry.source, "utf8")) !== entry.contentHash;
+      return hash(fs21.readFileSync(entry.source, "utf8")) !== entry.contentHash;
     } catch {
       return true;
     }
@@ -9626,8 +10479,8 @@ ${changed.map((entry) => `- ${entry.source} (use a fresh surgical read)`).join("
 }
 
 // src/notebook_compact.ts
-import * as fs21 from "node:fs";
-import * as path17 from "node:path";
+import * as fs22 from "node:fs";
+import * as path18 from "node:path";
 var NB_STRIP_MIN_SAVINGS = 4096;
 function stripNotebook(nbDict) {
   const cells = [];
@@ -9647,23 +10500,23 @@ function stripNotebook(nbDict) {
 var SIDECAR_DEFAULT_MAX_COUNT = 200;
 var SIDECAR_DEFAULT_MAX_AGE_MS = 24 * 3600 * 1e3;
 function pruneSidecars(cacheRoot, maxCount = SIDECAR_DEFAULT_MAX_COUNT, maxAgeMs = SIDECAR_DEFAULT_MAX_AGE_MS) {
-  const nbStripDir = path17.join(cacheRoot, "nb_strip");
+  const nbStripDir = path18.join(cacheRoot, "nb_strip");
   let removed = 0;
   try {
-    if (!fs21.existsSync(nbStripDir)) return 0;
+    if (!fs22.existsSync(nbStripDir)) return 0;
     const cutoff = Date.now() - maxAgeMs;
     const kept = [];
-    for (const entry of fs21.readdirSync(nbStripDir)) {
-      const dir = path17.join(nbStripDir, entry);
+    for (const entry of fs22.readdirSync(nbStripDir)) {
+      const dir = path18.join(nbStripDir, entry);
       let mtime;
       try {
-        mtime = fs21.statSync(dir).mtimeMs;
+        mtime = fs22.statSync(dir).mtimeMs;
       } catch {
         continue;
       }
       if (mtime < cutoff) {
         try {
-          fs21.rmSync(dir, { recursive: true, force: true });
+          fs22.rmSync(dir, { recursive: true, force: true });
           removed++;
         } catch {
           continue;
@@ -9676,7 +10529,7 @@ function pruneSidecars(cacheRoot, maxCount = SIDECAR_DEFAULT_MAX_COUNT, maxAgeMs
       kept.sort((a, b) => a[1] - b[1]);
       for (const [dir] of kept.slice(0, kept.length - maxCount)) {
         try {
-          fs21.rmSync(dir, { recursive: true, force: true });
+          fs22.rmSync(dir, { recursive: true, force: true });
           removed++;
         } catch {
           continue;
@@ -9690,9 +10543,9 @@ function pruneSidecars(cacheRoot, maxCount = SIDECAR_DEFAULT_MAX_COUNT, maxAgeMs
 }
 function getOrCreateSidecar(rawBytes, cacheRoot, opts = {}) {
   const sha = fingerprintContent(rawBytes);
-  const sidecarDir = path17.join(cacheRoot, "nb_strip", sha);
-  const sidecarPath = path17.join(sidecarDir, "stripped.ipynb");
-  if (fs21.existsSync(sidecarPath)) {
+  const sidecarDir = path18.join(cacheRoot, "nb_strip", sha);
+  const sidecarPath = path18.join(sidecarDir, "stripped.ipynb");
+  if (fs22.existsSync(sidecarPath)) {
     return [sidecarPath, false];
   }
   let nb;
@@ -9709,7 +10562,7 @@ function getOrCreateSidecar(rawBytes, cacheRoot, opts = {}) {
   try {
     ensureDirSync(sidecarDir);
   } catch (err) {
-    if (!fs21.existsSync(sidecarDir)) {
+    if (!fs22.existsSync(sidecarDir)) {
       throw err;
     }
   }
@@ -9742,8 +10595,8 @@ function isNodeModulesPath(p) {
   return check.includes("/node_modules/") || check.includes("\\node_modules\\");
 }
 function relPathWithinRoot(root, target) {
-  const rel = path18.relative(root, target).replace(/\\/g, "/");
-  if (rel.startsWith("..") || path18.isAbsolute(rel)) return null;
+  const rel = path19.relative(root, target).replace(/\\/g, "/");
+  if (rel.startsWith("..") || path19.isAbsolute(rel)) return null;
   return rel;
 }
 function _isDocFile(filePath) {
@@ -9774,7 +10627,7 @@ function scanRequestedSlice(absPath, offset, limit) {
   const windowEnd = offset + limit;
   let fd;
   try {
-    fd = fs22.openSync(absPath, "r");
+    fd = fs23.openSync(absPath, "r");
   } catch {
     return null;
   }
@@ -9788,7 +10641,7 @@ function scanRequestedSlice(absPath, offset, limit) {
         const nearSingleLine = lineNumber < NEAR_SINGLE_LINE_SCAN_THRESHOLD;
         return { bytes: sliceBytes, trustworthy: nearSingleLine, nearSingleLine };
       }
-      const bytesRead = fs22.readSync(fd, buf, 0, buf.length, null);
+      const bytesRead = fs23.readSync(fd, buf, 0, buf.length, null);
       if (bytesRead === 0) {
         return {
           bytes: sliceBytes,
@@ -9807,7 +10660,7 @@ function scanRequestedSlice(absPath, offset, limit) {
     }
   } finally {
     try {
-      fs22.closeSync(fd);
+      fs23.closeSync(fd);
     } catch {
     }
   }
@@ -9844,7 +10697,7 @@ var BINARY_FILE_TYPE_EXTS = /* @__PURE__ */ new Set(["pdf", "docx", "xlsx", "ppt
 var TEXT_FILE_TYPE_EXTS = /* @__PURE__ */ new Set(["html", "htm", "xhtml", "txt", "log", "out", "err", "trace", "csv", "tsv", "vtt", "srt"]);
 var DISPATCHED_FILE_TYPE_EXTS = /* @__PURE__ */ new Set([...BINARY_FILE_TYPE_EXTS, ...TEXT_FILE_TYPE_EXTS]);
 function isDispatchedFileType(basename12) {
-  return DISPATCHED_FILE_TYPE_EXTS.has(path18.extname(basename12).slice(1).toLowerCase());
+  return DISPATCHED_FILE_TYPE_EXTS.has(path19.extname(basename12).slice(1).toLowerCase());
 }
 function surgicalHint(filePath, basename12, lineCount) {
   if (lineCount < loadConfig().hints.min_file_lines_for_hint) return "";
@@ -9907,7 +10760,7 @@ function loadSnapshotDiff(sessionId, normalized, basename12) {
   try {
     const sz = statSize(normalized);
     if (sz === null || sz > 256 * 1024) return { kind: "none" };
-    const currentContent = fs22.readFileSync(normalized, "utf8");
+    const currentContent = fs23.readFileSync(normalized, "utf8");
     const TRUNC_MARKER = "\n<snapshot truncated at ";
     const oldRaw = oldSnap.toString("utf8");
     const truncIdx = oldRaw.indexOf(TRUNC_MARKER);
@@ -9993,7 +10846,7 @@ function preReadHandlerInner(event) {
     try {
       const cwd = getCwd(event) ?? process.cwd();
       const project = findProject(cwd) ?? makeProjectAt(cwd);
-      const current = fs22.readFileSync(normalized, "utf8");
+      const current = fs23.readFileSync(normalized, "utf8");
       const evidence = findVerifiedFileEvidence(project.root, normalized, current);
       if (evidence !== null) {
         recordStat("evidence_cache_hit", 0);
@@ -10004,7 +10857,7 @@ function preReadHandlerInner(event) {
     } catch {
     }
   }
-  const basename12 = path18.basename(normalized);
+  const basename12 = path19.basename(normalized);
   if (isLockFile(basename12)) {
     return denyOutput(
       'Lock files are rarely useful to read in full. Use `token-goat section "' + shown + '::<section>"` to extract a specific dependency, or read the relevant manifest instead.'
@@ -10043,7 +10896,7 @@ function preReadHandlerInner(event) {
   const skillName = detectSkillFile(normalized);
   if (skillName && basename12 === "SKILL.md") {
     try {
-      const body = fs22.readFileSync(normalized, "utf-8");
+      const body = fs23.readFileSync(normalized, "utf-8");
       const bodySha = contentHash(body);
       const compact = getCompactAnySessionSync(skillName);
       const stale = isCompactStale(compact, skillName, bodySha);
@@ -10074,9 +10927,9 @@ function preReadHandlerInner(event) {
   const isNotebook = /\.ipynb$/i.test(basename12);
   if (event.toolName !== "Grep" && isNotebook) {
     try {
-      const rawBytes = fs22.readFileSync(normalized);
+      const rawBytes = fs23.readFileSync(normalized);
       const [sidecarPath] = getOrCreateSidecar(rawBytes, dataDir());
-      const sidecarContent = fs22.readFileSync(sidecarPath, "utf-8");
+      const sidecarContent = fs23.readFileSync(sidecarPath, "utf-8");
       const savedBytes = rawBytes.length - sidecarContent.length;
       if (savedBytes >= NB_STRIP_MIN_SAVINGS) {
         recordActualRead(event, normalized);
@@ -10096,7 +10949,7 @@ function preReadHandlerInner(event) {
       const sz = statSize(normalized);
       if (sz !== null && sz >= MARKDOWN_SIZE_THRESHOLD) {
         markdownSize = sz;
-        fileContent = fs22.readFileSync(normalized, "utf8");
+        fileContent = fs23.readFileSync(normalized, "utf8");
       }
     } catch {
     }
@@ -10325,7 +11178,7 @@ function preReadHandlerInner(event) {
       "Note: " + shown + " is large (" + kb + "KB). " + hint + contextPressureAdvisorySuffix()
     );
   }
-  const fileTypeExt = path18.extname(normalized).slice(1).toLowerCase();
+  const fileTypeExt = path19.extname(normalized).slice(1).toLowerCase();
   const fileStatSize = size ?? statSize(normalized) ?? 0;
   const isKnownFileType = DISPATCHED_FILE_TYPE_EXTS.has(fileTypeExt);
   if (event.toolName !== "Grep" && !isImagePath(normalized) && (isKnownFileType || fileStatSize >= FILE_TYPE_THRESHOLDS.generic)) {
@@ -10334,7 +11187,7 @@ function preReadHandlerInner(event) {
     let ftContent = "";
     if (!BINARY_FILE_TYPE_EXTS.has(fileTypeExt) && fileStatSize <= SLICE_ESTIMATE_SCAN_CAP_BYTES) {
       try {
-        ftContent = fs22.readFileSync(normalized, "utf8");
+        ftContent = fs23.readFileSync(normalized, "utf8");
       } catch {
       }
     }
@@ -10364,7 +11217,7 @@ function estimateTruncatedLineCount(normalized) {
   try {
     const sz = statSize(normalized);
     if (sz !== null && sz <= SLICE_ESTIMATE_SCAN_CAP_BYTES) {
-      return countTextLines(fs22.readFileSync(normalized, "utf8"));
+      return countTextLines(fs23.readFileSync(normalized, "utf8"));
     }
   } catch {
   }
@@ -10387,13 +11240,13 @@ function postReadHandlerInner(event) {
   if (respText.includes("[Truncated:") || respText.includes("Truncated: PARTIAL view")) {
     markFileTruncated(normalized);
   }
-  const postBasename = path18.basename(normalized);
+  const postBasename = path19.basename(normalized);
   const diffSourcesEnabled = loadConfig().hints.serve_diff_on_reread;
   if (/\.(md|mdx|markdown|rst|txt)$/i.test(postBasename) || isSessionArtifactFile(normalized) || diffSourcesEnabled && DIFFABLE_SOURCE_RE.test(postBasename)) {
     try {
       const sz = statSize(normalized);
       if (sz !== null && sz <= 256 * 1024) {
-        const content = fs22.readFileSync(normalized);
+        const content = fs23.readFileSync(normalized);
         store(getSessionId(), normalized, content);
       }
     } catch {
@@ -10403,7 +11256,7 @@ function postReadHandlerInner(event) {
     try {
       const cwd = getCwd(event) ?? process.cwd();
       const project = findProject(cwd) ?? makeProjectAt(cwd);
-      const source = decodeSource(fs22.readFileSync(normalized));
+      const source = decodeSource(fs23.readFileSync(normalized));
       recordEvidence({ projectRoot: project.root, source: normalized, representation: "file", text: source });
     } catch {
     }
@@ -10434,7 +11287,7 @@ function postReadHandlerInner(event) {
     try {
       const sz = statSize(normalized);
       if (sz !== null && sz <= SLICE_ESTIMATE_SCAN_CAP_BYTES) {
-        const lineCount = countTextLines(fs22.readFileSync(normalized, "utf8"));
+        const lineCount = countTextLines(fs23.readFileSync(normalized, "utf8"));
         const minLines = loadConfig().post_read_code_compress.min_lines;
         if (lineCount >= minLines && meetsSavingsFloor(sz)) {
           recordStat("session_hint", 0, 0);
@@ -10454,9 +11307,9 @@ function postReadHandler(event) {
 registerHook("post_tool_use", postReadHandler, { toolName: "Read" });
 
 // src/cli_context_stats.ts
-import * as fs24 from "node:fs";
+import * as fs25 from "node:fs";
 import * as os8 from "node:os";
-import * as path20 from "node:path";
+import * as path21 from "node:path";
 
 // src/confirm_apply.ts
 import * as readline from "node:readline";
@@ -10510,8 +11363,8 @@ ${diff}
 }
 
 // src/memory_prune.ts
-import * as fs23 from "node:fs";
-import * as path19 from "node:path";
+import * as fs24 from "node:fs";
+import * as path20 from "node:path";
 var ENTRY_RE = /^\s*-\s*\[(?<title>[^\]]+)\]\((?<target>[^)]+?\.md)\)/;
 var URL_SCHEME_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
 function parseIndex(text) {
@@ -10556,10 +11409,10 @@ function pruneIndex(memoryDir, opts) {
     changed: false,
     tokensSaved: 0
   };
-  const memoryMd = path19.join(memoryDir, "MEMORY.md");
+  const memoryMd = path20.join(memoryDir, "MEMORY.md");
   let text;
   try {
-    text = fs23.readFileSync(memoryMd, "utf-8");
+    text = fs24.readFileSync(memoryMd, "utf-8");
   } catch {
     return result;
   }
@@ -10570,7 +11423,7 @@ function pruneIndex(memoryDir, opts) {
   const dups = [];
   for (const entry of entries) {
     const isUrl = URL_SCHEME_RE.test(entry.target);
-    const targetExists = isUrl ? true : path19.isAbsolute(entry.target) ? fs23.existsSync(entry.target) : fs23.existsSync(path19.join(memoryDir, entry.target));
+    const targetExists = isUrl ? true : path20.isAbsolute(entry.target) ? fs24.existsSync(entry.target) : fs24.existsSync(path20.join(memoryDir, entry.target));
     const foldedTarget = foldPath(entry.target);
     if (!targetExists) {
       dead.push(entry);
@@ -10624,7 +11477,7 @@ function jaccard(a, b) {
 function siblingSnippet(filePath) {
   let text;
   try {
-    text = fs23.readFileSync(filePath, { encoding: "utf-8" });
+    text = fs24.readFileSync(filePath, { encoding: "utf-8" });
   } catch {
     return "";
   }
@@ -10714,7 +11567,7 @@ async function tryEmbeddingClusters(siblings, snippets, threshold) {
 }
 async function findContentDuplicates(memoryDir, _opts) {
   const threshold = _opts?.threshold ?? 0.92;
-  const siblings = fs23.readdirSync(memoryDir).filter((name) => name.toLowerCase().endsWith(".md") && name.toLowerCase() !== "memory.md").map((name) => path19.join(memoryDir, name)).sort();
+  const siblings = fs24.readdirSync(memoryDir).filter((name) => name.toLowerCase().endsWith(".md") && name.toLowerCase() !== "memory.md").map((name) => path20.join(memoryDir, name)).sort();
   if (siblings.length < 2) {
     return [];
   }
@@ -10738,7 +11591,7 @@ function auditClaudeMd(files) {
   for (const filePath of files) {
     let text;
     try {
-      text = fs23.readFileSync(filePath, { encoding: "utf-8" });
+      text = fs24.readFileSync(filePath, { encoding: "utf-8" });
     } catch {
       continue;
     }
@@ -10798,7 +11651,7 @@ function auditClaudeMd(files) {
     const overlaps = [];
     for (const [stripped, filesSet] of lineToFiles) {
       if (filesSet.has(report.path) && filesSet.size > 1) {
-        const others = Array.from(filesSet).filter((p) => p !== report.path).map((p) => path19.basename(p));
+        const others = Array.from(filesSet).filter((p) => p !== report.path).map((p) => path20.basename(p));
         if (others.length > 0) {
           if (stripped.length > 60) {
             overlaps.push(
@@ -10818,7 +11671,7 @@ function auditClaudeMd(files) {
 // src/cli_context_stats.ts
 function tok(filePath) {
   try {
-    const size = fs24.statSync(filePath).size;
+    const size = fs25.statSync(filePath).size;
     return Math.floor(size / 4);
   } catch {
     return 0;
@@ -10827,42 +11680,42 @@ function tok(filePath) {
 function findClaudeMdFiles(projectRoot, homeDir = os8.homedir()) {
   const found = [];
   const seen = /* @__PURE__ */ new Set();
-  let current = path20.resolve(projectRoot);
+  let current = path21.resolve(projectRoot);
   while (true) {
-    const candidate = path20.join(current, "CLAUDE.md");
-    if (!seen.has(candidate) && fs24.existsSync(candidate)) {
+    const candidate = path21.join(current, "CLAUDE.md");
+    if (!seen.has(candidate) && fs25.existsSync(candidate)) {
       found.push(candidate);
       seen.add(candidate);
     }
-    const parent = path20.dirname(current);
+    const parent = path21.dirname(current);
     if (parent === current) break;
     current = parent;
   }
-  const globalMd = path20.join(homeDir, ".claude", "CLAUDE.md");
-  if (!seen.has(globalMd) && fs24.existsSync(globalMd)) {
+  const globalMd = path21.join(homeDir, ".claude", "CLAUDE.md");
+  if (!seen.has(globalMd) && fs25.existsSync(globalMd)) {
     found.push(globalMd);
   }
   return found;
 }
 function findMemoryMd(projectRoot, homeDir = os8.homedir(), alternateRoots = []) {
   try {
-    const projectsDir = path20.join(homeDir, ".claude", "projects");
-    if (!fs24.existsSync(projectsDir)) return null;
-    const rootStr = path20.resolve(projectRoot);
+    const projectsDir = path21.join(homeDir, ".claude", "projects");
+    if (!fs25.existsSync(projectsDir)) return null;
+    const rootStr = path21.resolve(projectRoot);
     const candidateRoots = [rootStr];
     try {
-      const realRoot = fs24.realpathSync.native(rootStr);
+      const realRoot = fs25.realpathSync.native(rootStr);
       if (realRoot !== rootStr) candidateRoots.push(realRoot);
     } catch {
     }
     for (const alternate of alternateRoots) {
-      const resolved = path20.resolve(alternate);
+      const resolved = path21.resolve(alternate);
       if (!candidateRoots.includes(resolved)) candidateRoots.push(resolved);
     }
     for (const root of candidateRoots) {
       const expectedSlug = root.replace(/[^A-Za-z0-9]/g, "-");
-      const candidate = path20.join(projectsDir, expectedSlug, "memory", "MEMORY.md");
-      if (fs24.existsSync(candidate)) return candidate;
+      const candidate = path21.join(projectsDir, expectedSlug, "memory", "MEMORY.md");
+      if (fs25.existsSync(candidate)) return candidate;
     }
     return null;
   } catch {
@@ -10876,10 +11729,10 @@ function buildStats(projectRoot, homeDir = os8.homedir(), alternateRoots = []) {
   for (const p of claudeMds) {
     const t = tok(p);
     claudeMdTotal += t;
-    const parentDir = path20.basename(path20.dirname(p));
+    const parentDir = path21.basename(path21.dirname(p));
     const label = parentDir === ".claude" ? "~/.claude/CLAUDE.md" : (() => {
       try {
-        return path20.relative(projectRoot, p);
+        return path21.relative(projectRoot, p);
       } catch {
         return p;
       }
@@ -10943,11 +11796,11 @@ async function runContextStats(opts = {}) {
       process.stdout.write("[--fix] No MEMORY.md found; nothing to prune.\n");
     } else {
       const memPath = result.memory_md_path;
-      const pruneResult = pruneIndex(path20.dirname(memPath), { dryRun: true });
+      const pruneResult = pruneIndex(path21.dirname(memPath), { dryRun: true });
       if (!pruneResult.changed || pruneResult.after === void 0) {
         process.stdout.write("[--fix] MEMORY.md already clean; nothing to prune.\n");
       } else {
-        const before = fs24.readFileSync(memPath, "utf-8");
+        const before = fs25.readFileSync(memPath, "utf-8");
         const applyResult = await confirmAndApply(
           [{ path: memPath, before, after: pruneResult.after, label: "MEMORY.md" }],
           opts.yes === true ? { yes: true } : {}
@@ -10974,8 +11827,8 @@ async function runContextStats(opts = {}) {
 }
 
 // src/baseline.ts
-import * as fs25 from "node:fs";
-import * as path21 from "node:path";
+import * as fs26 from "node:fs";
+import * as path22 from "node:path";
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -11013,12 +11866,12 @@ function walkProject(rootDir, opts = {}) {
     if (dir === void 0) break;
     let entries;
     try {
-      entries = fs25.readdirSync(dir, { withFileTypes: true });
+      entries = fs26.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const full = path21.join(dir, entry.name);
+      const full = path22.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name) || extraSkipDirs.includes(entry.name)) continue;
         if (entry.name.startsWith(".") && entry.name !== ".") {
@@ -11093,7 +11946,7 @@ function fetchTopSymbols(limit, dbPath, rootDir) {
   }
 }
 function buildProjectMap(rootDir = process.cwd(), opts = {}) {
-  const root = path21.resolve(rootDir);
+  const root = path22.resolve(rootDir);
   const config = loadConfig();
   const { files, languages } = walkProject(root, { excludeTests: config.repomap.exclude_tests });
   const compact = opts.compact === true || files.length > config.repomap.compact_file_threshold;
@@ -11102,12 +11955,12 @@ function buildProjectMap(rootDir = process.cwd(), opts = {}) {
   const recentFiles = files.map((f) => {
     let mtime;
     try {
-      mtime = fs25.statSync(f).mtimeMs;
+      mtime = fs26.statSync(f).mtimeMs;
     } catch {
       mtime = 0;
     }
     return { f, mtime };
-  }).sort((a, b) => b.mtime - a.mtime).slice(0, compact ? 5 : 15).map((x) => path21.relative(root, x.f));
+  }).sort((a, b) => b.mtime - a.mtime).slice(0, compact ? 5 : 15).map((x) => path22.relative(root, x.f));
   return {
     rootDir: root,
     fileCount: files.length,
@@ -11119,7 +11972,7 @@ function buildProjectMap(rootDir = process.cwd(), opts = {}) {
 }
 function formatProjectMap(map, compact = false) {
   const lines2 = [];
-  const rel = path21.basename(map.rootDir);
+  const rel = path22.basename(map.rootDir);
   lines2.push(`# Project map: ${rel}`);
   lines2.push(`Files: ${map.fileCount}`);
   const langPairs = Object.entries(map.languages).sort((a, b) => b[1] - a[1]);
@@ -11147,13 +12000,13 @@ function formatProjectMap(map, compact = false) {
 }
 function mapLookupBytesSaved(map, emittedText) {
   const referencedFiles = /* @__PURE__ */ new Set([
-    ...map.recentFiles.map((f) => normalizePath(path21.resolve(map.rootDir, f))),
+    ...map.recentFiles.map((f) => normalizePath(path22.resolve(map.rootDir, f))),
     ...map.topSymbols.map((s) => normalizePath(s.filePath))
   ]);
   let fullSourceBytes = 0;
   for (const fp of referencedFiles) {
     try {
-      fullSourceBytes += fs25.statSync(fp).size;
+      fullSourceBytes += fs26.statSync(fp).size;
     } catch {
     }
   }
@@ -11167,14 +12020,14 @@ function findMemSuggestionCandidates(projectRoot) {
   const claudeMdFiles = findClaudeMdFiles(projectRoot);
   const candidateFiles = new Set(claudeMdFiles);
   for (const claudeMd of claudeMdFiles) {
-    const agentsMd = path21.join(path21.dirname(claudeMd), "AGENTS.md");
-    if (fs25.existsSync(agentsMd)) candidateFiles.add(agentsMd);
+    const agentsMd = path22.join(path22.dirname(claudeMd), "AGENTS.md");
+    if (fs26.existsSync(agentsMd)) candidateFiles.add(agentsMd);
   }
   const suggestions = [];
   for (const filePath of candidateFiles) {
     let text;
     try {
-      text = fs25.readFileSync(filePath, { encoding: "utf-8" });
+      text = fs26.readFileSync(filePath, { encoding: "utf-8" });
     } catch {
       continue;
     }
@@ -11203,7 +12056,7 @@ function formatMemSuggestions(projectRoot) {
   if (suggestions.length === 0) return "";
   const lines2 = ["", "## mem suggestions"];
   for (const s of suggestions) {
-    const basename12 = path21.basename(s.path);
+    const basename12 = path22.basename(s.path);
     lines2.push(
       "Consider: mem import --from-md " + s.path + "  # migrates " + s.count + " preference-shaped lines from " + basename12 + " as pending facts for review"
     );
@@ -11343,9 +12196,9 @@ function getFileEntry(filePath, dbPath = globalDbPath()) {
     embedSha: row.embed_sha ?? ""
   };
 }
-function sanitizeFtsQuery(query, join22 = "AND") {
+function sanitizeFtsQuery(query, join23 = "AND") {
   const terms = query.split(/\s+/).filter((t) => t.length > 0).map((t) => '"' + t.replace(/"/g, '""') + '"');
-  return terms.join(join22 === "OR" ? " OR " : " ");
+  return terms.join(join23 === "OR" ? " OR " : " ");
 }
 function runFtsQuery(db, match, limit, scope, rootDir) {
   const sql = `SELECT s.file_path, s.name, s.kind, s.line_start, s.line_end, s.body, s.docstring, s.parent FROM symbols_fts JOIN symbols s ON s.id = symbols_fts.rowid WHERE symbols_fts MATCH ?${scope !== void 0 ? ` AND ${scope.clause}` : ""} ORDER BY bm25(symbols_fts) LIMIT ?`;
@@ -11374,9 +12227,9 @@ function searchSymbolsFts(query, limit = 50, dbPath = globalDbPath(), rootDir) {
 }
 
 // src/parser.ts
-import * as fs26 from "node:fs";
+import * as fs27 from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import * as path26 from "node:path";
+import * as path27 from "node:path";
 
 // src/languages/csharp.ts
 var USING_RE = /^(?:global\s+)?using\s+(?:static\s+)?([A-Za-z_][A-Za-z0-9_.]*)\s*(?:=\s*([A-Za-z_][A-Za-z0-9_.<>,\s]*))?\s*;/;
@@ -11809,7 +12662,7 @@ function extractHtml(content, filePath) {
 }
 
 // src/languages/liquid.ts
-import * as path22 from "node:path";
+import * as path23 from "node:path";
 var INCLUDE_RE = /{%-?\s*include\s+(['"])((?:(?!\1)[\s\S])+?)\1/gi;
 var SECTION_RE = /{%-?\s*section\s+(['"])((?:(?!\1)[\s\S])+?)\1/gi;
 var RENDER_RE = /{%-?\s*render\s+(['"])((?:(?!\1)[\s\S])+?)\1/gi;
@@ -11852,7 +12705,7 @@ function extractLiquid(content, filePath, relPath) {
   const resolvedRel = relPath ?? filePath;
   const relPosix = resolvedRel.replace(/\\/g, "/");
   if (relPosix.startsWith("sections/") || relPosix.includes("/sections/")) {
-    const stem = path22.basename(resolvedRel, path22.extname(resolvedRel));
+    const stem = path23.basename(resolvedRel, path23.extname(resolvedRel));
     symbols.push({ filePath, name: stem, kind: "liquid_section_file", lineStart: 1, lineEnd: 1, body: "", docstring: "", parent: "" });
   }
   const totalLines = countContentLines(content);
@@ -14155,7 +15008,7 @@ function extractApex(content, filePath) {
 }
 
 // src/languages/salesforce_metadata.ts
-import * as path23 from "node:path";
+import * as path24 from "node:path";
 var MAX_SYMBOLS10 = 1e3;
 var MAX_REFS = 1e3;
 var FLOW_TAG_KIND = {
@@ -14213,7 +15066,7 @@ function normalizedPath(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function basenameWithout(filePath, suffix) {
-  const base = path23.basename(filePath);
+  const base = path24.basename(filePath);
   return base.toLowerCase().endsWith(suffix.toLowerCase()) ? base.slice(0, base.length - suffix.length) : base;
 }
 function objectNameFromPath(filePath) {
@@ -14252,12 +15105,12 @@ function snakeCase(value) {
   return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/[^A-Za-z0-9]+/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
 }
 function companionName(filePath) {
-  const base = path23.basename(filePath);
+  const base = path24.basename(filePath);
   const match = /^(.+)\.(?:cls|trigger|page|component|cmp|app|evt|intf|design|auradoc|tokens|js)-meta\.xml$/i.exec(base);
   return match?.[1] === void 0 ? null : `${match[1]}.metadata`;
 }
 function metadataArtifactName(filePath) {
-  const base = path23.basename(filePath);
+  const base = path24.basename(filePath);
   const match = /^(.+)\.[^.]+-meta\.xml$/i.exec(base);
   return match?.[1] ?? basenameWithout(filePath, "-meta.xml");
 }
@@ -14348,7 +15201,7 @@ function extractSalesforceMetadata(rawContent, filePath) {
   const seen = /* @__PURE__ */ new Set();
   const refs = [];
   const seenRefs = /* @__PURE__ */ new Set();
-  const base = path23.basename(filePath).toLowerCase();
+  const base = path24.basename(filePath).toLowerCase();
   const whole = wholeFileSpan(content);
   const root = rootElement(content);
   if (root === null) return { symbols, refs };
@@ -14492,14 +15345,14 @@ function extractSalesforceMetadata(rawContent, filePath) {
 }
 
 // src/languages/salesforce_frontend.ts
-import * as path24 from "node:path";
+import * as path25 from "node:path";
 function lines(content) {
   return content.split("\n");
 }
 function bundleName(filePath) {
   const normalized = filePath.replaceAll("\\", "/");
-  const parent = path24.posix.basename(path24.posix.dirname(normalized));
-  const base = path24.posix.basename(normalized).replace(/\.[^.]+$/, "");
+  const parent = path25.posix.basename(path25.posix.dirname(normalized));
+  const base = path25.posix.basename(normalized).replace(/\.[^.]+$/, "");
   return parent === "lwc" || parent === "aura" ? base : parent;
 }
 function lwcTagAlias(name) {
@@ -14603,7 +15456,7 @@ var MARKUP_KIND = {
 };
 function markupArtifactName(filePath, extension) {
   if (extension === ".page" || extension === ".component" || extension === ".email") {
-    return path24.posix.basename(filePath.replaceAll("\\", "/")).replace(new RegExp(`${extension.replace(".", "\\.")}$`, "i"), "");
+    return path25.posix.basename(filePath.replaceAll("\\", "/")).replace(new RegExp(`${extension.replace(".", "\\.")}$`, "i"), "");
   }
   return bundleName(filePath);
 }
@@ -14623,7 +15476,7 @@ function attributeRefs(refs, content, filePath, attribute, split = false) {
 }
 function extractSalesforceMarkup(content, filePath) {
   const normalized = filePath.replaceAll("\\", "/");
-  const extension = path24.posix.extname(normalized).toLowerCase();
+  const extension = path25.posix.extname(normalized).toLowerCase();
   const kind = MARKUP_KIND[extension] ?? "salesforce_markup";
   const symbols = [
     symbol(filePath, markupArtifactName(normalized, extension), kind, 1, countContentLines(content))
@@ -14655,7 +15508,7 @@ function extractSalesforceMarkup(content, filePath) {
 }
 
 // src/languages/sfc_idx.ts
-import * as path25 from "node:path";
+import * as path26 from "node:path";
 var MAX_SYMBOLS11 = 500;
 function dedupe2(values, key) {
   const seen = /* @__PURE__ */ new Set();
@@ -14674,7 +15527,7 @@ function finalize(symbols, refs) {
 }
 function componentName(filePath) {
   const normalized = filePath.replaceAll("\\", "/");
-  return path25.posix.basename(normalized).replace(/\.[^.]+$/, "");
+  return path26.posix.basename(normalized).replace(/\.[^.]+$/, "");
 }
 function matchLine2(content, offset) {
   return content.slice(0, offset).split("\n").length;
@@ -14986,8 +15839,8 @@ function countNewlines(s) {
   return n;
 }
 function loadGrammar(lang, filePath, content) {
-  const useTsx = lang === "typescript" && filePath !== void 0 && path26.extname(filePath).toLowerCase() === ".tsx";
-  const useCppHeader = lang === "c" && filePath !== void 0 && path26.extname(filePath).toLowerCase() === ".h" && content !== void 0 && CPP_HEADER_SNIFF_RE.test(content);
+  const useTsx = lang === "typescript" && filePath !== void 0 && path27.extname(filePath).toLowerCase() === ".tsx";
+  const useCppHeader = lang === "c" && filePath !== void 0 && path27.extname(filePath).toLowerCase() === ".h" && content !== void 0 && CPP_HEADER_SNIFF_RE.test(content);
   const cacheKey = useTsx ? "typescript:tsx" : useCppHeader ? "c:cpp-header" : lang;
   const cached = _grammarCache.get(cacheKey);
   if (cached !== void 0) return cached;
@@ -15135,6 +15988,9 @@ function makeSymbol(filePath, name, kind, node, lines2, style) {
     parent: ""
   };
 }
+function fanOutElidesBodies(nameCount, declarationChars) {
+  return nameCount > 1 && nameCount * declarationChars > MAX_SYMBOL_BODY_CHARS;
+}
 function collectPatternBindings(node) {
   const names = [];
   const walk = (n) => {
@@ -15142,6 +15998,16 @@ function collectPatternBindings(node) {
       if (n.text !== "") names.push(n.text);
       return;
     }
+    if (n.type === "assignment_pattern" || n.type === "object_assignment_pattern") {
+      const left = n.childForFieldName("left");
+      if (left !== null) walk(left);
+      return;
+    }
+    if (n.type === "pair_pattern") {
+      const value = n.childForFieldName("value");
+      if (value !== null) walk(value);
+      return;
+    }
     for (const child of n.namedChildren) walk(child);
   };
   walk(node);
@@ -15203,7 +16069,7 @@ function extractTsJsSymbols(root, filePath, lines2) {
           out.push(makeSymbol(filePath, name.text, isFn ? "function" : "variable", child, lines2, "c"));
         } else {
           const bindings = collectPatternBindings(name);
-          const elideBodies = bindings.length > 1 && bindings.length * child.text.length > MAX_SYMBOL_BODY_CHARS;
+          const elideBodies = fanOutElidesBodies(bindings.length, child.text.length);
           for (const bound of bindings) {
             const sym = makeSymbol(filePath, bound, "variable", child, lines2, "c");
             out.push(elideBodies ? { ...sym, body: "" } : sym);
@@ -15321,14 +16187,26 @@ var GO_LOCAL_KINDS = /* @__PURE__ */ new Set([
   // the interface type declaring them does not.
   "method_elem"
 ]);
+var GO_MULTI_NAME_SPECS = /* @__PURE__ */ new Set(["var_spec", "const_spec"]);
 function extractGoSymbols(root, filePath, lines2) {
   const out = [];
   const visit = (node, insideFunction) => {
     const kind = GO_KIND_BY_TYPE.get(node.type);
     if (kind !== void 0 && !(insideFunction && GO_LOCAL_KINDS.has(node.type))) {
-      const name = nodeName(node);
-      if (name !== null && name !== "") {
-        out.push(makeSymbol(filePath, name, kind, node, lines2, "c"));
+      if (GO_MULTI_NAME_SPECS.has(node.type)) {
+        const declared = node.namedChildren.filter(
+          (c) => c.type === "identifier" && c.text !== "" && c.text !== "_"
+        );
+        const elideBodies = fanOutElidesBodies(declared.length, node.text.length);
+        for (const child of declared) {
+          const sym = makeSymbol(filePath, child.text, kind, node, lines2, "c");
+          out.push(elideBodies ? { ...sym, body: "" } : sym);
+        }
+      } else {
+        const name = nodeName(node);
+        if (name !== null && name !== "") {
+          out.push(makeSymbol(filePath, name, kind, node, lines2, "c"));
+        }
       }
     }
     const childInside = insideFunction || GO_FN_SCOPE_TYPES.has(node.type);
@@ -16654,9 +17532,9 @@ function isUnderSkipDir(filePath, skipDirs) {
 }
 function isParseSkipEligible(filePath, cfg) {
   if (isUnderSkipDir(filePath, cfg.skip_dirs)) return true;
-  if (cfg.skip_files.includes(path26.basename(filePath))) return true;
+  if (cfg.skip_files.includes(path27.basename(filePath))) return true;
   try {
-    const stat2 = fs26.statSync(filePath);
+    const stat2 = fs27.statSync(filePath);
     if (stat2.size > cfg.large_file_skip_kb * 1024) return true;
   } catch {
   }
@@ -16698,7 +17576,8 @@ function writeParseResult(filePath, content, result, dbPath) {
   });
   writeAll.immediate();
 }
-function indexFileSync(filePath, dbPath = globalDbPath(), preReadBytes) {
+function indexFileSync(rawPath, dbPath = globalDbPath(), preReadBytes) {
+  const filePath = canonicalizeIndexPath(rawPath);
   const ixCfg = loadConfig().indexing;
   if (ixCfg !== void 0 && isParseSkipEligible(filePath, ixCfg)) {
     const db = getDb(dbPath);
@@ -16712,7 +17591,7 @@ function indexFileSync(filePath, dbPath = globalDbPath(), preReadBytes) {
     raw = preReadBytes;
   } else {
     try {
-      raw = fs26.readFileSync(filePath);
+      raw = fs27.readFileSync(filePath);
     } catch (err) {
       if (err.code === "ENOENT") return;
       throw err;
@@ -16743,14 +17622,32 @@ var UNAVAILABLE_EMBED_SHA_PREFIX = "unavailable:";
 function unavailableEmbedSha(sha) {
   return UNAVAILABLE_EMBED_SHA_PREFIX + sha;
 }
+function canonicalizeIndexPath(absPath) {
+  if (!isCaseInsensitiveFs()) return absPath;
+  let real;
+  try {
+    real = fs27.realpathSync.native(absPath);
+  } catch {
+    return absPath;
+  }
+  const cut = Math.max(absPath.lastIndexOf("/"), absPath.lastIndexOf("\\"));
+  const base = absPath.slice(cut + 1);
+  const realNorm = normalizePath(real);
+  const realBase = path27.basename(realNorm);
+  if (base === realBase) return absPath;
+  if (foldPath(base) !== foldPath(realBase)) return absPath;
+  const callerDir = cut < 0 ? normalizePath(path27.resolve(".")) : normalizePath(absPath.slice(0, cut));
+  if (foldPath(callerDir) !== foldPath(path27.dirname(realNorm))) return absPath;
+  return absPath.slice(0, cut + 1) + realBase;
+}
 function indexedPathSpellingIsStale(storedPath, absPath) {
   if (!isCaseInsensitiveFs()) return false;
   const stored = normalizePath(storedPath);
-  const candidate = normalizePath(path26.resolve(absPath));
+  const candidate = normalizePath(path27.resolve(absPath));
   if (foldPath(stored) !== foldPath(candidate)) return false;
   let real;
   try {
-    real = normalizePath(fs26.realpathSync.native(absPath));
+    real = normalizePath(fs27.realpathSync.native(absPath));
   } catch {
     return false;
   }
@@ -16779,7 +17676,8 @@ function isEmbedFresh(storedEmbedSha, sha, embeddingsEnabled, depsAvailable) {
   if (!depsAvailable && storedEmbedSha === unavailableEmbedSha(sha)) return true;
   return false;
 }
-async function indexFileEmbeddings(filePath, dbPath = globalDbPath(), sha, onError) {
+async function indexFileEmbeddings(rawPath, dbPath = globalDbPath(), sha, onError) {
+  const filePath = canonicalizeIndexPath(rawPath);
   const ixCfg = loadConfig().indexing;
   if (!ixCfg.embeddings_enabled) {
     stampEmbedSha(getDb(dbPath), filePath, sha, disabledEmbedSha);
@@ -16816,7 +17714,7 @@ async function indexFileEmbeddings(filePath, dbPath = globalDbPath(), sha, onErr
   }
   let content;
   try {
-    content = decodeSource(await fs26.promises.readFile(filePath));
+    content = decodeSource(await fs27.promises.readFile(filePath));
   } catch {
     return;
   }
@@ -16862,15 +17760,15 @@ function stampEmbedSha(db, filePath, sha, makeValue) {
 }
 function safeMtime(filePath) {
   try {
-    return fs26.statSync(filePath).mtimeMs / 1e3;
+    return fs27.statSync(filePath).mtimeMs / 1e3;
   } catch {
     return 0;
   }
 }
 
 // src/index_prune.ts
-import * as fs27 from "node:fs";
-import * as path27 from "node:path";
+import * as fs28 from "node:fs";
+import * as path28 from "node:path";
 function removeFileFromIndex(db, filePath) {
   const tx = db.transaction(() => {
     deleteFileRows(db, filePath);
@@ -16907,7 +17805,7 @@ function findDeletablePaths(rootPrefix, dbPath) {
   for (const p of foldedPathsUnderRoot(rootPrefix, dbPath)) {
     let stillExists;
     try {
-      const st = fs27.statSync(p, { throwIfNoEntry: false });
+      const st = fs28.statSync(p, { throwIfNoEntry: false });
       stillExists = st !== void 0 && st.isFile();
     } catch {
       continue;
@@ -16935,7 +17833,7 @@ function removeDeletedFilesBestEffort(db, paths) {
   for (const p of paths) {
     let gone;
     try {
-      const st = fs27.statSync(p, { throwIfNoEntry: false });
+      const st = fs28.statSync(p, { throwIfNoEntry: false });
       gone = st === void 0 || !st.isFile();
     } catch {
       continue;
@@ -17002,7 +17900,7 @@ function pruneOrphanedChunks(dbPath = globalDbPath()) {
   return removed;
 }
 function recordKnownRoot(filePath, dbPath = globalDbPath()) {
-  const project = findProject(path27.dirname(filePath));
+  const project = findProject(path28.dirname(filePath));
   if (project === null || isTooShallowToPrune(project.root)) return;
   const db = getDb(dbPath);
   db.prepare(
@@ -17025,7 +17923,7 @@ function sweepKnownRoots(dbPath = globalDbPath(), opts) {
     if (isTooShallowToPrune(root)) continue;
     let reachable;
     try {
-      reachable = fs27.statSync(root, { throwIfNoEntry: false })?.isDirectory() === true;
+      reachable = fs28.statSync(root, { throwIfNoEntry: false })?.isDirectory() === true;
     } catch {
       reachable = false;
     }
@@ -17060,19 +17958,19 @@ function sweepKnownRoots(dbPath = globalDbPath(), opts) {
 }
 var KNOWN_ROOT_RECORD_MIN_INTERVAL_MS = 60 * 60 * 1e3;
 function knownRootRecordMarkerPath(dir, filePath) {
-  return path27.join(dir, `known-root-record-${shortFingerprint(path27.dirname(filePath))}.marker`);
+  return path28.join(dir, `known-root-record-${shortFingerprint(path28.dirname(filePath))}.marker`);
 }
 var KNOWN_ROOT_MARKER_PREFIX = "known-root-record-";
 function sweepExpiredKnownRootMarkers(dir = dataDir()) {
   let removed = 0;
   try {
     const cutoff = Date.now() - KNOWN_ROOT_RECORD_MIN_INTERVAL_MS;
-    for (const file of fs27.readdirSync(dir)) {
+    for (const file of fs28.readdirSync(dir)) {
       if (!file.startsWith(KNOWN_ROOT_MARKER_PREFIX) || !file.endsWith(".marker")) continue;
-      const full = path27.join(dir, file);
+      const full = path28.join(dir, file);
       try {
-        if (fs27.statSync(full).mtimeMs < cutoff) {
-          fs27.unlinkSync(full);
+        if (fs28.statSync(full).mtimeMs < cutoff) {
+          fs28.unlinkSync(full);
           removed += 1;
         }
       } catch {
@@ -17085,13 +17983,13 @@ function sweepExpiredKnownRootMarkers(dir = dataDir()) {
 function recordKnownRootThrottled(filePath, dir = dataDir(), dbPath = globalDbPath()) {
   const markerPath = knownRootRecordMarkerPath(dir, filePath);
   try {
-    const stat2 = fs27.statSync(markerPath);
+    const stat2 = fs28.statSync(markerPath);
     if (Date.now() - stat2.mtimeMs < KNOWN_ROOT_RECORD_MIN_INTERVAL_MS) return;
   } catch {
   }
   try {
     ensureDirSync(dir);
-    fs27.writeFileSync(markerPath, "");
+    fs28.writeFileSync(markerPath, "");
   } catch {
   }
   recordKnownRoot(filePath, dbPath);
@@ -17099,8 +17997,8 @@ function recordKnownRootThrottled(filePath, dir = dataDir(), dbPath = globalDbPa
 
 // src/worker.ts
 import { spawn as spawn2 } from "node:child_process";
-import * as fs28 from "node:fs";
-import * as path28 from "node:path";
+import * as fs29 from "node:fs";
+import * as path29 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var DEFAULT_POLL_INTERVAL_MS = 2e3;
 function resolvePollIntervalMs(explicit) {
@@ -17120,7 +18018,7 @@ var unclearedDrainingSnapshots = /* @__PURE__ */ new Map();
 function drainingSnapshotStamp(file, content) {
   let identity = "unknown";
   try {
-    const stat2 = fs28.statSync(file);
+    const stat2 = fs29.statSync(file);
     identity = `${stat2.mtimeMs}:${stat2.size}:${stat2.ino}`;
   } catch {
   }
@@ -17129,15 +18027,15 @@ function drainingSnapshotStamp(file, content) {
 var DRAINING_READ_ATTEMPTS = 5;
 var DRAINING_READ_RETRY_DELAY_MS = 50;
 function listDrainingFiles(queuePath) {
-  const dir = path28.dirname(queuePath);
-  const base = `${path28.basename(queuePath)}.draining`;
+  const dir = path29.dirname(queuePath);
+  const base = `${path29.basename(queuePath)}.draining`;
   let entries;
   try {
-    entries = fs28.readdirSync(dir);
+    entries = fs29.readdirSync(dir);
   } catch {
     return [];
   }
-  return entries.filter((name) => name === base || name.startsWith(`${base}.alt-`) && !name.includes(".corrupt-")).sort().map((name) => path28.join(dir, name));
+  return entries.filter((name) => name === base || name.startsWith(`${base}.alt-`) && !name.includes(".corrupt-")).sort().map((name) => path29.join(dir, name));
 }
 var MAX_TRANSIENT_RETRIES = 5;
 function bumpRetryCount(dbPath, absPath) {
@@ -17165,17 +18063,17 @@ function clearRetryCount(dbPath, absPath) {
   }
 }
 function dirtyQueuePathFor(dir) {
-  return path28.join(dir, "queue", "dirty.txt");
+  return path29.join(dir, "queue", "dirty.txt");
 }
 function drainHeartbeatPathFor(dir) {
-  return path28.join(dir, "queue", "drain-heartbeat");
+  return path29.join(dir, "queue", "drain-heartbeat");
 }
 function writeDrainHeartbeat(dir, force = false) {
   const now = Date.now();
   if (!force && now - (heartbeatWriteTimes.get(dir) ?? 0) < WORKER_HEARTBEAT_REFRESH_MS) return;
   try {
-    ensureDirSync(path28.dirname(drainHeartbeatPathFor(dir)));
-    fs28.writeFileSync(drainHeartbeatPathFor(dir), `${process.pid}
+    ensureDirSync(path29.dirname(drainHeartbeatPathFor(dir)));
+    fs29.writeFileSync(drainHeartbeatPathFor(dir), `${process.pid}
 `);
     heartbeatWriteTimes.set(dir, now);
   } catch {
@@ -17184,15 +18082,15 @@ function writeDrainHeartbeat(dir, force = false) {
 function hasFreshWorkerHeartbeat(dir, pid) {
   try {
     const heartbeatPath = drainHeartbeatPathFor(dir);
-    if (Date.now() - fs28.statSync(heartbeatPath).mtimeMs > WORKER_HEARTBEAT_STALE_MS) return false;
-    return fs28.readFileSync(heartbeatPath, "utf8").trim() === String(pid);
+    if (Date.now() - fs29.statSync(heartbeatPath).mtimeMs > WORKER_HEARTBEAT_STALE_MS) return false;
+    return fs29.readFileSync(heartbeatPath, "utf8").trim() === String(pid);
   } catch {
     return false;
   }
 }
 function pidFileIsWithinStartupGrace(dir) {
   try {
-    return Date.now() - fs28.statSync(workerPidPath(dir)).mtimeMs < WORKER_STARTUP_GRACE_MS;
+    return Date.now() - fs29.statSync(workerPidPath(dir)).mtimeMs < WORKER_STARTUP_GRACE_MS;
   } catch {
     return false;
   }
@@ -17226,28 +18124,28 @@ function parseDirtyQueueLines(raw) {
   return out;
 }
 function workerPidPath(dir = dataDir()) {
-  return path28.join(dir, "worker.pid");
+  return path29.join(dir, "worker.pid");
 }
 function getDirtyPathsFor(dir) {
   let raw;
   try {
-    raw = fs28.readFileSync(dirtyQueuePathFor(dir), "utf8");
+    raw = fs29.readFileSync(dirtyQueuePathFor(dir), "utf8");
   } catch {
     return [];
   }
   return parseDirtyQueueLines(raw);
 }
 function workerErrorLogPath(dir) {
-  return path28.join(dir, "worker-errors.log");
+  return path29.join(dir, "worker-errors.log");
 }
 var WORKER_ERROR_LOG_MAX_BYTES = 5 * 1024 * 1024;
 var CORRUPT_QUARANTINE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
 function cleanupWorkerStateFiles(dir) {
   try {
     const logPath = workerErrorLogPath(dir);
-    const stat2 = fs28.statSync(logPath);
+    const stat2 = fs29.statSync(logPath);
     if (stat2.size > WORKER_ERROR_LOG_MAX_BYTES) {
-      fs28.writeFileSync(
+      fs29.writeFileSync(
         logPath,
         `${(/* @__PURE__ */ new Date()).toISOString()} worker-errors.log rotated (exceeded ${WORKER_ERROR_LOG_MAX_BYTES} bytes)
 `
@@ -17256,13 +18154,13 @@ function cleanupWorkerStateFiles(dir) {
   } catch {
   }
   try {
-    const queueDir = path28.dirname(dirtyQueuePathFor(dir));
+    const queueDir = path29.dirname(dirtyQueuePathFor(dir));
     const cutoff = Date.now() - CORRUPT_QUARANTINE_MAX_AGE_MS;
-    for (const file of fs28.readdirSync(queueDir)) {
+    for (const file of fs29.readdirSync(queueDir)) {
       if (!file.includes(".corrupt-")) continue;
-      const full = path28.join(queueDir, file);
+      const full = path29.join(queueDir, file);
       try {
-        if (fs28.statSync(full).mtimeMs < cutoff) fs28.unlinkSync(full);
+        if (fs29.statSync(full).mtimeMs < cutoff) fs29.unlinkSync(full);
       } catch {
       }
     }
@@ -17293,7 +18191,7 @@ registerReset(() => {
 function embedFileSerialized(absPath, dbPath, sha) {
   const key = foldPath(absPath);
   const prior = inFlightEmbeddings.get(key);
-  const dir = path28.dirname(dbPath);
+  const dir = path29.dirname(dbPath);
   const onEmbedError = (err) => {
     const message = extractErrorMessage(err);
     appendWorkerErrorLog(dir, `${(/* @__PURE__ */ new Date()).toISOString()} indexFileEmbeddings failed for ${absPath}: ${message}
@@ -17327,7 +18225,7 @@ function embedFileSerialized(absPath, dbPath, sha) {
 }
 function appendWorkerErrorLog(dir, line) {
   try {
-    fs28.appendFileSync(workerErrorLogPath(dir), line);
+    fs29.appendFileSync(workerErrorLogPath(dir), line);
   } catch {
   }
 }
@@ -17344,7 +18242,7 @@ function logTransientReadFailure(dir, absPath) {
   );
 }
 function bumpAndCheckRetry(dir, absPath) {
-  const dbPath = path28.join(dir, "global.db");
+  const dbPath = path29.join(dir, "global.db");
   const attempts = bumpRetryCount(dbPath, absPath);
   if (attempts > MAX_TRANSIENT_RETRIES) {
     if (attempts === MAX_TRANSIENT_RETRIES + 1) {
@@ -17361,14 +18259,14 @@ function bumpAndCheckRetry(dir, absPath) {
 function appendToDirtyQueue(dir, absPath) {
   const queuePath = dirtyQueuePathFor(dir);
   try {
-    ensureDirSync(path28.dirname(queuePath));
+    ensureDirSync(path29.dirname(queuePath));
     let leadingNewline = "";
     try {
-      const existing = fs28.readFileSync(queuePath, "utf8");
+      const existing = fs29.readFileSync(queuePath, "utf8");
       if (existing.length > 0 && !existing.endsWith("\n")) leadingNewline = "\n";
     } catch {
     }
-    fs28.appendFileSync(queuePath, `${leadingNewline}${encodeDirtyQueueLine(absPath)}
+    fs29.appendFileSync(queuePath, `${leadingNewline}${encodeDirtyQueueLine(absPath)}
 `);
   } catch {
   }
@@ -17377,7 +18275,7 @@ function requeueDirtyPath(dir, absPath) {
   if (bumpAndCheckRetry(dir, absPath)) appendToDirtyQueue(dir, absPath);
 }
 function makeIndexer(dbPath) {
-  const dir = path28.dirname(dbPath);
+  const dir = path29.dirname(dbPath);
   return (absPath, sha) => {
     try {
       const ixCfgForSkip = loadConfig().indexing;
@@ -17429,16 +18327,16 @@ function processDirtyBatch(paths, index = makeIndexer(globalDbPath()), remove =
       requeue(dir, p);
       continue;
     }
-    clearRetryCount(path28.join(dir, "global.db"), p);
+    clearRetryCount(path29.join(dir, "global.db"), p);
     try {
-      const dirname17 = path28.dirname(p);
+      const dirname19 = path29.dirname(p);
       let root;
-      if (projectRootCache.has(dirname17)) {
-        root = projectRootCache.get(dirname17) ?? null;
+      if (projectRootCache.has(dirname19)) {
+        root = projectRootCache.get(dirname19) ?? null;
       } else {
-        const project = findProject(dirname17);
+        const project = findProject(dirname19);
         root = project?.root ?? null;
-        projectRootCache.set(dirname17, root);
+        projectRootCache.set(dirname19, root);
       }
       if (root) lastKnownProjectRoots.set(dir, root);
     } catch {
@@ -17457,7 +18355,7 @@ function sleepSyncMs(ms) {
 function drainOnce(dir, index, remove) {
   const queuePath = dirtyQueuePathFor(dir);
   const draining = `${queuePath}.draining`;
-  const dbPath = path28.join(dir, "global.db");
+  const dbPath = path29.join(dir, "global.db");
   const indexFn = index ?? makeIndexer(dbPath);
   const removeFn = remove ?? makeRemover(dbPath);
   let processed = 0;
@@ -17474,7 +18372,7 @@ function drainOnce(dir, index, remove) {
     let drainingContent = null;
     for (let attempt = 0; attempt < DRAINING_READ_ATTEMPTS; attempt++) {
       try {
-        drainingContent = fs28.readFileSync(drainingFile, "utf8");
+        drainingContent = fs29.readFileSync(drainingFile, "utf8");
         break;
       } catch {
         if (attempt < DRAINING_READ_ATTEMPTS - 1) sleepSyncMs(DRAINING_READ_RETRY_DELAY_MS);
@@ -17482,7 +18380,7 @@ function drainOnce(dir, index, remove) {
     }
     if (drainingContent === null) {
       try {
-        fs28.renameSync(drainingFile, `${drainingFile}.corrupt-${Date.now()}`);
+        fs29.renameSync(drainingFile, `${drainingFile}.corrupt-${Date.now()}`);
         unclearedDrainingSnapshots.delete(drainingFile);
       } catch {
       }
@@ -17492,23 +18390,23 @@ function drainOnce(dir, index, remove) {
       processed += processDirtyBatch(parseDirtyQueueLines(drainingContent), indexFn, removeFn, dir, requeueFn);
     }
     try {
-      fs28.rmSync(drainingFile, { force: true });
+      fs29.rmSync(drainingFile, { force: true });
       unclearedDrainingSnapshots.delete(drainingFile);
     } catch {
       try {
-        fs28.renameSync(drainingFile, `${drainingFile}.corrupt-${Date.now()}`);
+        fs29.renameSync(drainingFile, `${drainingFile}.corrupt-${Date.now()}`);
         unclearedDrainingSnapshots.delete(drainingFile);
       } catch {
         unclearedDrainingSnapshots.set(drainingFile, drainingSnapshotStamp(drainingFile, drainingContent));
       }
     }
   }
-  if (fs28.existsSync(queuePath)) {
-    const claimTarget = fs28.existsSync(draining) ? `${draining}.alt-${Date.now()}` : draining;
+  if (fs29.existsSync(queuePath)) {
+    const claimTarget = fs29.existsSync(draining) ? `${draining}.alt-${Date.now()}` : draining;
     let claimed = false;
     for (let attempt = 0; attempt < 5; attempt++) {
       try {
-        fs28.renameSync(queuePath, claimTarget);
+        fs29.renameSync(queuePath, claimTarget);
         claimed = true;
         break;
       } catch {
@@ -17519,14 +18417,14 @@ function drainOnce(dir, index, remove) {
       let claimedContent = "";
       let readOk = false;
       try {
-        claimedContent = fs28.readFileSync(claimTarget, "utf8");
+        claimedContent = fs29.readFileSync(claimTarget, "utf8");
         readOk = true;
       } catch {
       }
       if (readOk) {
         processed += processDirtyBatch(parseDirtyQueueLines(claimedContent), indexFn, removeFn, dir, requeueFn);
         try {
-          const recheck = fs28.readFileSync(claimTarget, "utf8");
+          const recheck = fs29.readFileSync(claimTarget, "utf8");
           if (recheck !== claimedContent) {
             const extra = recheck.startsWith(claimedContent) ? recheck.slice(claimedContent.length) : recheck;
             for (const p of parseDirtyQueueLines(extra)) appendToDirtyQueue(dir, p);
@@ -17534,10 +18432,10 @@ function drainOnce(dir, index, remove) {
         } catch {
         }
         try {
-          fs28.rmSync(claimTarget, { force: true });
+          fs29.rmSync(claimTarget, { force: true });
         } catch {
           try {
-            fs28.renameSync(claimTarget, `${claimTarget}.corrupt-${Date.now()}`);
+            fs29.renameSync(claimTarget, `${claimTarget}.corrupt-${Date.now()}`);
           } catch {
             unclearedDrainingSnapshots.set(claimTarget, drainingSnapshotStamp(claimTarget, claimedContent));
           }
@@ -17570,7 +18468,7 @@ function pidAlive(pid) {
 }
 function readPidFile(dir) {
   try {
-    const raw = fs28.readFileSync(workerPidPath(dir), "utf8").trim();
+    const raw = fs29.readFileSync(workerPidPath(dir), "utf8").trim();
     if (!/^\d+$/.test(raw)) return null;
     return parseInt(raw, 10);
   } catch {
@@ -17583,20 +18481,20 @@ function isWorkerRunning(dir = dataDir()) {
   return pidAlive(pid) && hasFreshWorkerHeartbeat(dir, pid);
 }
 function workerHealthCheckMarkerPath(dir) {
-  return path28.join(dir, "worker-healthcheck.marker");
+  return path29.join(dir, "worker-healthcheck.marker");
 }
 var WORKER_HEALTHCHECK_MIN_INTERVAL_MS = 5 * 60 * 1e3;
 function ensureWorkerAlive(dir = dataDir()) {
   if (process.env["TOKEN_GOAT_NO_WORKER_SPAWN"] === "1") return;
   const markerPath = workerHealthCheckMarkerPath(dir);
   try {
-    const stat2 = fs28.statSync(markerPath);
+    const stat2 = fs29.statSync(markerPath);
     if (Date.now() - stat2.mtimeMs < WORKER_HEALTHCHECK_MIN_INTERVAL_MS) return;
   } catch {
   }
   try {
     ensureDirSync(dir);
-    fs28.writeFileSync(markerPath, "");
+    fs29.writeFileSync(markerPath, "");
   } catch {
   }
   if (isWorkerRunning(dir)) return;
@@ -17626,7 +18524,7 @@ function stopWorker(dir = dataDir()) {
   }
   if (readPidFile(dir) === pid) {
     try {
-      fs28.rmSync(workerPidPath(dir), { force: true });
+      fs29.rmSync(workerPidPath(dir), { force: true });
     } catch {
     }
   }
@@ -17641,7 +18539,7 @@ var WorkerAlreadyRunningError = class extends Error {
 function claimWorkerPidFile(dir, pid) {
   const pidPath = workerPidPath(dir);
   try {
-    fs28.writeFileSync(pidPath, `${pid}
+    fs29.writeFileSync(pidPath, `${pid}
 `, { flag: "wx" });
     return true;
   } catch (e) {
@@ -17658,11 +18556,11 @@ function claimWorkerPidFile(dir, pid) {
     }
   }
   try {
-    fs28.rmSync(pidPath, { force: true });
+    fs29.rmSync(pidPath, { force: true });
   } catch {
   }
   try {
-    fs28.writeFileSync(pidPath, `${pid}
+    fs29.writeFileSync(pidPath, `${pid}
 `, { flag: "wx" });
     return true;
   } catch (e2) {
@@ -17672,9 +18570,9 @@ function claimWorkerPidFile(dir, pid) {
 }
 function daemonEntryScript() {
   const self = fileURLToPath2(import.meta.url);
-  const launcher = path28.join(path28.dirname(self), "token-goat.mjs");
+  const launcher = path29.join(path29.dirname(self), "token-goat.mjs");
   try {
-    if (fs28.existsSync(launcher)) return launcher;
+    if (fs29.existsSync(launcher)) return launcher;
   } catch {
   }
   return self;
@@ -17685,7 +18583,7 @@ function startDetachedWorker(opts) {
   try {
     ensureDirSync(dir);
   } catch (e) {
-    if (e.code !== "EEXIST" || !fs28.existsSync(dir)) throw e;
+    if (e.code !== "EEXIST" || !fs29.existsSync(dir)) throw e;
   }
   const child = spawn2(
     process.execPath,
@@ -17722,7 +18620,7 @@ async function runWorkerLoop(dir, pollIntervalMs, shouldStop = () => false) {
   let lastKnownRootsSweepMs = 0;
   let ownedPidFile = false;
   while (!shouldStop()) {
-    if (!fs28.existsSync(dir)) break;
+    if (!fs29.existsSync(dir)) break;
     const pidOwner = readPidFile(dir);
     if (pidOwner === process.pid) ownedPidFile = true;
     else if (ownedPidFile && pidOwner !== null) break;
@@ -17747,7 +18645,7 @@ async function runWorkerLoop(dir, pollIntervalMs, shouldStop = () => false) {
     }
     if (Date.now() - lastKnownRootsSweepMs >= KNOWN_ROOTS_SWEEP_INTERVAL_MS) {
       try {
-        const result = sweepKnownRoots(path28.join(dir, "global.db"));
+        const result = sweepKnownRoots(path29.join(dir, "global.db"));
         if (result.flaggedRoots.length > 0) {
           appendWorkerErrorLog(
             dir,
@@ -17770,7 +18668,7 @@ function runDetachedWorkerDaemon() {
   process.on("exit", () => {
     if (readPidFile(dir) === process.pid) {
       try {
-        fs28.rmSync(workerPidPath(dir), { force: true });
+        fs29.rmSync(workerPidPath(dir), { force: true });
       } catch {
       }
     }
@@ -17780,26 +18678,26 @@ function runDetachedWorkerDaemon() {
 }
 
 // src/hooks_index.ts
-import * as fs29 from "node:fs";
-import * as path29 from "node:path";
+import * as fs30 from "node:fs";
+import * as path30 from "node:path";
 function dirtyQueuePath() {
-  return path29.join(dataDir(), "queue", "dirty.txt");
+  return path30.join(dataDir(), "queue", "dirty.txt");
 }
 function appendDirtyPath(normalizedPath2) {
   const queuePath = dirtyQueuePath();
-  const dir = path29.dirname(queuePath);
+  const dir = path30.dirname(queuePath);
   try {
     ensureDirSync(dir);
   } catch (e) {
-    if (e.code !== "EEXIST" || !fs29.existsSync(dir)) throw e;
+    if (e.code !== "EEXIST" || !fs30.existsSync(dir)) throw e;
   }
   let leadingNewline = "";
   try {
-    const existing = fs29.readFileSync(queuePath, "utf8");
+    const existing = fs30.readFileSync(queuePath, "utf8");
     if (existing.length > 0 && !existing.endsWith("\n")) leadingNewline = "\n";
   } catch {
   }
-  fs29.appendFileSync(queuePath, `${leadingNewline}${encodeDirtyQueueLine(normalizedPath2)}
+  fs30.appendFileSync(queuePath, `${leadingNewline}${encodeDirtyQueueLine(normalizedPath2)}
 `);
 }
 function enqueueDirtyPathSafe(filePath, opts) {
@@ -17812,7 +18710,7 @@ function getDirtyPaths() {
   const queuePath = dirtyQueuePath();
   let raw;
   try {
-    raw = fs29.readFileSync(queuePath, "utf8");
+    raw = fs30.readFileSync(queuePath, "utf8");
   } catch {
     return [];
   }
@@ -17821,9 +18719,9 @@ function getDirtyPaths() {
 function preCompactIndexHandler(_event) {
   const paths = getDirtyPaths();
   if (paths.length > 0) {
-    const sidecar = path29.join(dataDir(), "queue", "pending.txt");
+    const sidecar = path30.join(dataDir(), "queue", "pending.txt");
     try {
-      ensureDirSync(path29.dirname(sidecar));
+      ensureDirSync(path30.dirname(sidecar));
       atomicWriteBytes(sidecar, Buffer.from(`${paths.join("\n")}
 `, "utf8"));
     } catch {
@@ -18017,6 +18915,8 @@ export {
   getGlobMatchCount,
   setLastTabContext,
   getLastTabContext,
+  hasSeenImage,
+  recordSeenImage,
   recordOutstandingAgentSpawn,
   getOutstandingAgentSpawns,
   removeOutstandingAgentSpawn,
@@ -18040,6 +18940,8 @@ export {
   installCodex,
   uninstallCodex,
   isCodexInstalled,
+  copilotCliUserRoot,
+  copilotCliMcpToolsDir,
   copilotCliConfigPath,
   copilotCliScriptPath,
   installCopilotCli,
@@ -18063,11 +18965,13 @@ export {
   loadBlob,
   listBlobs,
   pruneBlobs,
+  estimateTokensFromLength,
   estimateTokens,
   trimToBudget,
   capJsonRows,
   SESSIONS_SUBDIR,
   AGENT_SALT_MARKER,
+  sessionSidecarPath,
   listSiblingSessionStates,
   loadSessionState,
   saveSessionState,
@@ -18106,6 +19010,7 @@ export {
   formatShrinkSummary,
   isImagePath,
   probeImageMeta,
+  imageQualifiesForShrink,
   shrinkImage,
   compactPathFor,
   isCompactFresh,
@@ -18116,6 +19021,8 @@ export {
   compactDoc,
   OVER_FETCH_FACTOR,
   MAX_OVER_FETCH,
+  isAvailable,
+  embeddingBackendLoadError,
   searchSemantic,
   mergeNearbyHits,
   embeddingsDepsAvailable,