token-goat 2.9.12 → 2.9.13

package/dist/{token-goat-chunk-GM6QZWCF.mjs → token-goat-chunk-ZZI3IDQZ.mjs}

@@ -2,46 +2,57 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   OUTPUT_FIRST_TOOL_RESPONSE_KEYS,
-  SOURCE_HINT,
-  TREE_SITTER_LANGUAGES,
   VSCODE_TOOL_NAME_KEY,
   contextOutput,
   denyOutput,
-  detectHarness,
-  detectLanguage,
-  detectLanguageOfFile,
   emitRewrite,
   estimateTokens,
   extractToolResponseField,
+  getCwd,
+  getFilePath,
+  hasUnquotedOperator,
+  isRewriteWorthwhile,
+  materializeShrunkImageFile,
+  passOutput,
+  registerHook,
+  resolveMinNetSavingsBytes,
+  sessionStateKey
+} from "./token-goat-chunk-JOXLE672.mjs";
+import {
+  DEFAULT_MAX_AGE_MS,
+  DEFAULT_MAX_COUNT,
+  blobPath,
+  isBlobStale,
+  loadBlob,
+  storeBlob,
+  sweepCacheRoots
+} from "./token-goat-chunk-UM47DRD3.mjs";
+import {
+  SOURCE_HINT,
+  TREE_SITTER_LANGUAGES,
+  detectHarness,
+  detectLanguage,
+  detectLanguageOfFile,
   fileIsAbsent,
   findProject,
   fingerprintContent,
   fingerprintFile,
-  getCwd,
   getDb,
-  getFilePath,
   getHarnessName,
-  hasUnquotedOperator,
   isAutoTriggerMultiplierExplicit,
-  isRewriteWorthwhile,
   isUnderSystemTemp,
   languageHasFlag,
   loadConfig,
   makeProjectAt,
-  materializeShrunkImageFile,
-  passOutput,
   recordStat,
   redactIfDotenv,
   redactSecrets,
   refineLanguageByContent,
-  registerHook,
-  resolveMinNetSavingsBytes,
   resolveProjectRoot,
   savedTokensFromBytes,
-  sessionStateKey,
   shortFingerprint,
   summarize
-} from "./token-goat-chunk-TOGYS5A7.mjs";
+} from "./token-goat-chunk-UMXJN7DI.mjs";
 import {
   registerReset
 } from "./token-goat-chunk-EEIDFMEM.mjs";
@@ -71,18 +82,20 @@ import {
   extractErrorMessage,
   fenceUntrustedContent,
   fenceUntrustedFileContent,
-  fenceUntrustedOcrText,
   filtersFilteredToEmptyNotice,
   findHtmlHeadingMatches,
   foldPath,
   foldPathForContainment,
+  formatSymbolLocation,
   globalDbPath,
+  ipynbToVirtualSource,
   isCaseInsensitiveFs,
   isCodeFenceDelimiter,
   isInsideRoot,
   isTestFile,
   isUncOrDevicePath,
   isUnderBlockedRoot,
+  isVirtualIndexedPath,
   isWithinQuietHours,
   normalizePath,
   normalizePathForwardSlash,
@@ -103,7 +116,7 @@ import {
   toKB,
   tokenGoatHome,
   withFileLock
-} from "./token-goat-chunk-LOCOX2ML.mjs";
+} from "./token-goat-chunk-QKXBGBQR.mjs";
 import {
   __commonJS,
   __toESM,
@@ -2258,9 +2271,9 @@ var require_decoder = __commonJS({
         return a < 0 ? 0 : a > 255 ? 255 : a;
       }
       constructor.prototype = {
-        load: function load3(path24) {
+        load: function load3(path22) {
           var xhr = new XMLHttpRequest();
-          xhr.open("GET", path24, true);
+          xhr.open("GET", path22, true);
           xhr.responseType = "arraybuffer";
           xhr.onload = (function() {
             var data = new Uint8Array(xhr.response || xhr.mozResponseArrayBuffer);
@@ -2836,10 +2849,13 @@ import * as fs from "node:fs";
 
 // src/document_refusal.ts
 init_define_import_meta_env();
+var MAX_DOCUMENT_WORK_MILLIS = 6e4;
 var DocumentRefusedError = class extends Error {
-  constructor(message, name) {
+  transient;
+  constructor(message, name, transient = false) {
     super(message);
     this.name = name;
+    this.transient = transient;
   }
 };
 
@@ -2863,6 +2879,11 @@ function createLazyModuleLoader(load3, errorLabel) {
 // src/xml_parser.ts
 init_define_import_meta_env();
 var MAX_XML_DEPTH = 512;
+var XmlTooDeepError = class extends DocumentRefusedError {
+  constructor(message) {
+    super(message, "XmlTooDeepError");
+  }
+};
 var NAMED_ENTITIES = {
   lt: "<",
   gt: ">",
@@ -3060,7 +3081,7 @@ function parseXml(xml) {
       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)`);
+      throw new XmlTooDeepError(`XML nesting deeper than ${MAX_XML_DEPTH} elements; refusing to parse (this file is not something any office application produces)`);
     }
     stack.push(frame);
   }
@@ -3145,10 +3166,16 @@ function unzipBounded(mod, data, opts) {
 }
 
 // src/ooxml_extract.ts
-var MAX_OOXML_WORK_MILLIS = 6e4;
+var MAX_OOXML_WORK_MILLIS = MAX_DOCUMENT_WORK_MILLIS;
 var OoxmlTookTooLongError = class extends DocumentRefusedError {
   constructor(message) {
-    super(message, "OoxmlTookTooLongError");
+    super(message, "OoxmlTookTooLongError", true);
+  }
+};
+var NotAnOfficeDocumentError = class extends DocumentRefusedError {
+  constructor(message, cause) {
+    super(message, "NotAnOfficeDocumentError");
+    if (cause !== void 0) this.cause = cause;
   }
 };
 function ooxmlWorkDeadline() {
@@ -3177,7 +3204,7 @@ async function readOoxmlZip(filePath, kind) {
   } catch (err) {
     throw new Error(accessFailureMessage(err, filePath), { cause: err });
   }
-  if (!stat2.isFile()) throw new Error(`not a valid ${kind} file: ${filePath}`);
+  if (!stat2.isFile()) throw new NotAnOfficeDocumentError(`not a valid ${kind} file: ${filePath}`);
   if (stat2.size > MAX_ZIP_INPUT_BYTES) throw new ZipInputTooLargeError(filePath, stat2.size, MAX_ZIP_INPUT_BYTES);
   let data;
   try {
@@ -3189,12 +3216,30 @@ async function readOoxmlZip(filePath, kind) {
     return unzipBounded(fflate, new Uint8Array(data), { limitBytes: MAX_ZIP_OUTPUT_BYTES, shouldExtract: () => true });
   } catch (err) {
     if (err instanceof ZipOutputTooLargeError) throw err;
-    throw new Error(`not a valid ${kind} file: ${filePath}`, { cause: err });
+    throw new NotAnOfficeDocumentError(`not a valid ${kind} file: ${filePath}`, err);
+  }
+}
+var MAX_OOXML_PART_BYTES = 32 * 1024 * 1024;
+var OoxmlPartTooLargeError = class extends DocumentRefusedError {
+  constructor(entryPath, bytes) {
+    super(`${entryPath} is ${bytes} bytes, past the ${MAX_OOXML_PART_BYTES}-byte limit for one part of an office file. Split the document, or extract from a smaller copy.`, "OoxmlPartTooLargeError");
+  }
+};
+var MAX_OOXML_DOCUMENT_PART_BYTES = 64 * 1024 * 1024;
+var OoxmlDocumentTooLargeError = class extends DocumentRefusedError {
+  constructor(entryPath, spentBytes, partBytes) {
+    super(`decoding ${entryPath} (${partBytes} bytes, after ${spentBytes} already decoded) would take this office file past the ${MAX_OOXML_DOCUMENT_PART_BYTES}-byte limit on the XML one document may have decoded at once. Split the document, or extract from a smaller copy.`, "OoxmlDocumentTooLargeError");
   }
+};
+function ooxmlPartBudget() {
+  return { spent: 0 };
 }
-function decodeZipEntry(entries, entryPath) {
+function decodeZipEntry(entries, entryPath, budget) {
   const bytes = entries[entryPath];
   if (bytes === void 0) return null;
+  if (bytes.length > MAX_OOXML_PART_BYTES) throw new OoxmlPartTooLargeError(entryPath, bytes.length);
+  if (budget.spent + bytes.length > MAX_OOXML_DOCUMENT_PART_BYTES) throw new OoxmlDocumentTooLargeError(entryPath, budget.spent, bytes.length);
+  budget.spent += bytes.length;
   return new TextDecoder("utf-8").decode(bytes);
 }
 async function parseOoxmlPart(xmlText) {
@@ -3273,8 +3318,8 @@ function headingLevel(styleVal) {
 }
 async function loadDocumentBody(filePath) {
   const entries = await readOoxmlZip(filePath, ".docx");
-  const xml = decodeZipEntry(entries, "word/document.xml");
-  if (xml === null) throw new Error(`no word/document.xml found in ${filePath} (not a valid .docx?)`);
+  const xml = decodeZipEntry(entries, "word/document.xml", ooxmlPartBudget());
+  if (xml === null) throw new NotAnOfficeDocumentError(`no word/document.xml found in ${filePath} (not a valid .docx?)`);
   return parseOoxmlPart(xml);
 }
 async function docxOutline(filePath) {
@@ -3295,6 +3340,68 @@ async function docxText(filePath) {
   const lines2 = paragraphs.map((p) => collectTextRuns(p, "w:t").join("")).filter((t) => t.trim().length > 0);
   return lines2.join("\n\n");
 }
+async function docxTables(filePath) {
+  const parsed = await loadDocumentBody(filePath);
+  const tbls = collectElements(parsed, "w:tbl");
+  const out = [];
+  for (let i = 0; i < tbls.length; i++) {
+    const tbl = tbls[i];
+    const trElements = collectElements(tbl, "w:tr");
+    const rows = [];
+    let maxCols = 0;
+    for (const tr of trElements) {
+      const tcElements = collectElements(tr, "w:tc");
+      const rowCells = [];
+      for (const tc of tcElements) {
+        const cellText2 = collectTextRuns(tc, "w:t").join("").replace(/\r?\n/g, " ").trim();
+        rowCells.push(cellText2);
+      }
+      if (rowCells.length > maxCols) maxCols = rowCells.length;
+      rows.push(rowCells);
+    }
+    if (rows.length > 0) {
+      out.push({
+        tableIndex: i + 1,
+        rowCount: rows.length,
+        colCount: maxCols,
+        rows
+      });
+    }
+  }
+  return out;
+}
+function formatDocxTables(tables, opts) {
+  if (tables.length === 0) return "no tables found in document";
+  const selected = opts?.tableIndex !== void 0 ? tables.filter((t) => t.tableIndex === opts.tableIndex) : tables;
+  if (selected.length === 0) {
+    return `table ${opts?.tableIndex} not found (document has ${tables.length} table${tables.length === 1 ? "" : "s"})`;
+  }
+  const sections = [];
+  for (const table of selected) {
+    const lines2 = [
+      `Table ${table.tableIndex} (${table.rowCount} row${table.rowCount === 1 ? "" : "s"} x ${table.colCount} col${table.colCount === 1 ? "" : "s"}):`
+    ];
+    if (table.rows.length === 0) {
+      lines2.push("  (empty)");
+      sections.push(lines2.join("\n"));
+      continue;
+    }
+    const header = table.rows[0];
+    const padCols = Math.max(table.colCount, 1);
+    const paddedHeader = [...header];
+    while (paddedHeader.length < padCols) paddedHeader.push("");
+    lines2.push("| " + paddedHeader.map((c) => displaySafeText(c.replace(/\|/g, "\\|"))).join(" | ") + " |");
+    lines2.push("| " + Array.from({ length: padCols }, () => "---").join(" | ") + " |");
+    for (let r = 1; r < table.rows.length; r++) {
+      const row = table.rows[r];
+      const paddedRow = [...row];
+      while (paddedRow.length < padCols) paddedRow.push("");
+      lines2.push("| " + paddedRow.map((c) => displaySafeText(c.replace(/\|/g, "\\|"))).join(" | ") + " |");
+    }
+    sections.push(lines2.join("\n"));
+  }
+  return sections.join("\n\n");
+}
 
 // src/pptx_extract.ts
 init_define_import_meta_env();
@@ -3319,9 +3426,9 @@ function tableRowBlocks(parsedSlide) {
   }
   return blocks;
 }
-async function slidePathsInPresentationOrder(entries) {
-  const presXml = decodeZipEntry(entries, "ppt/presentation.xml");
-  const relsXml = decodeZipEntry(entries, "ppt/_rels/presentation.xml.rels");
+async function slidePathsInPresentationOrder(entries, budget) {
+  const presXml = decodeZipEntry(entries, "ppt/presentation.xml", budget);
+  const relsXml = decodeZipEntry(entries, "ppt/_rels/presentation.xml.rels", budget);
   if (presXml === null || relsXml === null) return null;
   const presParsed = await parseOoxmlPart(presXml);
   const relsParsed = await parseOoxmlPart(relsXml);
@@ -3332,24 +3439,28 @@ async function slidePathsInPresentationOrder(entries) {
     }
   }
   const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
   for (const sldId of collectElements(presParsed, "p:sldId")) {
     const rid = sldId["@_r:id"];
     if (rid === void 0) continue;
     const target = ridToTarget.get(rid);
     if (target === void 0) continue;
     const normalized = target.startsWith("slides/") ? `ppt/${target}` : `ppt/slides/${target}`;
-    if (entries[normalized] !== void 0) ordered.push(normalized);
+    if (entries[normalized] === void 0 || seen.has(normalized)) continue;
+    seen.add(normalized);
+    ordered.push(normalized);
   }
   return ordered.length > 0 ? ordered : null;
 }
 async function listSlideParts(filePath) {
   const entries = await readOoxmlZip(filePath, ".pptx");
-  const slidePaths = await slidePathsInPresentationOrder(entries) ?? sortNumberedParts(
+  const budget = ooxmlPartBudget();
+  const slidePaths = await slidePathsInPresentationOrder(entries, budget) ?? sortNumberedParts(
     Object.keys(entries).filter((p) => /^ppt\/slides\/slide\d+\.xml$/.test(p)),
     /slide(\d+)\.xml$/
   );
-  if (slidePaths.length === 0) throw new Error(`no slides found in ${filePath} (not a valid .pptx?)`);
-  return { entries, slidePaths };
+  if (slidePaths.length === 0) throw new NotAnOfficeDocumentError(`no slides found in ${filePath} (not a valid .pptx?)`);
+  return { entries, slidePaths, budget };
 }
 function relsPathFor(slidePath) {
   const idx = slidePath.lastIndexOf("/");
@@ -3366,8 +3477,8 @@ function resolveRelativeTarget(basePath, target) {
   }
   return resolved.join("/");
 }
-async function notesPathFor(entries, slidePath) {
-  const relsXml = decodeZipEntry(entries, relsPathFor(slidePath));
+async function notesPathFor(entries, slidePath, budget) {
+  const relsXml = decodeZipEntry(entries, relsPathFor(slidePath), budget);
   if (relsXml === null) return null;
   const relsParsed = await parseOoxmlPart(relsXml);
   for (const rel of collectElements(relsParsed, "Relationship")) {
@@ -3377,26 +3488,27 @@ async function notesPathFor(entries, slidePath) {
   }
   return null;
 }
-async function parseSlide(entries, path24) {
-  const xml = decodeZipEntry(entries, path24);
-  if (xml === null) throw new Error(`missing part: ${path24}`);
+async function parseSlide(entries, path22, budget) {
+  const xml = decodeZipEntry(entries, path22, budget);
+  if (xml === null) throw new Error(`missing part: ${path22}`);
   return parseOoxmlPart(xml);
 }
-async function notesTextFor(entries, notesPath) {
+async function notesTextFor(entries, notesPath, budget) {
   if (notesPath === null) return "";
-  const xml = decodeZipEntry(entries, notesPath);
+  const xml = decodeZipEntry(entries, notesPath, budget);
   if (xml === null) return "";
   const parsed = await parseOoxmlPart(xml);
   const shapes = collectElements(parsed, "p:sp");
   const bodyShape = shapes.find((s) => shapePlaceholderType(s) === "body");
   return bodyShape !== void 0 ? shapeText(bodyShape) : collectTextRuns(parsed, "a:t").join(" ").trim();
 }
-async function pptxOutline(filePath) {
-  const { entries, slidePaths } = await listSlideParts(filePath);
+async function pptxOutline(filePath, deadline = ooxmlWorkDeadline()) {
+  const { entries, slidePaths, budget } = await listSlideParts(filePath);
   const out = [];
   for (let i = 0; i < slidePaths.length; i++) {
-    const path24 = slidePaths[i];
-    const parsed = await parseSlide(entries, path24);
+    assertOoxmlWithinDeadline(deadline, "Narrow the read to specific slides with pptx-slide, or use a smaller deck.");
+    const path22 = slidePaths[i];
+    const parsed = await parseSlide(entries, path22, budget);
     const shapes = slideShapes(parsed);
     const titleShape = shapes.find((s) => {
       const t = shapePlaceholderType(s);
@@ -3405,61 +3517,63 @@ 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, path24))).length > 0;
+    const hasNotes = (await notesTextFor(entries, await notesPathFor(entries, path22, budget), budget)).length > 0;
     out.push({ slide: i + 1, title, bodyChars, hasNotes });
   }
   return out;
 }
-async function slideTextFromParts(entries, slidePaths, slideNumber, includeNotes) {
+async function slideTextFromParts(entries, slidePaths, slideNumber, includeNotes, budget) {
   if (slideNumber < 1 || slideNumber > slidePaths.length) {
     throw new Error(`slide ${slideNumber} out of range (this deck has ${slidePaths.length} slides)`);
   }
-  const path24 = slidePaths[slideNumber - 1];
-  const parsed = await parseSlide(entries, path24);
+  const path22 = slidePaths[slideNumber - 1];
+  const parsed = await parseSlide(entries, path22, budget);
   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, path24));
+    const notes = await notesTextFor(entries, await notesPathFor(entries, path22, budget), budget);
     if (notes.length > 0) lines2.push("", "## Speaker notes", notes);
   }
   return lines2.join("\n\n");
 }
 async function pptxSlideText(filePath, slideNumber, includeNotes) {
-  const { entries, slidePaths } = await listSlideParts(filePath);
-  return slideTextFromParts(entries, slidePaths, slideNumber, includeNotes);
+  const { entries, slidePaths, budget } = await listSlideParts(filePath);
+  return slideTextFromParts(entries, slidePaths, slideNumber, includeNotes, budget);
 }
 async function pptxAllSlidesText(filePath, includeNotes, deadline = ooxmlWorkDeadline()) {
-  const { entries, slidePaths } = await listSlideParts(filePath);
+  const { entries, slidePaths, budget } = await listSlideParts(filePath);
   const slideTexts = [];
   for (let i = 1; i <= slidePaths.length; i++) {
     assertOoxmlWithinDeadline(deadline, "Narrow the read to specific slides with pptx-slide, or use a smaller deck.");
-    slideTexts.push(await slideTextFromParts(entries, slidePaths, i, includeNotes));
+    slideTexts.push(await slideTextFromParts(entries, slidePaths, i, includeNotes, budget));
   }
   return slideTexts.join("\n\n");
 }
-async function pptxNotesText(filePath, slideNumber) {
-  const { entries, slidePaths } = await listSlideParts(filePath);
+async function pptxNotesText(filePath, slideNumber, deadline = ooxmlWorkDeadline()) {
+  const { entries, slidePaths, budget } = await listSlideParts(filePath);
   const targets = slideNumber !== void 0 ? [slideNumber] : slidePaths.map((_, i) => i + 1);
   const sections = [];
   for (const n of targets) {
+    assertOoxmlWithinDeadline(deadline, "Narrow the read to one slide with the slide-number argument, or use a smaller deck.");
     if (n < 1 || n > slidePaths.length) throw new Error(`slide ${n} out of range (this deck has ${slidePaths.length} slides)`);
-    const notesPath = await notesPathFor(entries, slidePaths[n - 1]);
-    const text = await notesTextFor(entries, notesPath);
+    const notesPath = await notesPathFor(entries, slidePaths[n - 1], budget);
+    const text = await notesTextFor(entries, notesPath, budget);
     if (text.length > 0) sections.push(`# Slide ${n} notes
 
 ${text}`);
   }
   return sections.join("\n\n");
 }
-async function pptxTextGrep(filePath, pattern) {
-  const { entries, slidePaths } = await listSlideParts(filePath);
+async function pptxTextGrep(filePath, pattern, deadline = ooxmlWorkDeadline()) {
+  const { entries, slidePaths, budget } = await listSlideParts(filePath);
   const guarded = compileGuardedRegex(pattern, "i");
   if (!guarded.ok) throw new Error(`invalid --grep pattern: ${pattern} -- the pattern ${guarded.reason}`);
   const re = guarded.re;
   const out = [];
   for (let i = 0; i < slidePaths.length; i++) {
-    const parsed = await parseSlide(entries, slidePaths[i]);
+    assertOoxmlWithinDeadline(deadline, "Narrow the read to specific slides with pptx-slide, or use a smaller deck.");
+    const parsed = await parseSlide(entries, slidePaths[i], budget);
     const text = collectTextRuns(parsed, "a:t").join(" ");
     if (re.test(text)) {
       const idx = text.search(re);
@@ -5198,13 +5312,30 @@ var parse = function(data, opts = {}) {
 };
 
 // src/csv_query.ts
+var DELIMITER_CANDIDATES = [",", "	", ";", "|"];
+var DELIMITER_SAMPLE_ROWS = 5;
+function detectDelimiter(content) {
+  const slice = content.slice(0, 1e4);
+  if (slice.trim() === "") return ",";
+  for (const cand of DELIMITER_CANDIDATES) {
+    let rows;
+    try {
+      rows = parse(slice, { columns: false, skip_empty_lines: true, trim: true, delimiter: cand, bom: true, relax_quotes: true, to: DELIMITER_SAMPLE_ROWS });
+    } catch {
+      continue;
+    }
+    if ((rows[0]?.length ?? 0) < 2) continue;
+    return cand;
+  }
+  return ",";
+}
 function parseRecords(content, opts) {
-  const delimiter = opts.delimiter ?? ",";
+  const delimiter = opts.delimiter ?? detectDelimiter(content);
   if (opts.noHeader === true) {
-    const rows = parse(content, { columns: false, skip_empty_lines: true, trim: true, delimiter, bom: true, relax_column_count: true });
+    const rows = parse(content, { columns: false, skip_empty_lines: true, trim: true, delimiter, bom: true, relax_column_count: true, relax_quotes: true });
     return rows.map((row) => Object.fromEntries(row.map((cell, i) => [`col${i + 1}`, cell])));
   }
-  const header = csvHeader(content, opts);
+  const header = csvHeader(content, { ...opts, delimiter });
   const dupes = header.filter((name, i) => name !== "" && header.indexOf(name) !== i);
   if (dupes.length > 0) {
     const unique = [...new Set(dupes)];
@@ -5212,13 +5343,13 @@ function parseRecords(content, opts) {
       `duplicate column ${unique.length === 1 ? "name" : "names"} in header: ${unique.join(", ")} \u2014 rename the duplicates or pass --no-header to address columns positionally as col1, col2, \u2026`
     );
   }
-  return parse(content, { columns: true, skip_empty_lines: true, trim: true, delimiter, bom: true, relax_column_count: true });
+  return parse(content, { columns: true, skip_empty_lines: true, trim: true, delimiter, bom: true, relax_column_count: true, relax_quotes: true });
 }
 function csvHeader(content, opts) {
   if (opts.noHeader === true) return [];
-  const delimiter = opts.delimiter ?? ",";
+  const delimiter = opts.delimiter ?? detectDelimiter(content);
   try {
-    const rows = parse(content, { columns: false, skip_empty_lines: true, trim: true, delimiter, bom: true, to: 1 });
+    const rows = parse(content, { columns: false, skip_empty_lines: true, trim: true, delimiter, bom: true, to: 1, relax_quotes: true });
     return rows[0] ?? [];
   } catch {
     return [];
@@ -5602,30 +5733,39 @@ function makeWorksheet(name, data) {
     }
   };
 }
-async function readXlsxWorkbook(filePath) {
+async function readXlsxWorkbook(filePath, deadline = ooxmlWorkDeadline()) {
   const entries = await readOoxmlZip(filePath, ".xlsx");
-  const workbookXml = decodeZipEntry(entries, "xl/workbook.xml");
-  if (workbookXml === null) throw new Error(`not a valid .xlsx file: ${filePath}`);
+  const budget = ooxmlPartBudget();
+  const workbookXml = decodeZipEntry(entries, "xl/workbook.xml", budget);
+  if (workbookXml === null) throw new NotAnOfficeDocumentError(`not a valid .xlsx file: ${filePath}`);
   const workbookRoot = await parseOoxmlPart(workbookXml);
   const wbNode = workbookRoot?.["workbook"];
   if (wbNode === void 0 || wbNode === null || typeof wbNode !== "object") {
-    throw new Error(`not a valid .xlsx file: ${filePath}`);
+    throw new NotAnOfficeDocumentError(`not a valid .xlsx file: ${filePath}`);
   }
   const wb = wbNode;
   const date1904 = isTruthyAttr(attr(wb["workbookPr"], "date1904"));
-  const relsXml = decodeZipEntry(entries, "xl/_rels/workbook.xml.rels");
+  const relsXml = decodeZipEntry(entries, "xl/_rels/workbook.xml.rels", budget);
   const rels = parseWorkbookRels(relsXml === null ? null : await parseOoxmlPart(relsXml));
-  const sharedXml = decodeZipEntry(entries, "xl/sharedStrings.xml");
+  const sharedXml = decodeZipEntry(entries, "xl/sharedStrings.xml", budget);
   const shared = sharedXml === null ? [] : parseSharedStrings(await parseOoxmlPart(sharedXml));
-  const stylesXml = decodeZipEntry(entries, "xl/styles.xml");
+  const stylesXml = decodeZipEntry(entries, "xl/styles.xml", budget);
   const styles = parseStyles(stylesXml, stylesXml === null ? null : await parseOoxmlPart(stylesXml));
   const worksheets = [];
+  const parsedByPart = /* @__PURE__ */ new Map();
   for (const sheet of asArray(wb["sheets"]?.["sheet"])) {
     const name = attr(sheet, "name") ?? "";
     const rid = attr(sheet, "r:id") ?? attr(sheet, "relationshipId");
     const partPath = rid === void 0 ? void 0 : rels.get(rid);
-    const sheetXml = partPath === void 0 ? null : decodeZipEntry(entries, partPath);
+    const cached = partPath === void 0 ? void 0 : parsedByPart.get(partPath);
+    if (cached !== void 0) {
+      worksheets.push(makeWorksheet(name, cached));
+      continue;
+    }
+    assertOoxmlWithinDeadline(deadline, "Narrow the read to specific sheets with xlsx-head, or use a smaller workbook.");
+    const sheetXml = partPath === void 0 ? null : decodeZipEntry(entries, partPath, budget);
     const data = sheetXml === null ? { cells: /* @__PURE__ */ new Map(), rowCount: 0, columnCount: 0, populatedRows: 0 } : parseSheet(await parseOoxmlPart(sheetXml), shared, styles, date1904);
+    if (partPath !== void 0) parsedByPart.set(partPath, data);
     worksheets.push(makeWorksheet(name, data));
   }
   return {
@@ -5637,11 +5777,18 @@ async function readXlsxWorkbook(filePath) {
 // src/xlsx_extract.ts
 var loadWorkbook = readXlsxWorkbook;
 function requireSheet(wb, sheetName) {
-  const ws = wb.getWorksheet(sheetName);
-  if (ws === void 0) {
-    throw new Error(`unknown sheet: ${sheetName} (available: ${wb.worksheets.map((s) => s.name).join(", ")})`);
+  if (sheetName !== void 0 && sheetName.trim() !== "") {
+    const ws = wb.getWorksheet(sheetName);
+    if (ws === void 0) {
+      throw new Error(`unknown sheet: ${sheetName} (available: ${wb.worksheets.map((s) => s.name).join(", ")})`);
+    }
+    return ws;
   }
-  return ws;
+  const first = wb.worksheets[0];
+  if (first === void 0) {
+    throw new Error("workbook contains no worksheets");
+  }
+  return first;
 }
 var MAX_XLSX_SCAN_CELLS = 2e7;
 var XlsxScanTooLargeError = class extends DocumentRefusedError {
@@ -5741,49 +5888,68 @@ function usedRange(ws) {
   }
   return { ref: `A1:${indexToColLetters(cols)}${rows}`, rows, cols };
 }
-async function listSheets(filePath) {
-  const wb = await loadWorkbook(filePath);
+async function listSheets(filePath, deadline = ooxmlWorkDeadline()) {
+  const wb = await loadWorkbook(filePath, deadline);
   return wb.worksheets.map((ws) => {
+    assertOoxmlWithinDeadline(deadline, "Narrow the read to specific sheets with xlsx-head, or use a smaller workbook.");
     const { ref: ref2, rows, cols } = usedRange(ws);
     return { name: ws.name, ref: ref2, rows, cols };
   });
 }
-function headSheetFromWorksheet(ws, rows) {
+function headSheetFromWorksheet(ws, rows, columns) {
   assertScannableExtent(ws);
   const rowCount = ws.rowCount || 0;
+  const sheetCols = ws.columnCount || 0;
+  const scanRows = Math.min(rowCount, rows + 1);
   const aoa = [];
-  let sheetCols = 0;
-  for (let r = 1; r <= rowCount; r++) {
-    const row = ws.getRow(r);
-    let maxCol = 0;
-    row.eachCell({ includeEmpty: false }, (_c, colNumber) => {
-      if (colNumber > maxCol) maxCol = colNumber;
-    });
-    if (maxCol > sheetCols) sheetCols = maxCol;
+  for (let r = 1; r <= scanRows; r++) {
     const rowVals = [];
-    for (let c = 1; c <= maxCol; c++) {
+    for (let c = 1; c <= sheetCols; c++) {
       rowVals.push(cellText(ws.getCell(encodeCell({ r, c }))));
     }
     aoa.push(rowVals);
   }
-  const header = Array.from({ length: sheetCols }, (_, i) => String(aoa[0]?.[i] ?? ""));
-  const dataRows = aoa.slice(1, 1 + rows).map(
+  let header = Array.from({ length: sheetCols }, (_, i) => String(aoa[0]?.[i] ?? ""));
+  let dataRows = aoa.slice(1, 1 + rows).map(
     (r) => Array.from({ length: sheetCols }, (_, i) => String(r[i] ?? ""))
   );
+  if (columns !== void 0 && columns.length > 0) {
+    const normCols = columns.map((c) => c.trim()).filter(Boolean);
+    const selectedIndices = [];
+    for (const req of normCols) {
+      let idx = header.findIndex((h) => h === req);
+      if (idx === -1) {
+        idx = header.findIndex((h) => h.toLowerCase() === req.toLowerCase());
+      }
+      if (idx === -1 && /^[A-Za-z]+$/.test(req)) {
+        const colNum = colLettersToIndex(req);
+        if (colNum >= 1 && colNum <= sheetCols) {
+          idx = colNum - 1;
+        }
+      }
+      if (idx !== -1 && !selectedIndices.includes(idx)) {
+        selectedIndices.push(idx);
+      } else if (idx === -1) {
+        throw new Error(`unknown column: ${req} (available: ${header.filter(Boolean).join(", ")})`);
+      }
+    }
+    header = selectedIndices.map((i) => header[i] ?? "");
+    dataRows = dataRows.map((r) => selectedIndices.map((i) => r[i] ?? ""));
+  }
   const lines2 = [header.map(quoteCsvCell).join(",")];
   for (const r of dataRows) lines2.push(r.map(quoteCsvCell).join(","));
-  if (aoa.length - 1 > dataRows.length) {
-    lines2.push(`...(${aoa.length - 1 - dataRows.length} more rows elided; use --rows to see more, or xlsx-query for filtering)`);
+  if (rowCount - 1 > dataRows.length) {
+    lines2.push(`...(${rowCount - 1 - dataRows.length} more rows elided; use --rows to see more, or xlsx-query for filtering)`);
   }
   return lines2.join("\n");
 }
-async function headSheet(filePath, sheetName, rows) {
+async function headSheet(filePath, sheetName, rows = 20, columns) {
   const wb = await loadWorkbook(filePath);
   const ws = requireSheet(wb, sheetName);
-  return headSheetFromWorksheet(ws, rows);
+  return headSheetFromWorksheet(ws, rows, columns);
 }
 async function allSheetsHeadText(filePath, rows, deadline = ooxmlWorkDeadline()) {
-  const wb = await loadWorkbook(filePath);
+  const wb = await loadWorkbook(filePath, deadline);
   const sheetTexts = [];
   for (const ws of wb.worksheets) {
     assertOoxmlWithinDeadline(deadline, "Narrow the read to specific sheets with xlsx-head, or use a smaller workbook.");
@@ -5840,6 +6006,60 @@ async function querySheet(filePath, sheetName, opts) {
   const csvText = await sheetToCsv(ws);
   return queryCsv(csvText, opts);
 }
+async function xlsxColumns(filePath, sheetName, sampleLimit = 100) {
+  const wb = await loadWorkbook(filePath);
+  const ws = requireSheet(wb, sheetName);
+  assertScannableExtent(ws);
+  const rowCount = ws.rowCount || 0;
+  const { cols: sheetCols } = usedRange(ws);
+  if (rowCount === 0 || sheetCols === 0) {
+    return { sheetName: ws.name, totalSheetRows: 0, sampleRows: 0, columns: [] };
+  }
+  const sampleRows = Math.min(Math.max(1, sampleLimit), Math.max(1, rowCount - 1));
+  const headers = [];
+  for (let c = 1; c <= sheetCols; c++) {
+    const val = cellText(ws.getCell(encodeCell({ r: 1, c })));
+    headers.push(val || `(col ${indexToColLetters(c)})`);
+  }
+  const colSummaries = headers.map((name, i) => ({
+    letter: indexToColLetters(i + 1),
+    name,
+    index: i + 1,
+    nonEmptyRows: 0,
+    sampleRows,
+    sampleValues: []
+  }));
+  for (let r = 2; r <= 1 + sampleRows; r++) {
+    for (let c = 1; c <= sheetCols; c++) {
+      const txt = cellText(ws.getCell(encodeCell({ r, c })));
+      if (txt !== "") {
+        const summary = colSummaries[c - 1];
+        summary.nonEmptyRows++;
+        if (summary.sampleValues.length < 3 && !summary.sampleValues.includes(txt)) {
+          summary.sampleValues.push(txt);
+        }
+      }
+    }
+  }
+  return {
+    sheetName: ws.name,
+    totalSheetRows: Math.max(0, rowCount - 1),
+    sampleRows,
+    columns: colSummaries
+  };
+}
+function formatXlsxColumns(result) {
+  if (result.columns.length === 0) return `Sheet "${displaySafeText(result.sheetName)}" is empty`;
+  const lines2 = [
+    `Sheet: ${displaySafeText(result.sheetName)} (${result.totalSheetRows} data rows, ${result.columns.length} columns; sampled first ${result.sampleRows} rows)`
+  ];
+  for (const c of result.columns) {
+    const pct = result.sampleRows > 0 ? Math.round(c.nonEmptyRows / c.sampleRows * 100) : 0;
+    const samples = c.sampleValues.length > 0 ? ` (e.g. ${c.sampleValues.map((v) => JSON.stringify(v.length > 30 ? v.slice(0, 27) + "..." : v)).join(", ")})` : " (all empty)";
+    lines2.push(`  ${c.letter.padEnd(4)} ${displaySafeText(c.name).padEnd(25)} ${c.nonEmptyRows}/${c.sampleRows} (${pct}%)${samples}`);
+  }
+  return lines2.join("\n");
+}
 
 // src/doc_embed_extract.ts
 init_define_import_meta_env();
@@ -5865,7 +6085,7 @@ var MAX_OUTLINE_ENTRIES = 2e4;
 var MAX_OUTLINE_TITLE_CHARS = 500;
 var MAX_LOCATE_MATCHES = 1e3;
 var MAX_LOCATE_CONTEXT_CHARS = 4e3;
-var MAX_PDF_WORK_MILLIS = 6e4;
+var MAX_PDF_WORK_MILLIS = MAX_DOCUMENT_WORK_MILLIS;
 var PdfRefusedError = class extends DocumentRefusedError {
 };
 var PdfTooLargeError = class extends PdfRefusedError {
@@ -5875,7 +6095,7 @@ var PdfTooLargeError = class extends PdfRefusedError {
 };
 var PdfTookTooLongError = class extends PdfRefusedError {
   constructor(message) {
-    super(message, "PdfTookTooLongError");
+    super(message, "PdfTookTooLongError", true);
   }
 };
 function pdfWorkDeadline() {
@@ -5988,6 +6208,10 @@ function reconstructLayout(items, deadline) {
   for (const item of items) {
     if ((checked++ & 1023) === 0 && Date.now() > deadline) throw pdfWorkTookTooLong();
     const y = item.transform[5];
+    if (!Number.isFinite(y)) {
+      rows.push([item]);
+      continue;
+    }
     const home = bucketOf(y);
     let found = -1;
     for (const bucket of [home - 1, home, home + 1]) {
@@ -6011,7 +6235,16 @@ function reconstructLayout(items, deadline) {
       place(home, found);
     }
   }
-  rows.sort((a, b) => b[0].transform[5] - a[0].transform[5]);
+  rows.sort((a, b) => {
+    const ya = a[0].transform[5];
+    const yb = b[0].transform[5];
+    const finiteA = Number.isFinite(ya);
+    const finiteB = Number.isFinite(yb);
+    if (finiteA && finiteB) return yb - ya;
+    if (finiteA) return -1;
+    if (finiteB) return 1;
+    return 0;
+  });
   const lines2 = [];
   for (const row of rows) {
     row.sort((a, b) => a.transform[4] - b.transform[4]);
@@ -6141,16 +6374,17 @@ function locateSnippet(text, index, matchLen, context) {
   const snippet = text.slice(from, to).replace(/\s+/g, " ").trim();
   return matchLen > kept ? `${snippet}...` : snippet;
 }
-async function resolveDestPage(doc, dest) {
+async function resolveDestPage(doc, dest, deadline) {
   let explicitDest = dest;
   if (typeof explicitDest === "string") {
-    explicitDest = await doc.getDestination(explicitDest);
+    explicitDest = await raceDeadline(doc.getDestination(explicitDest), deadline);
   }
   if (!Array.isArray(explicitDest) || explicitDest.length === 0) return null;
   try {
-    const pageIndex = await doc.getPageIndex(explicitDest[0]);
+    const pageIndex = await raceDeadline(doc.getPageIndex(explicitDest[0]), deadline);
     return pageIndex + 1;
-  } catch {
+  } catch (err) {
+    if (err instanceof PdfTookTooLongError) throw err;
     return null;
   }
 }
@@ -6167,7 +6401,7 @@ async function extractPdfOutline(data) {
         for (const item of items) {
           if (entries.length >= MAX_OUTLINE_ENTRIES) return;
           if (Date.now() > deadline) throw pdfWorkTookTooLong();
-          const page = await resolveDestPage(doc, item.dest);
+          const page = await resolveDestPage(doc, item.dest, deadline);
           const title = item.title.trim();
           entries.push({ level, title: title.length > MAX_OUTLINE_TITLE_CHARS ? `${title.slice(0, MAX_OUTLINE_TITLE_CHARS)}...` : title, page });
           if (item.items.length > 0) await walk(item.items, level + 1);
@@ -6220,6 +6454,9 @@ function isEmbeddableDocument(filePath) {
 function isDocumentRefusal(err) {
   return err instanceof DocumentRefusedError;
 }
+function isTransientDocumentRefusal(err) {
+  return err instanceof DocumentRefusedError && err.transient;
+}
 async function extractEmbeddableDocumentText(filePath) {
   switch (path.extname(filePath).toLowerCase()) {
     case ".pdf": {
@@ -7175,20 +7412,26 @@ function queryRefsByContext(context, filePath, dbPath = globalDbPath()) {
   const rows = db.prepare(sql).all(context, foldPath(filePath));
   return rows.map(toRefEntry);
 }
+var REF_COUNT_BATCH = 900;
 function queryRefCounts(names, dbPath = globalDbPath(), rootDir) {
   const counts = /* @__PURE__ */ new Map();
   if (names.length === 0) return counts;
   const db = getDb(dbPath);
-  const placeholders = names.map(() => "?").join(", ");
-  const params = [...names];
   const scopeWhere = [];
-  applyRootDirScope(rootDir, "file_path", scopeWhere, params);
+  const scopeParams = [];
+  applyRootDirScope(rootDir, "file_path", scopeWhere, scopeParams);
   const scopeSql = scopeWhere.length > 0 ? ` AND ${scopeWhere.join(" AND ")}` : "";
-  const sql = `SELECT name, COUNT(*) as c FROM refs WHERE name IN (${placeholders})${scopeSql} GROUP BY name`;
-  const rows = db.prepare(sql).all(...params);
-  for (const row of rows) {
-    counts.set(row.name, row.c);
-  }
+  const sqlFor = (width) => `SELECT name, COUNT(*) as c FROM refs WHERE name IN (${Array.from({ length: width }, () => "?").join(", ")})${scopeSql} GROUP BY name`;
+  const full = names.length >= REF_COUNT_BATCH ? db.prepare(sqlFor(REF_COUNT_BATCH)) : void 0;
+  db.transaction(() => {
+    for (let start = 0; start < names.length; start += REF_COUNT_BATCH) {
+      const batch = names.slice(start, start + REF_COUNT_BATCH);
+      const stmt = batch.length === REF_COUNT_BATCH && full !== void 0 ? full : db.prepare(sqlFor(batch.length));
+      for (const row of stmt.all(...batch, ...scopeParams)) {
+        counts.set(row.name, row.c);
+      }
+    }
+  })();
   return counts;
 }
 function getProjectFileEntries(rootDir, dbPath = globalDbPath()) {
@@ -7225,9 +7468,9 @@ function getFileEntry(filePath, dbPath = globalDbPath()) {
     parserSha: row.parser_sha ?? ""
   };
 }
-function sanitizeFtsQuery(query, join18 = "AND") {
+function sanitizeFtsQuery(query, join16 = "AND") {
   const terms = query.split(/\s+/).filter((t) => t.length > 0).map((t) => '"' + t.replace(/"/g, '""') + '"');
-  return terms.join(join18 === "OR" ? " OR " : " ");
+  return terms.join(join16 === "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 ?`;
@@ -7257,230 +7500,14 @@ function searchSymbolsFts(query, limit = 50, dbPath = globalDbPath(), rootDir) {
 
 // src/recall_index.ts
 init_define_import_meta_env();
-import * as fs7 from "node:fs";
-
-// src/disk_cache.ts
-init_define_import_meta_env();
 import * as fs6 from "node:fs";
-import * as path3 from "node:path";
-var DEFAULT_MAX_COUNT = 200;
-var DEFAULT_MAX_AGE_MS = 24 * 3600 * 1e3;
-function sanitizeId(id) {
-  return sanitizeIdForFilename(id, 64);
-}
-function blobDir(subdir) {
-  return path3.join(tokenGoatHome(), subdir);
-}
-function blobPath(subdir, id) {
-  const safe = sanitizeId(id);
-  if (!safe) return null;
-  const dir = blobDir(subdir);
-  const candidate = path3.join(dir, `${safe}.json`);
-  try {
-    const rel = path3.relative(dir, candidate);
-    if (rel.startsWith("..")) return null;
-  } catch {
-    return null;
-  }
-  return candidate;
-}
-function isBlobStale(subdir, id) {
-  const p = blobPath(subdir, id);
-  if (p === null) return false;
-  try {
-    const stat2 = fs6.statSync(p);
-    return Date.now() - stat2.mtimeMs > DEFAULT_MAX_AGE_MS;
-  } catch {
-    return false;
-  }
-}
-function subdirCacheDefaults(subdir) {
-  try {
-    if (subdir === "bash_outputs") {
-      const bc = loadConfig().bash_compress;
-      return { maxCount: bc.cache_max_file_count, maxBytes: bc.cache_max_bytes, maxBytesPerItem: bc.cache_max_bytes_per_output };
-    }
-    if (subdir === "web_outputs") {
-      const wf = loadConfig().webfetch;
-      return { maxCount: wf.max_file_count, maxBytes: wf.max_bytes, maxBytesPerItem: Number.POSITIVE_INFINITY };
-    }
-  } catch {
-  }
-  return { maxCount: DEFAULT_MAX_COUNT, maxBytes: Number.POSITIVE_INFINITY, maxBytesPerItem: Number.POSITIVE_INFINITY };
-}
-function storeBlob(subdir, id, value, opts = {}) {
-  const p = blobPath(subdir, id);
-  if (!p) return false;
-  const defaults = subdirCacheDefaults(subdir);
-  const maxBytesPerItem = opts.maxBytesPerItem ?? defaults.maxBytesPerItem;
-  let rawJson;
-  try {
-    rawJson = JSON.stringify(value);
-  } catch {
-    return false;
-  }
-  let json;
-  try {
-    const result = redactSecrets(rawJson);
-    json = result.text;
-    if (result.count > 0) recordStat("secret_redacted", 0, result.count, void 0, subdir);
-  } catch {
-    return false;
-  }
-  if (Number.isFinite(maxBytesPerItem) && Buffer.byteLength(json, "utf-8") > maxBytesPerItem) return false;
-  try {
-    const dir = path3.dirname(p);
-    if (!fs6.existsSync(dir)) ensureDirSync(dir);
-    atomicWriteText(p, json);
-  } catch {
-    return false;
-  }
-  pruneBlobs(
-    subdir,
-    opts.maxCount ?? defaults.maxCount,
-    opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS,
-    opts.maxBytes ?? defaults.maxBytes,
-    p
-  );
-  return true;
-}
-function loadBlob(subdir, id) {
-  const p = blobPath(subdir, id);
-  if (!p) return null;
-  try {
-    if (!fs6.existsSync(p)) return null;
-    return JSON.parse(fs6.readFileSync(p, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function listBlobs(subdir) {
-  const dir = blobDir(subdir);
-  const out = [];
-  try {
-    if (!fs6.existsSync(dir)) return out;
-    for (const file of fs6.readdirSync(dir)) {
-      if (!file.endsWith(".json")) continue;
-      const id = file.slice(0, -5);
-      let mtime = 0;
-      try {
-        mtime = fs6.statSync(path3.join(dir, file)).mtimeMs;
-      } catch {
-      }
-      const value = loadBlob(subdir, id);
-      if (value !== null) out.push({ id, mtime, value });
-    }
-  } catch {
-    return out;
-  }
-  return out;
-}
-function pruneBlobs(subdir, maxCount = DEFAULT_MAX_COUNT, maxAgeMs = DEFAULT_MAX_AGE_MS, maxBytes = Number.POSITIVE_INFINITY, protectedPath) {
-  return pruneBlobDir(blobDir(subdir), maxCount, maxAgeMs, maxBytes, protectedPath);
-}
-function pruneBlobDir(dir, maxCount = DEFAULT_MAX_COUNT, maxAgeMs = DEFAULT_MAX_AGE_MS, maxBytes = Number.POSITIVE_INFINITY, protectedPath) {
-  let removed = 0;
-  try {
-    if (!fs6.existsSync(dir)) return 0;
-    const cutoff = Date.now() - maxAgeMs;
-    let kept = [];
-    let protectedEntry;
-    for (const file of fs6.readdirSync(dir)) {
-      const full = path3.join(dir, file);
-      let stat2;
-      try {
-        stat2 = fs6.statSync(full);
-      } catch {
-        continue;
-      }
-      if (!stat2.isFile()) continue;
-      if (protectedPath !== void 0 && full === protectedPath) {
-        protectedEntry = [full, stat2.mtimeMs, stat2.size];
-        continue;
-      }
-      if (stat2.mtimeMs < cutoff) {
-        try {
-          fs6.unlinkSync(full);
-          removed++;
-        } catch {
-          continue;
-        }
-      } else if (file.endsWith(".json")) {
-        kept.push([full, stat2.mtimeMs, stat2.size]);
-      }
-    }
-    const countBudget = protectedEntry ? Math.max(0, maxCount - 1) : maxCount;
-    if (kept.length > countBudget) {
-      kept.sort((a, b) => a[1] - b[1]);
-      const excess = kept.slice(0, kept.length - countBudget);
-      kept = kept.slice(kept.length - countBudget);
-      for (const [full] of excess) {
-        try {
-          fs6.unlinkSync(full);
-          removed++;
-        } catch {
-          continue;
-        }
-      }
-    }
-    if (Number.isFinite(maxBytes)) {
-      kept.sort((a, b) => a[1] - b[1]);
-      let total = kept.reduce((sum, [, , size]) => sum + size, 0) + (protectedEntry ? protectedEntry[2] : 0);
-      while (total > maxBytes && kept.length > 0) {
-        const oldest = kept.shift();
-        if (!oldest) break;
-        const [full, , size] = oldest;
-        try {
-          fs6.unlinkSync(full);
-          removed++;
-          total -= size;
-        } catch {
-          break;
-        }
-      }
-    }
-  } catch {
-    return removed;
-  }
-  return removed;
-}
-var SWEEPABLE_CACHE_SUBDIRS = [
-  { subdir: "bash_outputs", countCapped: true },
-  { subdir: "web_outputs", countCapped: true },
-  { subdir: "mcp_outputs", countCapped: true },
-  { subdir: "sessions", countCapped: false }
-];
-function sweepCacheRoots(extraRoots = []) {
-  let removed = 0;
-  const roots = [tokenGoatHome(), ...extraRoots];
-  const seen = /* @__PURE__ */ new Set();
-  for (const root of roots) {
-    if (!root || seen.has(root)) continue;
-    seen.add(root);
-    for (const { subdir, countCapped } of SWEEPABLE_CACHE_SUBDIRS) {
-      try {
-        const defaults = subdirCacheDefaults(subdir);
-        removed += pruneBlobDir(
-          path3.join(root, subdir),
-          countCapped ? defaults.maxCount : Number.POSITIVE_INFINITY,
-          DEFAULT_MAX_AGE_MS,
-          countCapped ? defaults.maxBytes : Number.POSITIVE_INFINITY
-        );
-      } catch {
-      }
-    }
-  }
-  return removed;
-}
-
-// src/recall_index.ts
 function subdirForCacheType(cacheType) {
   return cacheType === "web" ? "web_outputs" : "bash_outputs";
 }
 function blobStillExists(cacheType, id) {
   try {
     const p = blobPath(subdirForCacheType(cacheType), id);
-    return p !== null && fs7.existsSync(p);
+    return p !== null && fs6.existsSync(p);
   } catch {
     return false;
   }
@@ -7631,7 +7658,7 @@ function searchRecall(query, opts = {}) {
 
 // src/bash_output_cache.ts
 init_define_import_meta_env();
-import { readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync4 } from "fs";
+import { readdirSync, readFileSync as readFileSync2, statSync as statSync3 } from "fs";
 import { resolve } from "path";
 
 // src/hints/lang_patterns.ts
@@ -7977,11 +8004,11 @@ function gitStateFingerprintSync(cwd) {
   }
 }
 var DIR_FINGERPRINT_LISTING_CAP_ENTRIES = 1e4;
-function dirStateFingerprintSync(path24) {
+function dirStateFingerprintSync(path22) {
   try {
-    const stat2 = statSync4(path24);
+    const stat2 = statSync3(path22);
     if (!stat2.isDirectory()) return null;
-    const entries = readdirSync2(path24);
+    const entries = readdirSync(path22);
     if (entries.length <= DIR_FINGERPRINT_LISTING_CAP_ENTRIES) {
       return shortFingerprint(entries.slice().sort().join("\0"));
     }
@@ -7991,12 +8018,12 @@ function dirStateFingerprintSync(path24) {
   }
 }
 var FILE_FINGERPRINT_CONTENT_CAP_BYTES = 2 * 1024 * 1024;
-function fileStateFingerprintSync(path24) {
+function fileStateFingerprintSync(path22) {
   try {
-    const stat2 = statSync4(path24);
+    const stat2 = statSync3(path22);
     if (!stat2.isFile()) return null;
     if (stat2.size <= FILE_FINGERPRINT_CONTENT_CAP_BYTES) {
-      return shortFingerprint(readFileSync3(path24));
+      return shortFingerprint(readFileSync2(path22));
     }
     return shortFingerprint(`${stat2.mtimeMs}\0${stat2.size}`);
   } catch {
@@ -8012,7 +8039,7 @@ function depLockfileFingerprintSync(cmd, cwd) {
   if (!candidates) return null;
   for (const lockfile of candidates) {
     try {
-      const content = readFileSync3(resolve(cwd, lockfile));
+      const content = readFileSync2(resolve(cwd, lockfile));
       return shortFingerprint(content);
     } catch {
       continue;
@@ -8265,8 +8292,8 @@ registerReset(() => {
 // src/session_store.ts
 init_define_import_meta_env();
 import { createHash } from "node:crypto";
-import * as fs8 from "node:fs";
-import * as path4 from "node:path";
+import * as fs7 from "node:fs";
+import * as path3 from "node:path";
 var MAX_FILES = 500;
 var SESSIONS_SUBDIR = "sessions";
 var AGENT_SALT_MARKER = sanitizeIdForFilename(":agent:");
@@ -8291,10 +8318,10 @@ function sessionSidecarPath(sessionId, suffix) {
   const safe = sessionFileStem(sessionId);
   if (!safe) return null;
   if (suffix.includes("/") || suffix.includes("\\") || suffix.includes("..")) return null;
-  const dir = path4.join(tokenGoatHome(), SESSIONS_SUBDIR);
-  const candidate = path4.join(dir, `${safe}${suffix}`);
+  const dir = path3.join(tokenGoatHome(), SESSIONS_SUBDIR);
+  const candidate = path3.join(dir, `${safe}${suffix}`);
   try {
-    const rel = path4.relative(dir, candidate);
+    const rel = path3.relative(dir, candidate);
     if (rel.startsWith("..")) return null;
   } catch {
     return null;
@@ -8568,8 +8595,8 @@ function capFiles(s, max) {
 }
 function readDiskState(p) {
   try {
-    if (!fs8.existsSync(p)) return null;
-    return coerce(JSON.parse(fs8.readFileSync(p, "utf8")));
+    if (!fs7.existsSync(p)) return null;
+    return coerce(JSON.parse(fs7.readFileSync(p, "utf8")));
   } catch {
     return null;
   }
@@ -8583,13 +8610,13 @@ function listSiblingSessionStates(sessionId) {
   if (!sessionId) return [];
   const prefix = saltedStemPrefix(sessionId);
   if (prefix === AGENT_SALT_MARKER) return [];
-  const dir = path4.join(tokenGoatHome(), SESSIONS_SUBDIR);
+  const dir = path3.join(tokenGoatHome(), SESSIONS_SUBDIR);
   const out = [];
   try {
-    if (!fs8.existsSync(dir)) return out;
-    for (const file of fs8.readdirSync(dir)) {
+    if (!fs7.existsSync(dir)) return out;
+    for (const file of fs7.readdirSync(dir)) {
       if (!file.endsWith(".json") || !file.startsWith(prefix)) continue;
-      const state = readDiskState(path4.join(dir, file));
+      const state = readDiskState(path3.join(dir, file));
       if (state !== null) out.push(state);
     }
   } catch {
@@ -8608,8 +8635,8 @@ function saveSessionState(sessionId) {
   const p = sessionPath(sessionId);
   if (!p) return;
   try {
-    const dir = path4.dirname(p);
-    if (!fs8.existsSync(dir)) ensureDirSync(dir);
+    const dir = path3.dirname(p);
+    if (!fs7.existsSync(dir)) ensureDirSync(dir);
     const mem = exportSessionState();
     const writeMerged = () => {
       const disk = readDiskState(p);
@@ -8631,10 +8658,10 @@ function saveSessionState(sessionId) {
 
 // src/skill_cache.ts
 init_define_import_meta_env();
-import * as fs9 from "fs/promises";
+import * as fs8 from "fs/promises";
 import { resolve as resolve2 } from "path";
 import { homedir } from "os";
-import { readdirSync as readdirSync4, readFileSync as readFileSync5, existsSync as existsSync6, statSync as statSync5, unlinkSync as unlinkSync2 } from "node:fs";
+import { readdirSync as readdirSync3, readFileSync as readFileSync4, existsSync as existsSync5, statSync as statSync4, unlinkSync } from "node:fs";
 var COMPACT_END_MARKER = "<!-- COMPACT_END -->";
 var SKILLS_OUTPUT_SUBDIR = "skills";
 var _skillOutputsDirOverride = null;
@@ -8799,14 +8826,14 @@ function extractChecklistSection(body) {
 async function listOutputs() {
   try {
     const dir = skillOutputsDir();
-    const entries = await fs9.readdir(dir, { withFileTypes: true });
+    const entries = await fs8.readdir(dir, { withFileTypes: true });
     const metas = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".meta")) {
         continue;
       }
       try {
-        const content = await fs9.readFile(resolve2(dir, entry.name), "utf-8");
+        const content = await fs8.readFile(resolve2(dir, entry.name), "utf-8");
         const meta = JSON.parse(content);
         metas.push(meta);
       } catch {
@@ -8857,7 +8884,7 @@ async function findCrossSessionEntry(skillName, contentSha) {
       const dir = skillOutputsDir();
       const bodyPath = resolve2(dir, `${meta.outputId}.txt`);
       try {
-        const bodyExists = await fs9.access(bodyPath).then(() => true).catch(() => false);
+        const bodyExists = await fs8.access(bodyPath).then(() => true).catch(() => false);
         if (bodyExists) {
           return meta;
         }
@@ -8960,11 +8987,11 @@ function getCompactAnySessionSync(skillName) {
     const suffix = compactSessionSuffix(skillName);
     if (!suffix) return null;
     const dir = skillOutputsDir();
-    const entries = readdirSync4(dir, { withFileTypes: true });
+    const entries = readdirSync3(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!matchesCompactSuffix(entry.name, entry.isFile(), suffix)) continue;
       try {
-        const text = readFileSync5(resolve2(dir, entry.name), "utf-8");
+        const text = readFileSync4(resolve2(dir, entry.name), "utf-8");
         if (text.trim()) return text;
       } catch {
         continue;
@@ -8993,7 +9020,7 @@ async function readSkillHits(skillName) {
     if (!name) return { count: 0, lastTs: 0 };
     const dir = skillOutputsDir();
     const hitsFile = resolve2(dir, `${sanitizeSkillId(name)}.hits`);
-    const content = await fs9.readFile(hitsFile, "utf-8").catch(() => null);
+    const content = await fs8.readFile(hitsFile, "utf-8").catch(() => null);
     if (content) {
       const parsed = JSON.parse(content);
       return parsed;
@@ -9021,14 +9048,14 @@ function runExclusiveInProcess(key, fn) {
 async function acquireSkillHitLock(lockPath) {
   for (let attempt = 0; attempt < SKILL_HIT_LOCK_MAX_ATTEMPTS; attempt++) {
     try {
-      await fs9.mkdir(lockPath);
+      await fs8.mkdir(lockPath);
       return true;
     } catch (err) {
       if (err.code !== "EEXIST") return false;
       try {
-        const st = await fs9.stat(lockPath);
+        const st = await fs8.stat(lockPath);
         if (Date.now() - st.mtimeMs > SKILL_HIT_LOCK_STALE_MS) {
-          await fs9.rmdir(lockPath).catch(() => {
+          await fs8.rmdir(lockPath).catch(() => {
           });
           continue;
         }
@@ -9057,7 +9084,7 @@ async function incrementSkillHit(skillName) {
         hits.lastTs = Date.now();
         await atomicWriteText(hitsFile, JSON.stringify(hits, null, 2));
       } finally {
-        await fs9.rmdir(lockPath).catch(() => {
+        await fs8.rmdir(lockPath).catch(() => {
         });
       }
     });
@@ -9093,14 +9120,14 @@ async function listSkills(sessionId) {
       let compactLen = 0;
       let compactText = "";
       try {
-        const stat2 = await fs9.stat(resolve2(dir, compactFileId));
+        const stat2 = await fs8.stat(resolve2(dir, compactFileId));
         compactLen = stat2.size;
-        compactText = await fs9.readFile(resolve2(dir, compactFileId), "utf-8").catch(() => "");
+        compactText = await fs8.readFile(resolve2(dir, compactFileId), "utf-8").catch(() => "");
       } catch {
         compactLen = 0;
       }
       const hasMarker = extractCompactFromMarker(
-        await fs9.readFile(resolve2(dir, `${meta.outputId}.txt`), "utf-8").catch(() => "")
+        await fs8.readFile(resolve2(dir, `${meta.outputId}.txt`), "utf-8").catch(() => "")
       ) !== null;
       const compactStale = isCompactStale(compactText, meta.skillName, meta.contentSha);
       const { count: hitCount } = await readSkillHits(meta.skillName);
@@ -9139,7 +9166,7 @@ async function resolvePluginSkillPath(pluginName, skillSlug) {
   const manifestPath = _pluginsManifestPathOverride ?? resolve2(homedir(), ".claude", "plugins", "installed_plugins.json");
   let raw;
   try {
-    raw = await fs9.readFile(manifestPath, "utf8");
+    raw = await fs8.readFile(manifestPath, "utf8");
   } catch {
     return null;
   }
@@ -9161,7 +9188,7 @@ async function resolvePluginSkillPath(pluginName, skillSlug) {
       if (typeof installPath !== "string" || installPath === "") continue;
       const diskPath = resolve2(installPath, "skills", skillSlug, "SKILL.md");
       try {
-        await fs9.access(diskPath);
+        await fs8.access(diskPath);
         return diskPath;
       } catch {
         continue;
@@ -9180,7 +9207,7 @@ async function installedSkillPath(skillName) {
   }
   const diskPath = resolve2(skillsSourceDir(), name, "SKILL.md");
   try {
-    await fs9.access(diskPath);
+    await fs8.access(diskPath);
     return diskPath;
   } catch {
     return null;
@@ -9190,19 +9217,19 @@ function pruneSkillOutputs(maxCount = DEFAULT_MAX_COUNT, maxAgeMs = DEFAULT_MAX_
   const dir = skillOutputsDir();
   let removed = 0;
   try {
-    if (!existsSync6(dir)) return 0;
+    if (!existsSync5(dir)) return 0;
     const cutoff = Date.now() - maxAgeMs;
     const entries = [];
-    for (const file of readdirSync4(dir)) {
+    for (const file of readdirSync3(dir)) {
       if (!file.endsWith(".meta")) continue;
       const outputId = file.slice(0, -".meta".length);
       let ts;
       try {
-        const parsed = JSON.parse(readFileSync5(resolve2(dir, file), "utf-8"));
+        const parsed = JSON.parse(readFileSync4(resolve2(dir, file), "utf-8"));
         ts = parsed.ts;
       } catch {
         try {
-          ts = statSync5(resolve2(dir, file)).mtimeMs;
+          ts = statSync4(resolve2(dir, file)).mtimeMs;
         } catch {
           continue;
         }
@@ -9212,7 +9239,7 @@ function pruneSkillOutputs(maxCount = DEFAULT_MAX_COUNT, maxAgeMs = DEFAULT_MAX_
     const removeEntry = (outputId) => {
       for (const ext of [".meta", ".txt"]) {
         try {
-          unlinkSync2(resolve2(dir, `${outputId}${ext}`));
+          unlinkSync(resolve2(dir, `${outputId}${ext}`));
         } catch {
         }
       }
@@ -9241,9 +9268,9 @@ function pruneSkillOutputs(maxCount = DEFAULT_MAX_COUNT, maxAgeMs = DEFAULT_MAX_
 // src/image_shrink.ts
 init_define_import_meta_env();
 var import_omggif2 = __toESM(require_omggif(), 1);
-import { createHash as createHash3 } from "node:crypto";
-import * as fs11 from "node:fs";
-import * as path7 from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+import * as fs9 from "node:fs";
+import * as path5 from "node:path";
 
 // src/image_engine.ts
 init_define_import_meta_env();
@@ -9803,10 +9830,10 @@ function calculateFitInside(width, height, maxDimension) {
 
 // src/vscode_path_gate.ts
 init_define_import_meta_env();
-import * as path5 from "node:path";
+import * as path4 from "node:path";
 function resolvesToUncPath(target, cwd) {
   try {
-    return isUncOrDevicePath(path5.resolve(cwd ?? process.cwd(), target));
+    return isUncOrDevicePath(path4.resolve(cwd ?? process.cwd(), target));
   } catch {
     return false;
   }
@@ -9814,8 +9841,8 @@ function resolvesToUncPath(target, cwd) {
 function vscodePathAllowed(filePath, workspace) {
   if (isUncOrDevicePath(filePath)) return false;
   if (workspace === void 0 || isUncOrDevicePath(workspace)) return false;
-  const resolvedRoot = path5.resolve(workspace);
-  const resolvedTarget = path5.resolve(workspace, filePath);
+  const resolvedRoot = path4.resolve(workspace);
+  const resolvedTarget = path4.resolve(workspace, filePath);
   const root = foldPathForContainment(resolvedRoot.replace(/\\/g, "/"));
   const target = foldPathForContainment(resolvedTarget.replace(/\\/g, "/"));
   if (target !== root && !target.startsWith(root.endsWith("/") ? root : root + "/")) return false;
@@ -9832,163 +9859,6 @@ function preToolPathDeclined(event, target) {
   return escapesOntoNetworkThroughLinks(target, cwd);
 }
 
-// src/image_ocr.ts
-init_define_import_meta_env();
-import { spawn } from "node:child_process";
-import { createHash as createHash2 } from "node:crypto";
-import * as fs10 from "node:fs";
-import { createRequire } from "node:module";
-import * as path6 from "node:path";
-var _ocrTimeoutMs = 12e3;
-var OCR_LANG_FILE = "eng.traineddata";
-var OCR_LANG_PATH = "https://cdn.jsdelivr.net/npm/@tesseract.js-data/eng@1.0.0/4.0.0_best_int";
-var OCR_LANG_SHA256 = "5dc5d8d640a212c9d6184921ba103b186f50e0fed9ee716c53e6b312b400d747";
-function verifyOcrLangCache() {
-  const file = path6.join(ocrCacheDir(), OCR_LANG_FILE);
-  let bytes;
-  try {
-    if (!fs10.existsSync(file)) return "absent";
-    bytes = fs10.readFileSync(file);
-  } catch {
-    return "unreadable";
-  }
-  return createHash2("sha256").update(bytes).digest("hex") === OCR_LANG_SHA256 ? "ok" : "mismatch";
-}
-function quarantineOcrLangCache() {
-  try {
-    fs10.rmSync(path6.join(ocrCacheDir(), OCR_LANG_FILE), { force: true });
-  } catch {
-  }
-}
-var _ocrIntegrityFailed = false;
-function ocrIntegrityFailed() {
-  return _ocrIntegrityFailed;
-}
-function ocrBlockedOffline() {
-  if (!loadConfig().network.offline) return false;
-  return !fs10.existsSync(path6.join(ocrCacheDir(), OCR_LANG_FILE));
-}
-function ocrCacheDir() {
-  return path6.join(tokenGoatHome(), "ocr-cache");
-}
-function ensureOcrCacheDir() {
-  try {
-    ensureDirSync(ocrCacheDir());
-  } catch {
-  }
-}
-var _require = createRequire(import.meta.url);
-var _tesseractEntryPath;
-function resolveTesseractEntry() {
-  if (_tesseractEntryPath !== void 0) return _tesseractEntryPath;
-  try {
-    _tesseractEntryPath = _require.resolve("tesseract.js");
-  } catch {
-    _tesseractEntryPath = null;
-  }
-  return _tesseractEntryPath;
-}
-function isOcrEngineAvailable() {
-  return !_ocrUnavailableThisProcess && resolveTesseractEntry() !== null;
-}
-var _ocrUnavailableThisProcess = false;
-function buildChildScript(entryPath, cacheDir) {
-  return [
-    `const { createWorker } = require(${JSON.stringify(entryPath)});`,
-    "const chunks = [];",
-    "process.stdin.on('data', (c) => chunks.push(c));",
-    "process.stdin.on('end', async () => {",
-    "  try {",
-    "    const buf = Buffer.concat(chunks);",
-    `    const worker = await createWorker('eng', 1, { cachePath: ${JSON.stringify(cacheDir)}, langPath: ${JSON.stringify(OCR_LANG_PATH)}, errorHandler: () => {} });`,
-    "    const { data } = await worker.recognize(buf);",
-    "    process.stdout.write(JSON.stringify({ text: data.text || '', confidence: data.confidence || 0 }));",
-    "    await worker.terminate();",
-    "    process.exit(0);",
-    "  } catch (e) {",
-    "    process.exit(1);",
-    "  }",
-    "});"
-  ].join("\n");
-}
-async function ocrImage(input) {
-  if (_ocrUnavailableThisProcess) return null;
-  const entryPath = resolveTesseractEntry();
-  if (entryPath === null) return null;
-  if (ocrBlockedOffline()) return null;
-  if (_ocrIntegrityFailed) return null;
-  if (verifyOcrLangCache() === "mismatch") {
-    _ocrIntegrityFailed = true;
-    quarantineOcrLangCache();
-    return null;
-  }
-  return new Promise((resolve8) => {
-    let settled = false;
-    let child;
-    try {
-      ensureOcrCacheDir();
-      child = spawn(process.execPath, ["-e", buildChildScript(entryPath, ocrCacheDir())], {
-        stdio: ["pipe", "pipe", "ignore"]
-      });
-    } catch {
-      _ocrUnavailableThisProcess = true;
-      resolve8(null);
-      return;
-    }
-    const chunks = [];
-    const finish = (result, subprocessBroken) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      if (subprocessBroken) _ocrUnavailableThisProcess = true;
-      try {
-        child.kill();
-      } catch {
-      }
-      resolve8(result);
-    };
-    const timer = setTimeout(() => finish(null, true), _ocrTimeoutMs);
-    child.stdout?.on("data", (c) => chunks.push(c));
-    child.on("error", () => finish(null, true));
-    child.on("close", (code) => {
-      if (code !== 0) {
-        finish(null, false);
-        return;
-      }
-      if (verifyOcrLangCache() === "mismatch") {
-        _ocrIntegrityFailed = true;
-        quarantineOcrLangCache();
-        finish(null, false);
-        return;
-      }
-      try {
-        const raw = JSON.parse(Buffer.concat(chunks).toString("utf8"));
-        const parsed = raw;
-        const text = typeof parsed.text === "string" ? parsed.text.trim() : "";
-        const confidence = typeof parsed.confidence === "number" ? parsed.confidence : 0;
-        finish({ text, confidence }, false);
-      } catch {
-        finish(null, false);
-      }
-    });
-    try {
-      child.stdin?.end(input);
-    } catch {
-      finish(null, false);
-    }
-  });
-}
-function isTextHeavy(result, minConfidence, minChars = 40) {
-  return result.confidence >= minConfidence && result.text.length >= minChars;
-}
-function formatOcrSummary(result, subject, originalBytes) {
-  const kb = Math.round(originalBytes / 1024);
-  const summary = `token-goat OCR'd ${subject} instead of shrinking it: text-heavy image detected (${Math.round(result.confidence)}% confidence), extracted ${result.text.length} chars of text from ${kb}kb of pixels.`;
-  return `${summary}
-
-${fenceUntrustedOcrText(result.text)}`;
-}
-
 // src/image_shrink.ts
 var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".png",
@@ -10060,7 +9930,7 @@ function formatShrinkSummary(result, subject) {
   return { summary, dataUrl };
 }
 function isImagePath(p) {
-  return IMAGE_EXTENSIONS.has(path7.extname(p).toLowerCase());
+  return IMAGE_EXTENSIONS.has(path5.extname(p).toLowerCase());
 }
 var ImageDecodeError = class extends Error {
 };
@@ -10175,17 +10045,17 @@ async function shrinkImage(input, opts) {
 }
 function statInfo(absPath) {
   try {
-    const st = fs11.statSync(absPath);
+    const st = fs9.statSync(absPath);
     return st.isFile() ? { size: st.size, mtimeMs: st.mtimeMs } : null;
   } catch {
     return null;
   }
 }
 function imageShrinkCacheDir() {
-  return path7.join(tokenGoatHome(), "image_shrink_cache");
+  return path5.join(tokenGoatHome(), "image_shrink_cache");
 }
 function shrinkCacheKey(originalPath, size, mtimeMs, quality) {
-  return createHash3("sha256").update(`${originalPath}:${size}:${mtimeMs}:${quality}`).digest("hex").slice(0, 16);
+  return createHash2("sha256").update(`${originalPath}:${size}:${mtimeMs}:${quality}`).digest("hex").slice(0, 16);
 }
 var SHRINK_CACHE_EXTENSION = /* @__PURE__ */ new Map([
   ["jpeg", ".jpg"],
@@ -10203,7 +10073,7 @@ function findCachedShrink(originalPath, size, mtimeMs, quality) {
   const dir = imageShrinkCacheDir();
   let entries;
   try {
-    entries = fs11.readdirSync(dir);
+    entries = fs9.readdirSync(dir);
   } catch {
     return null;
   }
@@ -10214,7 +10084,7 @@ function findCachedShrink(originalPath, size, mtimeMs, quality) {
     const format = SHRINK_CACHE_FORMAT.get(m[3] ?? "");
     if (format === void 0) continue;
     return {
-      filePath: path7.join(dir, file),
+      filePath: path5.join(dir, file),
       format,
       originalWidth: Number(m[1]),
       originalHeight: Number(m[2])
@@ -10229,7 +10099,7 @@ function writeCachedShrink(originalPath, result, mtimeMs, quality) {
     const key = shrinkCacheKey(originalPath, result.originalBytes, mtimeMs, quality);
     const ext = SHRINK_CACHE_EXTENSION.get(result.format);
     if (ext === void 0) return;
-    atomicWriteBytes(path7.join(dir, `token-goat-shrink-${key}-${result.originalWidth}x${result.originalHeight}${ext}`), result.data);
+    atomicWriteBytes(path5.join(dir, `token-goat-shrink-${key}-${result.originalWidth}x${result.originalHeight}${ext}`), result.data);
   } catch {
   }
 }
@@ -10241,14 +10111,14 @@ function pruneShrinkCache() {
   lastShrinkCachePruneAtMs = now;
   try {
     const dir = imageShrinkCacheDir();
-    if (!fs11.existsSync(dir)) return;
+    if (!fs9.existsSync(dir)) return;
     const cutoff = now - DEFAULT_MAX_AGE_MS;
-    for (const file of fs11.readdirSync(dir)) {
+    for (const file of fs9.readdirSync(dir)) {
       if (!file.startsWith("token-goat-shrink-")) continue;
-      const full = path7.join(dir, file);
+      const full = path5.join(dir, file);
       try {
-        const st = fs11.statSync(full);
-        if (st.mtimeMs < cutoff) fs11.unlinkSync(full);
+        const st = fs9.statSync(full);
+        if (st.mtimeMs < cutoff) fs9.unlinkSync(full);
       } catch {
       }
     }
@@ -10257,7 +10127,7 @@ function pruneShrinkCache() {
 }
 var HOST_MATERIALIZED_HARNESSES = /* @__PURE__ */ new Set(["copilot_cli", "pi", "opencode", "openclaw"]);
 async function finalizeShrinkResult(result, filePath, event) {
-  const basename10 = displaySafePath(path7.basename(filePath));
+  const basename10 = displaySafePath(path5.basename(filePath));
   const shrinkSaved = result.originalBytes - result.shrunkBytes;
   const tier = loadConfig().image_shrink.vision_tier;
   const shrinkTokens = visionTokensSaved(result.originalWidth, result.originalHeight, result.width, result.height, tier);
@@ -10275,6 +10145,7 @@ ${dataUrl2}`);
   }
   recordStat("image_shrink", shrinkSaved, shrinkTokens, void 0, basename10);
   if (loadConfig().image_shrink.ocr_enabled) {
+    const { ocrImage, isTextHeavy, formatOcrSummary } = await import("./token-goat-chunk-4NXUKV7D.mjs");
     const ocr = await ocrImage(result.data);
     if (ocr !== null && isTextHeavy(ocr, loadConfig().image_shrink.ocr_min_confidence)) {
       const emitted = formatOcrSummary(ocr, basename10, result.originalBytes);
@@ -10305,7 +10176,7 @@ async function preReadImageHandler(event) {
   if (cached !== null) {
     let cachedData;
     try {
-      cachedData = fs11.readFileSync(cached.filePath);
+      cachedData = fs9.readFileSync(cached.filePath);
     } catch {
       cachedData = null;
     }
@@ -10331,13 +10202,13 @@ async function preReadImageHandler(event) {
       return finalizeShrinkResult(result2, filePath, event);
     }
     try {
-      fs11.unlinkSync(cached.filePath);
+      fs9.unlinkSync(cached.filePath);
     } catch {
     }
   }
   let input;
   try {
-    input = fs11.readFileSync(filePath);
+    input = fs9.readFileSync(filePath);
   } catch {
     return passOutput();
   }
@@ -10357,10 +10228,10 @@ init_define_import_meta_env();
 
 // src/embed_model.ts
 init_define_import_meta_env();
-import { createHash as createHash4 } from "node:crypto";
-import * as fs12 from "node:fs";
-import { createRequire as createRequire2 } from "node:module";
-import * as path8 from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+import * as fs10 from "node:fs";
+import { createRequire } from "node:module";
+import * as path6 from "node:path";
 import { pipeline } from "node:stream/promises";
 
 // src/embed_tokenizer.ts
@@ -10375,20 +10246,20 @@ var UnsupportedTokenizerError = class extends Error {
 function fail(message) {
   throw new UnsupportedTokenizerError(message);
 }
-function asRecord(value, path24) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) fail(`${path24} is not an object`);
+function asRecord(value, path22) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) fail(`${path22} is not an object`);
   return value;
 }
-function asString(value, path24) {
-  if (typeof value !== "string") fail(`${path24} is not a string`);
+function asString(value, path22) {
+  if (typeof value !== "string") fail(`${path22} is not a string`);
   return value;
 }
-function asArray2(value, path24) {
-  if (!Array.isArray(value)) fail(`${path24} is not an array`);
+function asArray2(value, path22) {
+  if (!Array.isArray(value)) fail(`${path22} is not an array`);
   return value;
 }
-function expectValue(actual, wanted, path24) {
-  if (actual !== wanted) fail(`${path24} is ${JSON.stringify(actual)}, expected ${JSON.stringify(wanted)}`);
+function expectValue(actual, wanted, path22) {
+  if (actual !== wanted) fail(`${path22} 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;
@@ -10571,7 +10442,7 @@ var BertWordPiece = class _BertWordPiece {
 };
 
 // src/embed_model.ts
-var _require2 = createRequire2(import.meta.url);
+var _require = createRequire(import.meta.url);
 var DEFAULT_MODEL = "Xenova/bge-small-en-v1.5";
 var DEFAULT_DIM = 384;
 var DEFAULT_EMBED_THREADS = 2;
@@ -10589,7 +10460,7 @@ var MODEL_FILES = [
   }
 ];
 function modelDir() {
-  return path8.join(dataDir(), "models", ...DEFAULT_MODEL.split("/"), PINNED_MODEL_REVISION);
+  return path6.join(dataDir(), "models", ...DEFAULT_MODEL.split("/"), PINNED_MODEL_REVISION);
 }
 function downloadUrl(file) {
   return `https://huggingface.co/${DEFAULT_MODEL}/resolve/${PINNED_MODEL_REVISION}/${file.name}`;
@@ -10597,44 +10468,44 @@ function downloadUrl(file) {
 function sharedModelCacheDir() {
   const raw = process.env["TOKEN_GOAT_MODEL_CACHE_DIR"]?.trim();
   if (!raw) return null;
-  return path8.join(raw, ...DEFAULT_MODEL.split("/"), PINNED_MODEL_REVISION);
+  return path6.join(raw, ...DEFAULT_MODEL.split("/"), PINNED_MODEL_REVISION);
 }
 async function copyFromSharedCache(shared, file, target) {
-  const source = path8.join(shared, file.name);
+  const source = path6.join(shared, file.name);
   const temp = `${target}.${process.pid}.shared`;
   try {
-    const info = fs12.lstatSync(source, { throwIfNoEntry: false });
+    const info = fs10.lstatSync(source, { throwIfNoEntry: false });
     if (!info?.isFile() || info.size !== file.bytes) return false;
-    fs12.copyFileSync(source, temp);
+    fs10.copyFileSync(source, temp);
     if (await sha256Of(temp) !== file.sha256) {
-      fs12.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
-      fs12.rmSync(source, { force: true, maxRetries: 20, retryDelay: 25 });
+      fs10.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
+      fs10.rmSync(source, { force: true, maxRetries: 20, retryDelay: 25 });
       return false;
     }
-    fs12.renameSync(temp, target);
+    fs10.renameSync(temp, target);
     return true;
   } catch {
     try {
-      fs12.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
+      fs10.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
     } catch {
     }
     return false;
   }
 }
 function publishToSharedCache(shared, file, target) {
-  const destination = path8.join(shared, file.name);
+  const destination = path6.join(shared, file.name);
   const temp = `${destination}.${process.pid}.partial`;
   let created = false;
   try {
-    if (fs12.existsSync(destination)) return;
-    ensureDirSync(path8.dirname(destination));
-    fs12.copyFileSync(target, temp, fs12.constants.COPYFILE_EXCL);
+    if (fs10.existsSync(destination)) return;
+    ensureDirSync(path6.dirname(destination));
+    fs10.copyFileSync(target, temp, fs10.constants.COPYFILE_EXCL);
     created = true;
-    fs12.renameSync(temp, destination);
+    fs10.renameSync(temp, destination);
   } catch {
     if (!created) return;
     try {
-      fs12.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
+      fs10.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
     } catch {
     }
   }
@@ -10646,7 +10517,7 @@ function ensureRuntimeLoaded() {
   if (_ortLoadAttempted) return;
   _ortLoadAttempted = true;
   try {
-    _ort = _require2("onnxruntime-node");
+    _ort = _require("onnxruntime-node");
   } catch (e) {
     _ortError = e instanceof Error ? e : new Error(String(e));
   }
@@ -10663,14 +10534,14 @@ function runtimeVersion() {
   ensureRuntimeLoaded();
   if (_ort === null) return "unknown";
   try {
-    let dir = path8.dirname(_require2.resolve("onnxruntime-node"));
+    let dir = path6.dirname(_require.resolve("onnxruntime-node"));
     for (let depth = 0; depth < 6; depth++) {
-      const manifest = path8.join(dir, "package.json");
-      if (fs12.existsSync(manifest)) {
-        const parsed = JSON.parse(fs12.readFileSync(manifest, "utf8"));
+      const manifest = path6.join(dir, "package.json");
+      if (fs10.existsSync(manifest)) {
+        const parsed = JSON.parse(fs10.readFileSync(manifest, "utf8"));
         if (parsed.name === "onnxruntime-node" && typeof parsed.version === "string") return parsed.version;
       }
-      const up = path8.dirname(dir);
+      const up = path6.dirname(dir);
       if (up === dir) break;
       dir = up;
     }
@@ -10680,8 +10551,8 @@ function runtimeVersion() {
 }
 function sha256Of(filePath) {
   return new Promise((resolve8, reject) => {
-    const hash2 = createHash4("sha256");
-    const stream = fs12.createReadStream(filePath);
+    const hash2 = createHash3("sha256");
+    const stream = fs10.createReadStream(filePath);
     stream.on("error", reject);
     stream.on("data", (chunk) => hash2.update(chunk));
     stream.on("end", () => resolve8(hash2.digest("hex")));
@@ -10693,9 +10564,9 @@ async function download(file, target) {
   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");
+  const hash2 = createHash3("sha256");
   let written = 0;
-  const out = fs12.createWriteStream(temp);
+  const out = fs10.createWriteStream(temp);
   try {
     await pipeline(async function* () {
       for await (const chunk of response.body) {
@@ -10712,14 +10583,14 @@ async function download(file, target) {
     if (digest !== file.sha256) {
       throw new Error(`${file.name} has sha256 ${digest}, expected the pinned ${file.sha256}`);
     }
-    fs12.renameSync(temp, target);
+    fs10.renameSync(temp, target);
   } catch (e) {
     await new Promise((resolve8) => {
       if (out.closed) resolve8();
       else out.once("close", () => resolve8());
     });
     try {
-      fs12.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
+      fs10.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
     } catch {
     }
     throw e;
@@ -10736,14 +10607,14 @@ async function ensureModelFiles(modelName = DEFAULT_MODEL) {
   const offline = loadConfig().network.offline;
   const shared = sharedModelCacheDir();
   for (const file of MODEL_FILES) {
-    const target = path8.join(dir, file.name);
-    if (fs12.existsSync(target)) {
+    const target = path6.join(dir, file.name);
+    if (fs10.existsSync(target)) {
       const digest = await sha256Of(target);
       if (digest === file.sha256) continue;
-      fs12.rmSync(target, { force: true });
+      fs10.rmSync(target, { force: true });
     }
     if (shared) {
-      ensureDirSync(path8.dirname(target));
+      ensureDirSync(path6.dirname(target));
       if (await copyFromSharedCache(shared, file, target)) continue;
     }
     if (offline) {
@@ -10751,7 +10622,7 @@ async function ensureModelFiles(modelName = DEFAULT_MODEL) {
         `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.`
       );
     }
-    ensureDirSync(path8.dirname(target));
+    ensureDirSync(path6.dirname(target));
     console.warn(
       `Downloading the embedding model, once (${file.name}, ${Math.round(file.bytes / 1024 / 1024)} MB) into ${dir}`
     );
@@ -10792,10 +10663,10 @@ var EmbeddingModel = class _EmbeddingModel {
       throw new Error(`onnxruntime-node is not available: ${_ortError?.message ?? "unknown error"}`);
     }
     const dir = await ensureModelFiles(modelName);
-    const tokenizer = BertWordPiece.fromJson(fs12.readFileSync(path8.join(dir, "tokenizer.json"), "utf8"));
+    const tokenizer = BertWordPiece.fromJson(fs10.readFileSync(path6.join(dir, "tokenizer.json"), "utf8"));
     const ort = _ort;
     const threads = loadConfig().worker.embed_threads ?? DEFAULT_EMBED_THREADS;
-    const session = await ort.InferenceSession.create(path8.join(dir, "onnx", "model_quantized.onnx"), {
+    const session = await ort.InferenceSession.create(path6.join(dir, "onnx", "model_quantized.onnx"), {
       intraOpNumThreads: threads,
       interOpNumThreads: 1
     });
@@ -10908,6 +10779,7 @@ var _TOKEN_RE = /\w+/g;
 var _MIN_TOKEN_LEN = 3;
 var OVER_FETCH_FACTOR = 4;
 var MAX_OVER_FETCH = 100;
+var VEC_MAX_K = 4096;
 function isAvailable() {
   return isRuntimeAvailable();
 }
@@ -11210,6 +11082,34 @@ function fetchScopedHits(db, queryVec, k, maxDistance, rootDir) {
   }
   return { hits, candidateCount: rows.length };
 }
+function fetchScopedExactHits(db, queryVec, limit, maxDistance, rootDir) {
+  const scope = projectScopeClause("c.file_path");
+  const rows = db.prepare(
+    `SELECT file_path, start_line, end_line, text, kind, distance FROM (
+         SELECT c.id AS id, c.file_path AS file_path, c.start_line AS start_line, c.end_line AS end_line, c.text AS text, c.kind AS kind, vec_distance_L2(v.embedding, ?) AS distance
+         FROM chunks c JOIN chunk_vectors v ON v.rowid = c.id
+         WHERE ${scope.clause}
+       )
+       WHERE distance IS NOT NULL AND distance <= ?
+       ORDER BY distance ASC, file_path ASC, start_line ASC, id ASC
+       LIMIT ?`
+  ).all(packVec(queryVec), ...scope.params(rootDir), maxDistance, limit);
+  const hits = [];
+  for (const row of rows) {
+    if (!row || typeof row.distance !== "number" || !Number.isFinite(row.distance) || row.distance > maxDistance) {
+      continue;
+    }
+    hits.push({
+      filePath: row.file_path,
+      startLine: row.start_line,
+      endLine: row.end_line,
+      kind: row.kind,
+      distance: row.distance,
+      text: row.text
+    });
+  }
+  return hits;
+}
 async function searchSemantic(db, query, topK = 8, modelName = DEFAULT_MODEL, maxDistance = DEFAULT_DISTANCE_THRESHOLD, rootDir) {
   if (!isAvailable()) {
     return [];
@@ -11233,16 +11133,19 @@ async function searchSemantic(db, query, topK = 8, modelName = DEFAULT_MODEL, ma
     MAX_OVER_FETCH,
     Math.ceil(topK * OVER_FETCH_FACTOR)
   );
-  let k = overFetchK;
+  let k = Math.min(overFetchK, VEC_MAX_K);
   let pass = fetchScopedHits(db, queryVec, k, maxDistance, rootDir);
   let hits = pass.hits;
   if (rootDir !== void 0) {
-    const ceiling = countStoredVectors(db);
+    const ceiling = Math.min(countStoredVectors(db), VEC_MAX_K);
     while (hits.length < topK && pass.candidateCount === k && k < ceiling) {
       k = Math.min(ceiling, k * BACKFILL_MULTIPLIER);
       pass = fetchScopedHits(db, queryVec, k, maxDistance, rootDir);
       hits = pass.hits;
     }
+    if (hits.length < topK && pass.candidateCount === k && k >= ceiling && countStoredVectors(db) > VEC_MAX_K) {
+      hits = fetchScopedExactHits(db, queryVec, VEC_MAX_K, maxDistance, rootDir);
+    }
   }
   return rerankHits(hits, query, topK);
 }
@@ -11446,13 +11349,13 @@ function _pathPriorityPenalty(filePath) {
 
 // src/parser_fingerprint.ts
 init_define_import_meta_env();
-var PARSER_FINGERPRINT = "d49e4406b2f63a60";
+var PARSER_FINGERPRINT = "9c0e5a5680783f75";
 
 // src/parser.ts
 init_define_import_meta_env();
-import * as fs13 from "node:fs";
-import { createRequire as createRequire3 } from "node:module";
-import * as path10 from "node:path";
+import * as fs11 from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import * as path8 from "node:path";
 
 // src/markdown_lines.ts
 init_define_import_meta_env();
@@ -11575,14 +11478,14 @@ function extractChangelogVersionHint(content, filePath) {
 
 // src/languages/salesforce_frontend.ts
 init_define_import_meta_env();
-import * as path9 from "node:path";
+import * as path7 from "node:path";
 function lines(content) {
   return content.split("\n");
 }
 function bundleName(filePath) {
   const normalized = filePath.replaceAll("\\", "/");
-  const parent = path9.posix.basename(path9.posix.dirname(normalized));
-  const base = path9.posix.basename(normalized).replace(/\.[^.]+$/, "");
+  const parent = path7.posix.basename(path7.posix.dirname(normalized));
+  const base = path7.posix.basename(normalized).replace(/\.[^.]+$/, "");
   return parent === "lwc" || parent === "aura" ? base : parent;
 }
 function lwcTagAlias(name) {
@@ -11686,7 +11589,7 @@ var MARKUP_KIND = {
 };
 function markupArtifactName(filePath, extension) {
   if (extension === ".page" || extension === ".component" || extension === ".email") {
-    return path9.posix.basename(filePath.replaceAll("\\", "/")).replace(new RegExp(`${extension.replace(".", "\\.")}$`, "i"), "");
+    return path7.posix.basename(filePath.replaceAll("\\", "/")).replace(new RegExp(`${extension.replace(".", "\\.")}$`, "i"), "");
   }
   return bundleName(filePath);
 }
@@ -11706,7 +11609,7 @@ function attributeRefs(refs, content, filePath, attribute, split = false) {
 }
 function extractSalesforceMarkup(content, filePath) {
   const normalized = filePath.replaceAll("\\", "/");
-  const extension = path9.posix.extname(normalized).toLowerCase();
+  const extension = path7.posix.extname(normalized).toLowerCase();
   const kind = MARKUP_KIND[extension] ?? "salesforce_markup";
   const symbols = [
     symbol(filePath, markupArtifactName(normalized, extension), kind, 1, countContentLines(content))
@@ -11737,56 +11640,8 @@ function extractSalesforceMarkup(content, filePath) {
   };
 }
 
-// src/languages/ipynb_idx.ts
-init_define_import_meta_env();
-function normalizeSource(source) {
-  if (typeof source === "string") return source;
-  if (!Array.isArray(source)) return "";
-  const lines2 = source.filter((s) => typeof s === "string");
-  if (lines2.length === 0) return "";
-  const noneEndWithNewline = lines2.every((l) => !l.endsWith("\n"));
-  return noneEndWithNewline ? lines2.join("\n") : lines2.join("");
-}
-function resolveKernelLanguage(metadata) {
-  const kernelspecLang = metadata?.kernelspec?.language;
-  if (typeof kernelspecLang === "string" && kernelspecLang !== "") return kernelspecLang.toLowerCase();
-  const infoLang = metadata?.language_info?.name;
-  if (typeof infoLang === "string" && infoLang !== "") return infoLang.toLowerCase();
-  return void 0;
-}
-function ipynbToVirtualSource(raw) {
-  let data;
-  try {
-    data = JSON.parse(raw);
-  } catch {
-    return { content: "", cellLanguage: null };
-  }
-  if (typeof data !== "object" || data === null) return { content: "", cellLanguage: null };
-  const nb = data;
-  if (!Array.isArray(nb.cells)) return { content: "", cellLanguage: null };
-  const declared = resolveKernelLanguage(nb.metadata);
-  const isPython = declared === void 0 || declared === "python" || declared === "python3";
-  if (!isPython) return { content: "", cellLanguage: null };
-  const blocks = [];
-  nb.cells.forEach((cell, index) => {
-    if (typeof cell !== "object" || cell === null) return;
-    const c = cell;
-    if (c.cell_type === "code") {
-      const src = normalizeSource(c.source).replace(/\n+$/, "");
-      blocks.push(`# %% cell ${index}
-${src}`);
-    } else if (c.cell_type === "markdown") {
-      const src = normalizeSource(c.source).replace(/\n+$/, "");
-      const commented = src.split("\n").map((line) => line === "" ? "#" : `# ${line}`).join("\n");
-      blocks.push(`# %% [markdown] cell ${index}
-${commented}`);
-    }
-  });
-  return { content: blocks.join("\n\n"), cellLanguage: "python" };
-}
-
 // src/parser.ts
-var _require3 = createRequire3(import.meta.url);
+var _require2 = createRequire2(import.meta.url);
 var COMPILER_ARTIFACT_REF_NAMES = /* @__PURE__ */ new Set(["__name"]);
 var _parserCtor;
 var _parserCtorError = null;
@@ -11797,7 +11652,7 @@ function loadParserCtor() {
   if (_parserCtorOverride !== void 0) return _parserCtorOverride;
   if (_parserCtor !== void 0) return _parserCtor;
   try {
-    _parserCtor = _require3("tree-sitter");
+    _parserCtor = _require2("tree-sitter");
   } catch (e) {
     _parserCtor = null;
     _parserCtorError = e instanceof Error ? e : new Error(String(e));
@@ -11886,32 +11741,32 @@ function countNewlines(s) {
   return n;
 }
 function loadGrammar(lang, filePath, content) {
-  const useTsx = lang === "typescript" && filePath !== void 0 && path10.extname(filePath).toLowerCase() === ".tsx";
-  const useCppHeader = lang === "c" && filePath !== void 0 && path10.extname(filePath).toLowerCase() === ".h" && content !== void 0 && CPP_HEADER_SNIFF_RE.test(content);
+  const useTsx = lang === "typescript" && filePath !== void 0 && path8.extname(filePath).toLowerCase() === ".tsx";
+  const useCppHeader = lang === "c" && filePath !== void 0 && path8.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;
   let grammar = null;
   try {
     if (lang === "typescript") {
-      const mod = _require3("tree-sitter-typescript");
+      const mod = _require2("tree-sitter-typescript");
       grammar = useTsx ? mod.tsx : mod.typescript;
     } else if (lang === "javascript") {
-      grammar = _require3("tree-sitter-javascript");
+      grammar = _require2("tree-sitter-javascript");
     } else if (lang === "python") {
-      grammar = _require3("tree-sitter-python");
+      grammar = _require2("tree-sitter-python");
     } else if (lang === "go") {
-      grammar = _require3("tree-sitter-go");
+      grammar = _require2("tree-sitter-go");
     } else if (lang === "rust") {
-      grammar = _require3("tree-sitter-rust");
+      grammar = _require2("tree-sitter-rust");
     } else if (lang === "ruby") {
-      grammar = _require3("tree-sitter-ruby");
+      grammar = _require2("tree-sitter-ruby");
     } else if (lang === "java") {
-      grammar = _require3("tree-sitter-java");
+      grammar = _require2("tree-sitter-java");
     } else if (lang === "c") {
-      grammar = useCppHeader ? _require3("tree-sitter-cpp") : _require3("tree-sitter-c");
+      grammar = useCppHeader ? _require2("tree-sitter-cpp") : _require2("tree-sitter-c");
     } else if (lang === "cpp") {
-      grammar = _require3("tree-sitter-cpp");
+      grammar = _require2("tree-sitter-cpp");
     }
   } catch {
     grammar = null;
@@ -11937,7 +11792,7 @@ var TREE_SITTER_GRAMMAR_PACKAGES = [
 function missingTreeSitterGrammarPackages() {
   return TREE_SITTER_GRAMMAR_PACKAGES.filter((pkg) => {
     try {
-      _require3.resolve(pkg);
+      _require2.resolve(pkg);
       return false;
     } catch {
       return true;
@@ -12578,7 +12433,7 @@ var CALL_TYPES_BY_LANG = /* @__PURE__ */ new Map([
   ["rust", /* @__PURE__ */ new Set(["call_expression", "macro_invocation"])],
   ["java", /* @__PURE__ */ new Set(["method_invocation", "object_creation_expression"])],
   ["c", /* @__PURE__ */ new Set(["call_expression"])],
-  ["cpp", /* @__PURE__ */ new Set(["call_expression"])],
+  ["cpp", /* @__PURE__ */ new Set(["call_expression", "new_expression"])],
   ["ruby", /* @__PURE__ */ new Set(["call"])]
 ]);
 var REF_NOISE_BY_LANG = /* @__PURE__ */ new Map([
@@ -12770,6 +12625,38 @@ function cFunctionName(node) {
   }
   return null;
 }
+function cppCalleeName(node) {
+  switch (node.type) {
+    case "identifier":
+    case "field_identifier":
+    case "type_identifier":
+      return node.text;
+    // An overloaded operator's name is its own node type, and it is the spelling the extractor gives the operator's definition too, so returning the text here is what makes the two match. Measured: `r.template operator()<int>(3)` parses as `dependent_name(template, template_method(operator_name "operator()", template_argument_list "<int>"))`, so without this case the name resolved to null and the field_expression fallback below recorded `template operator()<int>` -- a spelling no symbol row ever holds, leaving the call permanently unresolvable.
+    case "operator_name":
+      return node.text;
+    case "template_function":
+    case "template_method":
+    case "template_type": {
+      const name = node.childForFieldName("name");
+      return name !== null ? cppCalleeName(name) : null;
+    }
+    case "qualified_identifier": {
+      const name = node.childForFieldName("name");
+      return name !== null ? cppCalleeName(name) : lastSegment(node.text);
+    }
+    case "dependent_name": {
+      const last = node.namedChildren[node.namedChildren.length - 1];
+      return last !== void 0 ? cppCalleeName(last) : null;
+    }
+    case "field_expression": {
+      const field = node.childForFieldName("field");
+      if (field === null) return null;
+      return cppCalleeName(field) ?? field.text;
+    }
+    default:
+      return null;
+  }
+}
 function calleeName(call, language) {
   switch (language) {
     case "typescript":
@@ -12821,12 +12708,9 @@ function calleeName(call, language) {
     }
     case "c":
     case "cpp": {
-      const fn = call.childForFieldName("function");
+      const fn = call.type === "new_expression" ? call.childForFieldName("type") : call.childForFieldName("function");
       if (fn === null) return null;
-      if (fn.type === "identifier") return fn.text;
-      if (fn.type === "field_expression") return fn.childForFieldName("field")?.text ?? null;
-      if (fn.type === "qualified_identifier") return lastSegment(fn.text);
-      return null;
+      return cppCalleeName(fn);
     }
     case "ruby": {
       const m = call.childForFieldName("method");
@@ -13594,7 +13478,7 @@ function parseSourceSymbolsTreeSitterOnly(content, filePath, language) {
 var REGEX_ADAPTERS_SLOT = /* @__PURE__ */ Symbol.for("token-goat.regex-adapters");
 var adapterSlot = globalThis;
 async function loadRegexExtractors() {
-  adapterSlot[REGEX_ADAPTERS_SLOT] ??= await import("./token-goat-chunk-OTW7LC4Y.mjs");
+  adapterSlot[REGEX_ADAPTERS_SLOT] ??= await import("./token-goat-chunk-6B44WLIF.mjs");
 }
 function regexAdapters() {
   const loaded = adapterSlot[REGEX_ADAPTERS_SLOT];
@@ -13656,9 +13540,9 @@ function isUnderSkipDir(filePath, skipDirs) {
 }
 function isParseSkipEligible(filePath, cfg) {
   if (isUnderSkipDir(filePath, cfg.skip_dirs)) return true;
-  if (cfg.skip_files.includes(path10.basename(filePath))) return true;
+  if (cfg.skip_files.includes(path8.basename(filePath))) return true;
   try {
-    const stat2 = fs13.statSync(filePath);
+    const stat2 = fs11.statSync(filePath);
     if (stat2.size > cfg.large_file_skip_kb * 1024) return true;
   } catch {
   }
@@ -13717,7 +13601,7 @@ function indexFileSync(rawPath, dbPath = globalDbPath(), preReadBytes) {
     raw = preReadBytes;
   } else {
     try {
-      raw = fs13.readFileSync(filePath);
+      raw = fs11.readFileSync(filePath);
     } catch (err) {
       if (err.code === "ENOENT") return;
       throw err;
@@ -13753,32 +13637,36 @@ var OVERSIZE_EMBED_SHA_PREFIX = "oversize:";
 function oversizeEmbedSha(sha, symbolOnlyKb) {
   return `${OVERSIZE_EMBED_SHA_PREFIX}${symbolOnlyKb}:${sha}`;
 }
+var TIMEOUT_EMBED_SHA_PREFIX = "timeout:";
+function timeoutEmbedSha(sha, workMillis) {
+  return `${TIMEOUT_EMBED_SHA_PREFIX}${workMillis}:${sha}`;
+}
 function canonicalizeIndexPath(absPath) {
   if (!isCaseInsensitiveFs()) return absPath;
   let real;
   try {
-    real = fs13.realpathSync.native(absPath);
+    real = fs11.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 = path10.basename(realNorm);
+  const realBase = path8.basename(realNorm);
   if (base === realBase) return absPath;
   if (foldPath(base) !== foldPath(realBase)) return absPath;
-  const callerDir = cut < 0 ? normalizePath(path10.resolve(".")) : normalizePath(absPath.slice(0, cut));
-  if (foldPath(callerDir) !== foldPath(path10.dirname(realNorm))) return absPath;
+  const callerDir = cut < 0 ? normalizePath(path8.resolve(".")) : normalizePath(absPath.slice(0, cut));
+  if (foldPath(callerDir) !== foldPath(path8.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(path10.resolve(absPath));
+  const candidate = normalizePath(path8.resolve(absPath));
   if (foldPath(stored) !== foldPath(candidate)) return false;
   let real;
   try {
-    real = normalizePath(fs13.realpathSync.native(absPath));
+    real = normalizePath(fs11.realpathSync.native(absPath));
   } catch {
     return false;
   }
@@ -13806,6 +13694,7 @@ function isEmbedFresh(storedEmbedSha, sha, embeddingsEnabled, depsAvailable, sym
   if (storedEmbedSha === sha) return true;
   if (!depsAvailable && storedEmbedSha === unavailableEmbedSha(sha)) return true;
   if (storedEmbedSha === oversizeEmbedSha(sha, symbolOnlyKb)) return true;
+  if (storedEmbedSha === timeoutEmbedSha(sha, MAX_DOCUMENT_WORK_MILLIS)) return true;
   return false;
 }
 async function indexFileEmbeddings(rawPath, dbPath = globalDbPath(), sha, onError) {
@@ -13823,6 +13712,7 @@ async function indexFileEmbeddings(rawPath, dbPath = globalDbPath(), sha, onErro
   }
   if (isEmbeddableDocument(filePath)) {
     let extracted;
+    let refusedOnTheClock = false;
     try {
       extracted = await extractEmbeddableDocumentText(filePath);
     } catch (err) {
@@ -13830,12 +13720,13 @@ async function indexFileEmbeddings(rawPath, dbPath = globalDbPath(), sha, onErro
         onError?.(err);
         return;
       }
+      refusedOnTheClock = isTransientDocumentRefusal(err);
       extracted = null;
     }
     if (extracted === null || extracted.trim().length === 0) {
       const db = getDb(dbPath);
       deleteFileEmbeddings(db, filePath);
-      stampEmbedSha(db, filePath, sha, (s) => s);
+      stampEmbedSha(db, filePath, sha, (s) => refusedOnTheClock ? timeoutEmbedSha(s, MAX_DOCUMENT_WORK_MILLIS) : s);
       return;
     }
     if (extracted.length > ixCfg.large_file_symbol_only_kb * 1024) {
@@ -13855,7 +13746,7 @@ async function indexFileEmbeddings(rawPath, dbPath = globalDbPath(), sha, onErro
   }
   let content;
   try {
-    content = decodeSource(await fs13.promises.readFile(filePath));
+    content = decodeSource(await fs11.promises.readFile(filePath));
   } catch {
     return;
   }
@@ -13901,7 +13792,7 @@ function stampEmbedSha(db, filePath, sha, makeValue) {
 }
 function safeMtime(filePath) {
   try {
-    return fs13.statSync(filePath).mtimeMs / 1e3;
+    return fs11.statSync(filePath).mtimeMs / 1e3;
   } catch {
     return 0;
   }
@@ -13909,8 +13800,8 @@ function safeMtime(filePath) {
 
 // src/index_prune.ts
 init_define_import_meta_env();
-import * as fs14 from "node:fs";
-import * as path11 from "node:path";
+import * as fs12 from "node:fs";
+import * as path9 from "node:path";
 function removeFileFromIndex(db, filePath) {
   const tx = db.transaction(() => {
     deleteFileRows(db, filePath);
@@ -13947,7 +13838,7 @@ function findDeletablePaths(rootPrefix, dbPath) {
   for (const p of foldedPathsUnderRoot(rootPrefix, dbPath)) {
     let stillExists;
     try {
-      const st = fs14.statSync(p, { throwIfNoEntry: false });
+      const st = fs12.statSync(p, { throwIfNoEntry: false });
       stillExists = st !== void 0 && st.isFile();
     } catch {
       continue;
@@ -13975,7 +13866,7 @@ function removeDeletedFilesBestEffort(db, paths) {
   for (const p of paths) {
     let gone;
     try {
-      const st = fs14.statSync(p, { throwIfNoEntry: false });
+      const st = fs12.statSync(p, { throwIfNoEntry: false });
       gone = st === void 0 || !st.isFile();
     } catch {
       continue;
@@ -14042,7 +13933,7 @@ function pruneOrphanedChunks(dbPath = globalDbPath()) {
   return removed;
 }
 function recordKnownRoot(filePath, dbPath = globalDbPath()) {
-  const project = findProject(path11.dirname(filePath));
+  const project = findProject(path9.dirname(filePath));
   if (project === null || isTooShallowToPrune(project.root)) return;
   const db = getDb(dbPath);
   db.prepare(
@@ -14065,7 +13956,7 @@ function sweepKnownRoots(dbPath = globalDbPath(), opts) {
     if (isTooShallowToPrune(root)) continue;
     let reachable;
     try {
-      reachable = fs14.statSync(root, { throwIfNoEntry: false })?.isDirectory() === true;
+      reachable = fs12.statSync(root, { throwIfNoEntry: false })?.isDirectory() === true;
     } catch {
       reachable = false;
     }
@@ -14100,19 +13991,19 @@ function sweepKnownRoots(dbPath = globalDbPath(), opts) {
 }
 var KNOWN_ROOT_RECORD_MIN_INTERVAL_MS = 60 * 60 * 1e3;
 function knownRootRecordMarkerPath(dir, filePath) {
-  return path11.join(dir, `known-root-record-${shortFingerprint(path11.dirname(filePath))}.marker`);
+  return path9.join(dir, `known-root-record-${shortFingerprint(path9.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 fs14.readdirSync(dir)) {
+    for (const file of fs12.readdirSync(dir)) {
       if (!file.startsWith(KNOWN_ROOT_MARKER_PREFIX) || !file.endsWith(".marker")) continue;
-      const full = path11.join(dir, file);
+      const full = path9.join(dir, file);
       try {
-        if (fs14.statSync(full).mtimeMs < cutoff) {
-          fs14.unlinkSync(full);
+        if (fs12.statSync(full).mtimeMs < cutoff) {
+          fs12.unlinkSync(full);
           removed += 1;
         }
       } catch {
@@ -14125,13 +14016,13 @@ function sweepExpiredKnownRootMarkers(dir = dataDir()) {
 function recordKnownRootThrottled(filePath, dir = dataDir(), dbPath = globalDbPath()) {
   const markerPath = knownRootRecordMarkerPath(dir, filePath);
   try {
-    const stat2 = fs14.statSync(markerPath);
+    const stat2 = fs12.statSync(markerPath);
     if (Date.now() - stat2.mtimeMs < KNOWN_ROOT_RECORD_MIN_INTERVAL_MS) return;
   } catch {
   }
   try {
     ensureDirSync(dir);
-    fs14.writeFileSync(markerPath, "");
+    fs12.writeFileSync(markerPath, "");
   } catch {
   }
   recordKnownRoot(filePath, dbPath);
@@ -14161,15 +14052,15 @@ function applyIndexingPriority() {
 
 // src/worker.ts
 init_define_import_meta_env();
-import { spawn as spawn2 } from "node:child_process";
-import * as fs16 from "node:fs";
-import * as path13 from "node:path";
+import { spawn } from "node:child_process";
+import * as fs14 from "node:fs";
+import * as path11 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/snapshots.ts
 init_define_import_meta_env();
-import * as fs15 from "node:fs";
-import * as path12 from "node:path";
+import * as fs13 from "node:fs";
+import * as path10 from "node:path";
 var MAX_SNAPSHOTS_PER_SESSION = 150;
 var MAX_SNAPSHOT_BYTES = 256 * 1024;
 var SNAPSHOT_TRUNCATE_BYTES = 50 * 1024;
@@ -14179,10 +14070,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 = path12.join(tokenGoatHome(), "session_snapshots");
-  const candidate = path12.join(base, safe);
+  const base = path10.join(tokenGoatHome(), "session_snapshots");
+  const candidate = path10.join(base, safe);
   try {
-    const rel = path12.relative(base, candidate);
+    const rel = path10.relative(base, candidate);
     if (rel.startsWith("..")) return null;
   } catch {
     return null;
@@ -14195,7 +14086,7 @@ function pathKey(filePath) {
 function snapshot_path(sessionId, filePath) {
   const d = sessionDir(sessionId);
   if (!d) return null;
-  return path12.join(d, `${pathKey(filePath)}.bin`);
+  return path10.join(d, `${pathKey(filePath)}.bin`);
 }
 function kindSidecarPath(snapshotPath) {
   return snapshotPath + ".kind";
@@ -14203,11 +14094,11 @@ function kindSidecarPath(snapshotPath) {
 function writeSnapshotKind(sidecarPath, kind) {
   try {
     const safeKind = VALID_KINDS.has(kind) ? kind : KIND_READ;
-    const dir = path12.dirname(sidecarPath);
-    if (!fs15.existsSync(dir)) {
+    const dir = path10.dirname(sidecarPath);
+    if (!fs13.existsSync(dir)) {
       ensureDirSync(dir);
     }
-    fs15.writeFileSync(sidecarPath, safeKind, "utf8");
+    fs13.writeFileSync(sidecarPath, safeKind, "utf8");
     return true;
   } catch {
     return false;
@@ -14216,12 +14107,12 @@ function writeSnapshotKind(sidecarPath, kind) {
 function evictOldest(d, maxCount) {
   try {
     const entries = [];
-    const files = fs15.readdirSync(d);
+    const files = fs13.readdirSync(d);
     for (const file of files) {
-      const fullPath = path12.join(d, file);
+      const fullPath = path10.join(d, file);
       if (!file.endsWith(".bin")) continue;
       try {
-        const stat2 = fs15.statSync(fullPath);
+        const stat2 = fs13.statSync(fullPath);
         entries.push([fullPath, stat2.mtimeMs]);
       } catch {
         continue;
@@ -14233,10 +14124,10 @@ function evictOldest(d, maxCount) {
     const over = entries.length - maxCount;
     for (const [p] of entries.slice(0, over)) {
       try {
-        fs15.unlinkSync(p);
+        fs13.unlinkSync(p);
         removed++;
         try {
-          fs15.unlinkSync(kindSidecarPath(p));
+          fs13.unlinkSync(kindSidecarPath(p));
         } catch {
         }
       } catch {
@@ -14265,10 +14156,10 @@ function store(sessionId, filePath, content, opts = {}) {
   if (!p) return null;
   const sha = fingerprintContent(stored);
   try {
-    const isNewEntry = !fs15.existsSync(p);
+    const isNewEntry = !fs13.existsSync(p);
     if (!isNewEntry) {
       try {
-        const existing = fs15.readFileSync(p);
+        const existing = fs13.readFileSync(p);
         if (Buffer.from(existing).equals(stored)) {
           return {
             path: p,
@@ -14279,8 +14170,8 @@ function store(sessionId, filePath, content, opts = {}) {
       } catch {
       }
     }
-    const dir = path12.dirname(p);
-    if (!fs15.existsSync(dir)) {
+    const dir = path10.dirname(p);
+    if (!fs13.existsSync(dir)) {
       ensureDirSync(dir);
     }
     if (isNewEntry) {
@@ -14300,9 +14191,9 @@ function store(sessionId, filePath, content, opts = {}) {
 }
 function load(sessionId, filePath, opts = {}) {
   const p = snapshot_path(sessionId, filePath);
-  if (!p || !fs15.existsSync(p)) return null;
+  if (!p || !fs13.existsSync(p)) return null;
   try {
-    const stat2 = fs15.statSync(p);
+    const stat2 = fs13.statSync(p);
     if (stat2.size > MAX_SNAPSHOT_BYTES) {
       return null;
     }
@@ -14310,7 +14201,7 @@ function load(sessionId, filePath, opts = {}) {
     return null;
   }
   try {
-    const data = fs15.readFileSync(p);
+    const data = fs13.readFileSync(p);
     if (opts.expected_sha) {
       const actualSha = fingerprintContent(data);
       if (actualSha.toLowerCase() !== opts.expected_sha.toLowerCase()) {
@@ -14323,31 +14214,31 @@ function load(sessionId, filePath, opts = {}) {
   }
 }
 function removeEligibleSnapshotFile(fullPath, file, cutoff) {
-  const stat2 = fs15.lstatSync(fullPath);
+  const stat2 = fs13.lstatSync(fullPath);
   if ((stat2.mode & 61440) === 40960) return false;
   if (cutoff !== void 0 && stat2.mtimeMs >= cutoff) return false;
-  fs15.unlinkSync(fullPath);
+  fs13.unlinkSync(fullPath);
   return file.endsWith(".bin");
 }
 function cleanup_stale(maxAgeHours = 24) {
-  const base = path12.join(tokenGoatHome(), "session_snapshots");
-  if (!fs15.existsSync(base)) return 0;
+  const base = path10.join(tokenGoatHome(), "session_snapshots");
+  if (!fs13.existsSync(base)) return 0;
   const cutoff = Date.now() - maxAgeHours * 3600 * 1e3;
   let removed = 0;
   try {
-    const sessionDirs = fs15.readdirSync(base);
+    const sessionDirs = fs13.readdirSync(base);
     for (const sessionDir2 of sessionDirs) {
-      const sessionPath2 = path12.join(base, sessionDir2);
+      const sessionPath2 = path10.join(base, sessionDir2);
       try {
-        const stat2 = fs15.statSync(sessionPath2);
+        const stat2 = fs13.statSync(sessionPath2);
         if (!stat2.isDirectory()) continue;
       } catch {
         continue;
       }
       try {
-        const files = fs15.readdirSync(sessionPath2);
+        const files = fs13.readdirSync(sessionPath2);
         for (const file of files) {
-          const fullPath = path12.join(sessionPath2, file);
+          const fullPath = path10.join(sessionPath2, file);
           try {
             if (removeEligibleSnapshotFile(fullPath, file, cutoff)) removed++;
           } catch {
@@ -14355,7 +14246,7 @@ function cleanup_stale(maxAgeHours = 24) {
           }
         }
         try {
-          fs15.rmdirSync(sessionPath2);
+          fs13.rmdirSync(sessionPath2);
         } catch {
         }
       } catch {
@@ -14387,7 +14278,7 @@ var unclearedDrainingSnapshots = /* @__PURE__ */ new Map();
 function drainingSnapshotStamp(file, content) {
   let identity = "unknown";
   try {
-    const stat2 = fs16.statSync(file);
+    const stat2 = fs14.statSync(file);
     identity = `${stat2.mtimeMs}:${stat2.size}:${stat2.ino}`;
   } catch {
   }
@@ -14396,15 +14287,15 @@ function drainingSnapshotStamp(file, content) {
 var DRAINING_READ_ATTEMPTS = 5;
 var DRAINING_READ_RETRY_DELAY_MS = 50;
 function listDrainingFiles(queuePath) {
-  const dir = path13.dirname(queuePath);
-  const base = `${path13.basename(queuePath)}.draining`;
+  const dir = path11.dirname(queuePath);
+  const base = `${path11.basename(queuePath)}.draining`;
   let entries;
   try {
-    entries = fs16.readdirSync(dir);
+    entries = fs14.readdirSync(dir);
   } catch {
     return [];
   }
-  return entries.filter((name) => name === base || name.startsWith(`${base}.alt-`) && !name.includes(".corrupt-")).sort().map((name) => path13.join(dir, name));
+  return entries.filter((name) => name === base || name.startsWith(`${base}.alt-`) && !name.includes(".corrupt-")).sort().map((name) => path11.join(dir, name));
 }
 var MAX_TRANSIENT_RETRIES = 5;
 function bumpRetryCount(dbPath, absPath) {
@@ -14432,17 +14323,17 @@ function clearRetryCount(dbPath, absPath) {
   }
 }
 function dirtyQueuePathFor(dir) {
-  return path13.join(dir, "queue", "dirty.txt");
+  return path11.join(dir, "queue", "dirty.txt");
 }
 function drainHeartbeatPathFor(dir) {
-  return path13.join(dir, "queue", "drain-heartbeat");
+  return path11.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(path13.dirname(drainHeartbeatPathFor(dir)));
-    fs16.writeFileSync(drainHeartbeatPathFor(dir), `${process.pid}
+    ensureDirSync(path11.dirname(drainHeartbeatPathFor(dir)));
+    fs14.writeFileSync(drainHeartbeatPathFor(dir), `${process.pid}
 `);
     heartbeatWriteTimes.set(dir, now);
   } catch {
@@ -14451,15 +14342,15 @@ function writeDrainHeartbeat(dir, force = false) {
 function hasFreshWorkerHeartbeat(dir, pid) {
   try {
     const heartbeatPath = drainHeartbeatPathFor(dir);
-    if (Date.now() - fs16.statSync(heartbeatPath).mtimeMs > WORKER_HEARTBEAT_STALE_MS) return false;
-    return fs16.readFileSync(heartbeatPath, "utf8").trim() === String(pid);
+    if (Date.now() - fs14.statSync(heartbeatPath).mtimeMs > WORKER_HEARTBEAT_STALE_MS) return false;
+    return fs14.readFileSync(heartbeatPath, "utf8").trim() === String(pid);
   } catch {
     return false;
   }
 }
 function pidFileIsWithinStartupGrace(dir) {
   try {
-    return Date.now() - fs16.statSync(workerPidPath(dir)).mtimeMs < WORKER_STARTUP_GRACE_MS;
+    return Date.now() - fs14.statSync(workerPidPath(dir)).mtimeMs < WORKER_STARTUP_GRACE_MS;
   } catch {
     return false;
   }
@@ -14493,28 +14384,28 @@ function parseDirtyQueueLines(raw) {
   return out;
 }
 function workerPidPath(dir = dataDir()) {
-  return path13.join(dir, "worker.pid");
+  return path11.join(dir, "worker.pid");
 }
 function getDirtyPathsFor(dir) {
   let raw;
   try {
-    raw = fs16.readFileSync(dirtyQueuePathFor(dir), "utf8");
+    raw = fs14.readFileSync(dirtyQueuePathFor(dir), "utf8");
   } catch {
     return [];
   }
   return parseDirtyQueueLines(raw);
 }
 function workerErrorLogPath(dir) {
-  return path13.join(dir, "worker-errors.log");
+  return path11.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 = fs16.statSync(logPath);
+    const stat2 = fs14.statSync(logPath);
     if (stat2.size > WORKER_ERROR_LOG_MAX_BYTES) {
-      fs16.writeFileSync(
+      fs14.writeFileSync(
         logPath,
         `${(/* @__PURE__ */ new Date()).toISOString()} worker-errors.log rotated (exceeded ${WORKER_ERROR_LOG_MAX_BYTES} bytes)
 `
@@ -14523,13 +14414,13 @@ function cleanupWorkerStateFiles(dir) {
   } catch {
   }
   try {
-    const queueDir = path13.dirname(dirtyQueuePathFor(dir));
+    const queueDir = path11.dirname(dirtyQueuePathFor(dir));
     const cutoff = Date.now() - CORRUPT_QUARANTINE_MAX_AGE_MS;
-    for (const file of fs16.readdirSync(queueDir)) {
+    for (const file of fs14.readdirSync(queueDir)) {
       if (!file.includes(".corrupt-")) continue;
-      const full = path13.join(queueDir, file);
+      const full = path11.join(queueDir, file);
       try {
-        if (fs16.statSync(full).mtimeMs < cutoff) fs16.unlinkSync(full);
+        if (fs14.statSync(full).mtimeMs < cutoff) fs14.unlinkSync(full);
       } catch {
       }
     }
@@ -14563,7 +14454,7 @@ registerReset(() => {
 function embedFileSerialized(absPath, dbPath, sha) {
   const key = foldPath(absPath);
   const prior = inFlightEmbeddings.get(key);
-  const dir = path13.dirname(dbPath);
+  const dir = path11.dirname(dbPath);
   const onEmbedError = (err) => {
     const message = extractErrorMessage(err);
     appendWorkerErrorLog(dir, `${(/* @__PURE__ */ new Date()).toISOString()} indexFileEmbeddings failed for ${absPath}: ${message}
@@ -14600,7 +14491,7 @@ function oneLogLine(line) {
 }
 function appendWorkerErrorLog(dir, line) {
   try {
-    fs16.appendFileSync(workerErrorLogPath(dir), oneLogLine(line));
+    fs14.appendFileSync(workerErrorLogPath(dir), oneLogLine(line));
   } catch {
   }
 }
@@ -14617,7 +14508,7 @@ function logTransientReadFailure(dir, absPath) {
   );
 }
 function bumpAndCheckRetry(dir, absPath) {
-  const dbPath = path13.join(dir, "global.db");
+  const dbPath = path11.join(dir, "global.db");
   const attempts = bumpRetryCount(dbPath, absPath);
   if (attempts > MAX_TRANSIENT_RETRIES) {
     if (attempts === MAX_TRANSIENT_RETRIES + 1) {
@@ -14634,14 +14525,14 @@ function bumpAndCheckRetry(dir, absPath) {
 function appendToDirtyQueue(dir, absPath) {
   const queuePath = dirtyQueuePathFor(dir);
   try {
-    ensureDirSync(path13.dirname(queuePath));
+    ensureDirSync(path11.dirname(queuePath));
     let leadingNewline = "";
     try {
-      const existing = fs16.readFileSync(queuePath, "utf8");
+      const existing = fs14.readFileSync(queuePath, "utf8");
       if (existing.length > 0 && !existing.endsWith("\n")) leadingNewline = "\n";
     } catch {
     }
-    fs16.appendFileSync(queuePath, `${leadingNewline}${encodeDirtyQueueLine(absPath)}
+    fs14.appendFileSync(queuePath, `${leadingNewline}${encodeDirtyQueueLine(absPath)}
 `);
   } catch {
   }
@@ -14650,7 +14541,7 @@ function requeueDirtyPath(dir, absPath) {
   if (bumpAndCheckRetry(dir, absPath)) appendToDirtyQueue(dir, absPath);
 }
 function makeIndexer(dbPath) {
-  const dir = path13.dirname(dbPath);
+  const dir = path11.dirname(dbPath);
   return (absPath, sha) => {
     try {
       const ixCfgForSkip = loadConfig().indexing;
@@ -14711,14 +14602,14 @@ function processDirtyBatch(paths, index = makeIndexer(globalDbPath()), remove =
       continue;
     }
     try {
-      const dirname15 = path13.dirname(p);
+      const dirname14 = path11.dirname(p);
       let root;
-      if (projectRootCache.has(dirname15)) {
-        root = projectRootCache.get(dirname15) ?? null;
+      if (projectRootCache.has(dirname14)) {
+        root = projectRootCache.get(dirname14) ?? null;
       } else {
-        const project = findProject(dirname15);
+        const project = findProject(dirname14);
         root = project?.root ?? null;
-        projectRootCache.set(dirname15, root);
+        projectRootCache.set(dirname14, root);
       }
       if (root) lastKnownProjectRoots.set(dir, root);
     } catch {
@@ -14728,7 +14619,7 @@ function processDirtyBatch(paths, index = makeIndexer(globalDbPath()), remove =
       requeue(dir, p);
       continue;
     }
-    clearRetryCount(path13.join(dir, "global.db"), p);
+    clearRetryCount(path11.join(dir, "global.db"), p);
     if (result !== false) indexed += 1;
   }
   return indexed;
@@ -14742,7 +14633,7 @@ function sleepSyncMs(ms) {
 function drainOnce(dir, index, remove) {
   const queuePath = dirtyQueuePathFor(dir);
   const draining = `${queuePath}.draining`;
-  const dbPath = path13.join(dir, "global.db");
+  const dbPath = path11.join(dir, "global.db");
   const indexFn = index ?? makeIndexer(dbPath);
   const removeFn = remove ?? makeRemover(dbPath);
   let processed = 0;
@@ -14759,7 +14650,7 @@ function drainOnce(dir, index, remove) {
     let drainingContent = null;
     for (let attempt = 0; attempt < DRAINING_READ_ATTEMPTS; attempt++) {
       try {
-        drainingContent = fs16.readFileSync(drainingFile, "utf8");
+        drainingContent = fs14.readFileSync(drainingFile, "utf8");
         break;
       } catch {
         if (attempt < DRAINING_READ_ATTEMPTS - 1) sleepSyncMs(DRAINING_READ_RETRY_DELAY_MS);
@@ -14767,7 +14658,7 @@ function drainOnce(dir, index, remove) {
     }
     if (drainingContent === null) {
       try {
-        fs16.renameSync(drainingFile, `${drainingFile}.corrupt-${Date.now()}`);
+        fs14.renameSync(drainingFile, `${drainingFile}.corrupt-${Date.now()}`);
         unclearedDrainingSnapshots.delete(drainingFile);
       } catch {
       }
@@ -14777,23 +14668,23 @@ function drainOnce(dir, index, remove) {
       processed += processDirtyBatch(parseDirtyQueueLines(drainingContent), indexFn, removeFn, dir, requeueFn);
     }
     try {
-      fs16.rmSync(drainingFile, { force: true });
+      fs14.rmSync(drainingFile, { force: true });
       unclearedDrainingSnapshots.delete(drainingFile);
     } catch {
       try {
-        fs16.renameSync(drainingFile, `${drainingFile}.corrupt-${Date.now()}`);
+        fs14.renameSync(drainingFile, `${drainingFile}.corrupt-${Date.now()}`);
         unclearedDrainingSnapshots.delete(drainingFile);
       } catch {
         unclearedDrainingSnapshots.set(drainingFile, drainingSnapshotStamp(drainingFile, drainingContent));
       }
     }
   }
-  if (fs16.existsSync(queuePath)) {
-    const claimTarget = fs16.existsSync(draining) ? `${draining}.alt-${Date.now()}` : draining;
+  if (fs14.existsSync(queuePath)) {
+    const claimTarget = fs14.existsSync(draining) ? `${draining}.alt-${Date.now()}` : draining;
     let claimed = false;
     for (let attempt = 0; attempt < 5; attempt++) {
       try {
-        fs16.renameSync(queuePath, claimTarget);
+        fs14.renameSync(queuePath, claimTarget);
         claimed = true;
         break;
       } catch {
@@ -14804,14 +14695,14 @@ function drainOnce(dir, index, remove) {
       let claimedContent = "";
       let readOk = false;
       try {
-        claimedContent = fs16.readFileSync(claimTarget, "utf8");
+        claimedContent = fs14.readFileSync(claimTarget, "utf8");
         readOk = true;
       } catch {
       }
       if (readOk) {
         processed += processDirtyBatch(parseDirtyQueueLines(claimedContent), indexFn, removeFn, dir, requeueFn);
         try {
-          const recheck = fs16.readFileSync(claimTarget, "utf8");
+          const recheck = fs14.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);
@@ -14819,10 +14710,10 @@ function drainOnce(dir, index, remove) {
         } catch {
         }
         try {
-          fs16.rmSync(claimTarget, { force: true });
+          fs14.rmSync(claimTarget, { force: true });
         } catch {
           try {
-            fs16.renameSync(claimTarget, `${claimTarget}.corrupt-${Date.now()}`);
+            fs14.renameSync(claimTarget, `${claimTarget}.corrupt-${Date.now()}`);
           } catch {
             unclearedDrainingSnapshots.set(claimTarget, drainingSnapshotStamp(claimTarget, claimedContent));
           }
@@ -14855,7 +14746,7 @@ function pidAlive(pid) {
 }
 function readPidFile(dir) {
   try {
-    const raw = fs16.readFileSync(workerPidPath(dir), "utf8").trim();
+    const raw = fs14.readFileSync(workerPidPath(dir), "utf8").trim();
     if (!/^\d+$/.test(raw)) return null;
     return parseInt(raw, 10);
   } catch {
@@ -14868,20 +14759,20 @@ function isWorkerRunning(dir = dataDir()) {
   return pidAlive(pid) && hasFreshWorkerHeartbeat(dir, pid);
 }
 function workerHealthCheckMarkerPath(dir) {
-  return path13.join(dir, "worker-healthcheck.marker");
+  return path11.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 = fs16.statSync(markerPath);
+    const stat2 = fs14.statSync(markerPath);
     if (Date.now() - stat2.mtimeMs < WORKER_HEALTHCHECK_MIN_INTERVAL_MS) return;
   } catch {
   }
   try {
     ensureDirSync(dir);
-    fs16.writeFileSync(markerPath, "");
+    fs14.writeFileSync(markerPath, "");
   } catch {
   }
   if (isWorkerRunning(dir)) return;
@@ -14911,7 +14802,7 @@ function stopWorker(dir = dataDir()) {
   }
   if (readPidFile(dir) === pid) {
     try {
-      fs16.rmSync(workerPidPath(dir), { force: true });
+      fs14.rmSync(workerPidPath(dir), { force: true });
     } catch {
     }
   }
@@ -14926,7 +14817,7 @@ var WorkerAlreadyRunningError = class extends Error {
 function claimWorkerPidFile(dir, pid) {
   const pidPath = workerPidPath(dir);
   try {
-    fs16.writeFileSync(pidPath, `${pid}
+    fs14.writeFileSync(pidPath, `${pid}
 `, { flag: "wx" });
     return true;
   } catch (e) {
@@ -14943,11 +14834,11 @@ function claimWorkerPidFile(dir, pid) {
     }
   }
   try {
-    fs16.rmSync(pidPath, { force: true });
+    fs14.rmSync(pidPath, { force: true });
   } catch {
   }
   try {
-    fs16.writeFileSync(pidPath, `${pid}
+    fs14.writeFileSync(pidPath, `${pid}
 `, { flag: "wx" });
     return true;
   } catch (e2) {
@@ -14957,9 +14848,9 @@ function claimWorkerPidFile(dir, pid) {
 }
 function daemonEntryScript() {
   const self = fileURLToPath(import.meta.url);
-  const launcher = path13.join(path13.dirname(self), "token-goat.mjs");
+  const launcher = path11.join(path11.dirname(self), "token-goat.mjs");
   try {
-    if (fs16.existsSync(launcher)) return launcher;
+    if (fs14.existsSync(launcher)) return launcher;
   } catch {
   }
   return self;
@@ -14970,9 +14861,9 @@ function startDetachedWorker(opts) {
   try {
     ensureDirSync(dir);
   } catch (e) {
-    if (e.code !== "EEXIST" || !fs16.existsSync(dir)) throw e;
+    if (e.code !== "EEXIST" || !fs14.existsSync(dir)) throw e;
   }
-  const child = spawn2(
+  const child = spawn(
     process.execPath,
     [daemonEntryScript(), "--worker-daemon"],
     {
@@ -15008,7 +14899,7 @@ async function runWorkerLoop(dir, pollIntervalMs, shouldStop = () => false) {
   let lastKnownRootsSweepMs = 0;
   let ownedPidFile = false;
   while (!shouldStop()) {
-    if (!fs16.existsSync(dir)) break;
+    if (!fs14.existsSync(dir)) break;
     const pidOwner = readPidFile(dir);
     if (pidOwner === process.pid) ownedPidFile = true;
     else if (ownedPidFile && pidOwner !== null) break;
@@ -15033,7 +14924,7 @@ async function runWorkerLoop(dir, pollIntervalMs, shouldStop = () => false) {
     }
     if (Date.now() - lastKnownRootsSweepMs >= KNOWN_ROOTS_SWEEP_INTERVAL_MS) {
       try {
-        const result = sweepKnownRoots(path13.join(dir, "global.db"));
+        const result = sweepKnownRoots(path11.join(dir, "global.db"));
         if (result.flaggedRoots.length > 0) {
           appendWorkerErrorLog(
             dir,
@@ -15069,7 +14960,7 @@ function runDetachedWorkerDaemon() {
   process.on("exit", () => {
     if (readPidFile(dir) === process.pid) {
       try {
-        fs16.rmSync(workerPidPath(dir), { force: true });
+        fs14.rmSync(workerPidPath(dir), { force: true });
       } catch {
       }
     }
@@ -15080,26 +14971,26 @@ function runDetachedWorkerDaemon() {
 
 // src/hooks_index.ts
 init_define_import_meta_env();
-import * as fs17 from "node:fs";
-import * as path14 from "node:path";
+import * as fs15 from "node:fs";
+import * as path12 from "node:path";
 function dirtyQueuePath() {
-  return path14.join(dataDir(), "queue", "dirty.txt");
+  return path12.join(dataDir(), "queue", "dirty.txt");
 }
 function appendDirtyPath(normalizedPath) {
   const queuePath = dirtyQueuePath();
-  const dir = path14.dirname(queuePath);
+  const dir = path12.dirname(queuePath);
   try {
     ensureDirSync(dir);
   } catch (e) {
-    if (e.code !== "EEXIST" || !fs17.existsSync(dir)) throw e;
+    if (e.code !== "EEXIST" || !fs15.existsSync(dir)) throw e;
   }
   let leadingNewline = "";
   try {
-    const existing = fs17.readFileSync(queuePath, "utf8");
+    const existing = fs15.readFileSync(queuePath, "utf8");
     if (existing.length > 0 && !existing.endsWith("\n")) leadingNewline = "\n";
   } catch {
   }
-  fs17.appendFileSync(queuePath, `${leadingNewline}${encodeDirtyQueueLine(normalizedPath)}
+  fs15.appendFileSync(queuePath, `${leadingNewline}${encodeDirtyQueueLine(normalizedPath)}
 `);
 }
 function enqueueDirtyPathSafe(filePath, opts) {
@@ -15117,7 +15008,7 @@ function getDirtyPaths() {
   const queuePath = dirtyQueuePath();
   let raw;
   try {
-    raw = fs17.readFileSync(queuePath, "utf8");
+    raw = fs15.readFileSync(queuePath, "utf8");
   } catch {
     return [];
   }
@@ -15126,9 +15017,9 @@ function getDirtyPaths() {
 function preCompactIndexHandler(_event) {
   const paths = getDirtyPaths();
   if (paths.length > 0) {
-    const sidecar = path14.join(dataDir(), "queue", "pending.txt");
+    const sidecar = path12.join(dataDir(), "queue", "pending.txt");
     try {
-      ensureDirSync(path14.dirname(sidecar));
+      ensureDirSync(path12.dirname(sidecar));
       atomicWriteBytes(sidecar, Buffer.from(`${paths.join("\n")}
 `, "utf8"));
     } catch {
@@ -15140,7 +15031,7 @@ registerHook("pre_compact", preCompactIndexHandler, { advisory: true });
 
 // src/section_reader.ts
 init_define_import_meta_env();
-import { readFileSync as readFileSync13 } from "node:fs";
+import { readFileSync as readFileSync11 } from "node:fs";
 function parseHeadingSpec(spec, headers) {
   const m = /^([^#\r\n]+)#(\d+)$/.exec(spec);
   if (m !== null && m[1] !== void 0 && m[2] !== void 0) {
@@ -15438,7 +15329,7 @@ function readTextForSections(filePath, readFn) {
     text = read;
   } else {
     try {
-      text = decodeSource(readFileSync13(filePath));
+      text = decodeSource(readFileSync11(filePath));
     } catch {
       return null;
     }
@@ -15499,8 +15390,8 @@ function listSections(filePath, readFn) {
 
 // src/hooks_read.ts
 init_define_import_meta_env();
-import * as fs22 from "node:fs";
-import * as path19 from "node:path";
+import * as fs20 from "node:fs";
+import * as path17 from "node:path";
 
 // src/served_lines.ts
 init_define_import_meta_env();
@@ -15594,8 +15485,8 @@ function planServedElisions(rows, bodies) {
 
 // src/compact.ts
 init_define_import_meta_env();
-import * as fs18 from "node:fs";
-import * as path15 from "node:path";
+import * as fs16 from "node:fs";
+import * as path13 from "node:path";
 var CONTEXT_AUTOCOMPACT_TOKENS = 66e4;
 var CATALOG_TOKENS = 10800;
 var CONTEXT_TIER_WARM = 0.5;
@@ -15785,7 +15676,7 @@ function inferSessionGoal(cache, maxTokens = 80) {
     const dirCounts = new Counter();
     for (const fpath of editedPaths) {
       try {
-        let parent = path15.dirname(fpath);
+        let parent = path13.dirname(fpath);
         if (parent === ".") {
           parent = "root";
         } else if (parent.startsWith("./")) {
@@ -15863,11 +15754,11 @@ function isNoisePath(inputPath) {
 }
 function findLatestSessionId() {
   try {
-    const sessionsDir = path15.join(tokenGoatHome(), "sessions");
-    if (!fs18.existsSync(sessionsDir)) {
+    const sessionsDir = path13.join(tokenGoatHome(), "sessions");
+    if (!fs16.existsSync(sessionsDir)) {
       return null;
     }
-    const files = fs18.readdirSync(sessionsDir);
+    const files = fs16.readdirSync(sessionsDir);
     const jsonFiles = files.filter((f) => f.endsWith(".json") && !f.includes(AGENT_SALT_MARKER));
     if (jsonFiles.length === 0) {
       return null;
@@ -15877,9 +15768,9 @@ function findLatestSessionId() {
       return null;
     }
     let latestFile = firstFile;
-    let latestMtime = fs18.statSync(path15.join(sessionsDir, firstFile)).mtimeMs;
+    let latestMtime = fs16.statSync(path13.join(sessionsDir, firstFile)).mtimeMs;
     for (const file of jsonFiles) {
-      const mtime = fs18.statSync(path15.join(sessionsDir, file)).mtimeMs;
+      const mtime = fs16.statSync(path13.join(sessionsDir, file)).mtimeMs;
       if (mtime > latestMtime) {
         latestFile = file;
         latestMtime = mtime;
@@ -15901,37 +15792,37 @@ function eventCount(cache) {
 function writeSessionManifest(projectHash, sessionId, manifestJson) {
   const safeSessionId = sanitizeIdForFilename(sessionId, 64);
   if (!safeSessionId) return;
-  const sessionsDir = path15.join(dataDir(), "projects", projectHash, "sessions");
-  if (!fs18.existsSync(sessionsDir)) {
+  const sessionsDir = path13.join(dataDir(), "projects", projectHash, "sessions");
+  if (!fs16.existsSync(sessionsDir)) {
     ensureDirSync(sessionsDir);
   }
-  const dest = path15.join(sessionsDir, `${safeSessionId}.json`);
+  const dest = path13.join(sessionsDir, `${safeSessionId}.json`);
   atomicWriteText(dest, JSON.stringify(manifestJson));
 }
 function readAllSessionManifests(projectHash, maxAgeSecs = 3600) {
-  const sessionsDir = path15.join(dataDir(), "projects", projectHash, "sessions");
-  if (!fs18.existsSync(sessionsDir)) {
+  const sessionsDir = path13.join(dataDir(), "projects", projectHash, "sessions");
+  if (!fs16.existsSync(sessionsDir)) {
     return [];
   }
   const now = Date.now() / 1e3;
   const results = [];
   try {
-    const files = fs18.readdirSync(sessionsDir);
+    const files = fs16.readdirSync(sessionsDir);
     for (const file of files) {
       if (!file.endsWith(".json")) {
         continue;
       }
       try {
-        const fullPath = path15.join(sessionsDir, file);
-        const stat2 = fs18.statSync(fullPath);
+        const fullPath = path13.join(sessionsDir, file);
+        const stat2 = fs16.statSync(fullPath);
         if (now - stat2.mtimeMs / 1e3 > maxAgeSecs) {
           try {
-            fs18.unlinkSync(fullPath);
+            fs16.unlinkSync(fullPath);
           } catch {
           }
           continue;
         }
-        const text = fs18.readFileSync(fullPath, "utf8");
+        const text = fs16.readFileSync(fullPath, "utf8");
         const data = JSON.parse(text);
         if (typeof data === "object" && data !== null && "files" in data) {
           results.push(data);
@@ -16133,11 +16024,11 @@ function buildPackageManifestHint(options) {
     return null;
   }
 }
-function _sanitizeHintPath(path24) {
-  if (typeof path24 !== "string") {
+function _sanitizeHintPath(path22) {
+  if (typeof path22 !== "string") {
     return "???";
   }
-  return path24.replace(/[\x00]/g, "").slice(0, 200);
+  return path22.replace(/[\x00]/g, "").slice(0, 200);
 }
 
 // src/hints/file_type_handler.ts
@@ -16152,9 +16043,16 @@ var FILE_TYPE_THRESHOLDS = {
   xml: 2e4,
   csv: 1e4,
   tsv: 1e4,
+  json: 2e4,
+  yaml: 2e4,
+  jsonl: 2e4,
   transcript: 1e4,
   office: 0,
   // always block (.docx etc)
+  sqlite: 0,
+  // always block (.db, .sqlite, etc)
+  parquet: 0,
+  // always block (.parquet)
   generic: 1e5
   // catch-all for unrecognized large files
 };
@@ -16349,6 +16247,7 @@ function handleDocx(filePath) {
     message: [
       `Word file \u2014 Read cannot return document content; this is not retryable with different Read parameters.`,
       `See headings: token-goat docx-outline "${filePath}"`,
+      `Extract tables: token-goat docx-tables "${filePath}"`,
       `Read full text: token-goat docx-text "${filePath}"`
     ].join("\n")
   };
@@ -16415,6 +16314,106 @@ function handleTranscript(filePath, content, contentLengthHint) {
     ].filter(Boolean).join("\n")
   };
 }
+function handleSqlite(filePath) {
+  return {
+    shouldBlock: true,
+    message: [
+      `SQLite database \u2014 Read cannot return binary database content; this is not retryable with different Read parameters.`,
+      `See tables: token-goat sqlite-tables "${filePath}"`,
+      `See schema: token-goat sqlite-schema "${filePath}"`,
+      `Query data: token-goat sqlite-query "${filePath}" "SELECT ... FROM ... LIMIT 20"`
+    ].join("\n")
+  };
+}
+function handleParquet(filePath) {
+  return {
+    shouldBlock: true,
+    message: [
+      `Parquet file \u2014 Read cannot return binary columnar content; this is not retryable with different Read parameters.`,
+      `Query with DuckDB: duckdb -c "SELECT * FROM read_parquet('${filePath}') LIMIT 10"`
+    ].join("\n")
+  };
+}
+function handleJson(filePath, content, contentLengthHint) {
+  const length = contentLengthHint ?? content.length;
+  if (length < FILE_TYPE_THRESHOLDS.json) return { shouldBlock: false, message: "" };
+  if (previewUnavailable(content, length)) {
+    return {
+      shouldBlock: true,
+      message: [
+        `Large JSON file (${formatBytes(length)}) \u2014 too large to preview (exceeds the in-hook scan cap).`,
+        `See structure: token-goat json-outline "${filePath}"`,
+        `Query subtree: token-goat json-query "${filePath}" '<path>'`
+      ].join("\n")
+    };
+  }
+  let summary = "";
+  try {
+    const parsed = JSON.parse(content);
+    if (Array.isArray(parsed)) {
+      summary = `JSON array (${parsed.length} items)`;
+      if (parsed.length > 0 && typeof parsed[0] === "object" && parsed[0] !== null) {
+        const itemKeys = Object.keys(parsed[0]).slice(0, 10);
+        summary += `, item keys: ${itemKeys.join(", ")}${Object.keys(parsed[0]).length > 10 ? "..." : ""}`;
+      }
+    } else if (typeof parsed === "object" && parsed !== null) {
+      const keys = Object.keys(parsed).slice(0, 15);
+      summary = `Top-level keys (${Object.keys(parsed).length}): ${keys.join(", ")}${Object.keys(parsed).length > 15 ? "..." : ""}`;
+    }
+  } catch {
+  }
+  return {
+    shouldBlock: true,
+    message: [
+      `Large JSON file (${formatBytes(length)}).`,
+      summary ? fenceUntrustedFileContent(summary) : "",
+      `See structure: token-goat json-outline "${filePath}"`,
+      `Query subtree: token-goat json-query "${filePath}" '<path>'`
+    ].filter(Boolean).join("\n")
+  };
+}
+function handleYaml(filePath, content, contentLengthHint) {
+  const length = contentLengthHint ?? content.length;
+  if (length < FILE_TYPE_THRESHOLDS.yaml) return { shouldBlock: false, message: "" };
+  return {
+    shouldBlock: true,
+    message: [
+      `Large YAML file (${formatBytes(length)}).`,
+      `See structure: token-goat yaml-outline "${filePath}"`,
+      `Query subtree: token-goat yaml-query "${filePath}" '<path>'`
+    ].join("\n")
+  };
+}
+function handleJsonl(filePath, content, contentLengthHint) {
+  const length = contentLengthHint ?? content.length;
+  if (length < FILE_TYPE_THRESHOLDS.jsonl) return { shouldBlock: false, message: "" };
+  if (previewUnavailable(content, length)) {
+    return {
+      shouldBlock: true,
+      message: `Large JSON Lines file (${formatBytes(length)}) \u2014 too large to preview (exceeds the in-hook scan cap). Slice records with Read using offset and limit (each line is a single JSON record).`
+    };
+  }
+  const lines2 = content.split(/\r?\n/).filter((l) => l.trim().length > 0);
+  let schema = "";
+  if (lines2.length > 0) {
+    try {
+      const firstObj = JSON.parse(lines2[0]);
+      if (typeof firstObj === "object" && firstObj !== null && !Array.isArray(firstObj)) {
+        const keys = Object.keys(firstObj).slice(0, 15);
+        schema = `Record keys: ${keys.join(", ")}${Object.keys(firstObj).length > 15 ? "..." : ""}`;
+      }
+    } catch {
+    }
+  }
+  return {
+    shouldBlock: true,
+    message: [
+      `Large JSON Lines file (${formatBytes(length)}, ~${lines2.length} records).`,
+      schema ? fenceUntrustedFileContent(schema) : "",
+      `Slice records with Read using offset and limit (each line is a single JSON record), e.g. offset=1, limit=5.`
+    ].filter(Boolean).join("\n")
+  };
+}
 function handleGenericLarge(filePath, contentLength) {
   if (contentLength < FILE_TYPE_THRESHOLDS.generic) return { shouldBlock: false, message: "" };
   return {
@@ -16435,40 +16434,45 @@ function dispatchFileTypeHandler(filePath, content, contentLengthHint) {
   if (ext === "pptx") return handlePptx(filePath);
   if (ext === "docx") return handleDocx(filePath);
   if (["odt", "ods", "ott", "odp"].includes(ext)) return handleOfficeBinary(filePath);
+  if (["sqlite", "db", "sqlite3", "db3"].includes(ext)) return handleSqlite(filePath);
+  if (ext === "parquet") return handleParquet(filePath);
   if (ext === "csv" || ext === "tsv") return handleCsv(filePath, content, effectiveLength);
   if (ext === "vtt" || ext === "srt") return handleTranscript(filePath, content, effectiveLength);
+  if (ext === "json") return handleJson(filePath, content, effectiveLength);
+  if (["yaml", "yml"].includes(ext)) return handleYaml(filePath, content, effectiveLength);
+  if (ext === "jsonl") return handleJsonl(filePath, content, effectiveLength);
   return handleGenericLarge(filePath, effectiveLength);
 }
 
 // src/doc_compact.ts
 init_define_import_meta_env();
-import * as fs19 from "fs";
-import * as path16 from "path";
+import * as fs17 from "fs";
+import * as path14 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(fs17.readFileSync(filePath));
   } catch {
     return "";
   }
 }
 function _compactSlug(absPathStr) {
   const h = fingerprintContent(foldPath(absPathStr)).slice(0, 12);
-  const ext = path16.extname(absPathStr);
-  const stem = path16.basename(absPathStr, ext);
+  const ext = path14.extname(absPathStr);
+  const stem = path14.basename(absPathStr, ext);
   const safeStem = sanitizeIdForFilename(stem, 32);
   return `${h}_${safeStem}`;
 }
 function compactPathFor(sourcePath) {
   const abs = resolveIndexPath(sourcePath);
-  return path16.join(dataDir(), compactSubdir, `${_compactSlug(abs)}.md`);
+  return path14.join(dataDir(), compactSubdir, `${_compactSlug(abs)}.md`);
 }
 function readCompactHeader(compactPath) {
   try {
-    const text = fs19.readFileSync(compactPath, "utf-8");
+    const text = fs17.readFileSync(compactPath, "utf-8");
     const firstLine = text.split("\n")[0] || "";
     const m = firstLine.match(headerRegex);
     if (!m || !m[1] || !m[2]) return null;
@@ -16487,8 +16491,8 @@ function isCompactFresh(compactPath, sourcePath) {
 }
 function markCompactStale(compactPath) {
   try {
-    if (!fs19.existsSync(compactPath)) return false;
-    const text = fs19.readFileSync(compactPath, "utf-8");
+    if (!fs17.existsSync(compactPath)) return false;
+    const text = fs17.readFileSync(compactPath, "utf-8");
     const lines2 = text.split("\n");
     if (!lines2[0]) return false;
     const m = lines2[0].match(headerRegex);
@@ -16503,7 +16507,7 @@ function markCompactStale(compactPath) {
 }
 function readCompactBody(compactPath) {
   try {
-    const text = fs19.readFileSync(compactPath, "utf-8");
+    const text = fs17.readFileSync(compactPath, "utf-8");
     const lines2 = text.split("\n");
     if (lines2.length < 2) return null;
     const body = lines2.slice(1).join("\n").trimStart();
@@ -16513,14 +16517,14 @@ function readCompactBody(compactPath) {
   }
 }
 function writeCompact(compactPath, sourcePath, compactBody, sourceRel) {
-  const srcPath = path16.resolve(sourcePath);
+  const srcPath = path14.resolve(sourcePath);
   const sha = sourceHash(srcPath);
-  const displayRel = sourceRel || path16.basename(srcPath);
+  const displayRel = sourceRel || path14.basename(srcPath);
   const header = `${headerPrefix}${sha} source:${displayRel} -->
 `;
   const fullText = header + compactBody.trimStart();
-  const dir = path16.dirname(compactPath);
-  if (!fs19.existsSync(dir)) {
+  const dir = path14.dirname(compactPath);
+  if (!fs17.existsSync(dir)) {
     ensureDirSync(dir);
   }
   atomicWriteText(compactPath, fullText);
@@ -16644,7 +16648,7 @@ function extractDocCompact(body, heading) {
 }
 function compactDoc(filePath, heading) {
   try {
-    const body = fs19.readFileSync(filePath, "utf-8");
+    const body = fs17.readFileSync(filePath, "utf-8");
     const compact = extractDocCompact(body, heading);
     return compact || null;
   } catch {
@@ -16655,20 +16659,20 @@ function compactDoc(filePath, heading) {
 // src/evidence_cache.ts
 init_define_import_meta_env();
 import crypto from "node:crypto";
-import fs20 from "node:fs";
-import path17 from "node:path";
+import fs18 from "node:fs";
+import path15 from "node:path";
 var MAX_ENTRIES = 500;
 var MAX_TEXT_BYTES = 128 * 1024;
 var CACHE_FILE = "workspace-evidence.json";
 function cachePath() {
-  return path17.join(dataDir(), CACHE_FILE);
+  return path15.join(dataDir(), CACHE_FILE);
 }
 function hash(text) {
   return crypto.createHash("sha256").update(text).digest("hex");
 }
 function load2() {
   try {
-    const parsed = JSON.parse(fs20.readFileSync(cachePath(), "utf8"));
+    const parsed = JSON.parse(fs18.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")
@@ -16680,7 +16684,7 @@ function load2() {
 function save(entries) {
   try {
     ensureDirSync(dataDir());
-    fs20.writeFileSync(cachePath(), JSON.stringify(entries.slice(0, MAX_ENTRIES)), "utf8");
+    fs18.writeFileSync(cachePath(), JSON.stringify(entries.slice(0, MAX_ENTRIES)), "utf8");
   } catch {
   }
 }
@@ -16771,7 +16775,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(fs18.readFileSync(entry.source, "utf8")) !== entry.contentHash;
     } catch {
       return true;
     }
@@ -16783,8 +16787,8 @@ ${changed.map((entry) => `- ${displaySafePath(entry.source)} (use a fresh surgic
 
 // src/notebook_compact.ts
 init_define_import_meta_env();
-import * as fs21 from "node:fs";
-import * as path18 from "node:path";
+import * as fs19 from "node:fs";
+import * as path16 from "node:path";
 var NB_STRIP_MIN_SAVINGS = 4096;
 function stripNotebook(nbDict) {
   const cells = [];
@@ -16804,23 +16808,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 = path18.join(cacheRoot, "nb_strip");
+  const nbStripDir = path16.join(cacheRoot, "nb_strip");
   let removed = 0;
   try {
-    if (!fs21.existsSync(nbStripDir)) return 0;
+    if (!fs19.existsSync(nbStripDir)) return 0;
     const cutoff = Date.now() - maxAgeMs;
     const kept = [];
-    for (const entry of fs21.readdirSync(nbStripDir)) {
-      const dir = path18.join(nbStripDir, entry);
+    for (const entry of fs19.readdirSync(nbStripDir)) {
+      const dir = path16.join(nbStripDir, entry);
       let mtime;
       try {
-        mtime = fs21.statSync(dir).mtimeMs;
+        mtime = fs19.statSync(dir).mtimeMs;
       } catch {
         continue;
       }
       if (mtime < cutoff) {
         try {
-          fs21.rmSync(dir, { recursive: true, force: true });
+          fs19.rmSync(dir, { recursive: true, force: true });
           removed++;
         } catch {
           continue;
@@ -16833,7 +16837,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 });
+          fs19.rmSync(dir, { recursive: true, force: true });
           removed++;
         } catch {
           continue;
@@ -16847,9 +16851,9 @@ function pruneSidecars(cacheRoot, maxCount = SIDECAR_DEFAULT_MAX_COUNT, maxAgeMs
 }
 function getOrCreateSidecar(rawBytes, cacheRoot, opts = {}) {
   const sha = fingerprintContent(rawBytes);
-  const sidecarDir = path18.join(cacheRoot, "nb_strip", sha);
-  const sidecarPath = path18.join(sidecarDir, "stripped.ipynb");
-  if (fs21.existsSync(sidecarPath)) {
+  const sidecarDir = path16.join(cacheRoot, "nb_strip", sha);
+  const sidecarPath = path16.join(sidecarDir, "stripped.ipynb");
+  if (fs19.existsSync(sidecarPath)) {
     return [sidecarPath, false];
   }
   let nb;
@@ -16866,7 +16870,7 @@ function getOrCreateSidecar(rawBytes, cacheRoot, opts = {}) {
   try {
     ensureDirSync(sidecarDir);
   } catch (err) {
-    if (!fs21.existsSync(sidecarDir)) {
+    if (!fs19.existsSync(sidecarDir)) {
       throw err;
     }
   }
@@ -16954,10 +16958,10 @@ var COMMENT_SYNTAX = new Map([
   ...["py", "rb", "sh", "bash", "zsh", "pl", "r"].map((ext) => [ext, HASH]),
   ...["sql", "lua", "hs"].map((ext) => [ext, DOUBLE_DASH])
 ]);
-function commentSyntaxFor(path24) {
-  const dot = path24.lastIndexOf(".");
+function commentSyntaxFor(path22) {
+  const dot = path22.lastIndexOf(".");
   if (dot < 0) return null;
-  return COMMENT_SYNTAX.get(path24.slice(dot + 1).toLowerCase()) ?? null;
+  return COMMENT_SYNTAX.get(path22.slice(dot + 1).toLowerCase()) ?? null;
 }
 function planCommentFolds(rows, syntax, commentKeep, commentMinBlock, occupied) {
   if (syntax === null || rows.length === 0 || commentKeep < 1 || commentMinBlock < 1) return [];
@@ -17066,8 +17070,8 @@ function planProseFolds(rows, claimed) {
   }
   return folds;
 }
-function foldDetail(path24, folds, maxLen = MAX_FOLD_DETAIL) {
-  const head = `${path24}::`;
+function foldDetail(path22, folds, maxLen = MAX_FOLD_DETAIL) {
+  const head = `${path22}::`;
   const ids = folds.map((f) => f.kind === "body" ? f.name : `#${f.firstLine}-${f.lastLine}`);
   const budget = maxLen - head.length - FOLD_DETAIL_SUFFIX_BUDGET;
   const kept = [];
@@ -17085,7 +17089,7 @@ function foldDetail(path24, folds, maxLen = MAX_FOLD_DETAIL) {
 
 // src/fold_delivery.ts
 init_define_import_meta_env();
-import { readFileSync as readFileSync16, statSync as statSync14 } from "node:fs";
+import { readFileSync as readFileSync14, statSync as statSync13 } from "node:fs";
 var BODY_FOLD_KEEP_LINES = 8;
 var BODY_FOLD_MIN_SPAN = 20;
 var COMMENT_FOLD_KEEP_LINES = 2;
@@ -17117,10 +17121,10 @@ function commentFoldNotice(firstLine, lastLine, shownPath) {
 var FOLD_SPAN_PARSE_MAX_BYTES = 4e5;
 function parseFoldSpansFromDisk(normalizedPath, rows) {
   try {
-    if (statSync14(normalizedPath).size > FOLD_SPAN_PARSE_MAX_BYTES) return [];
+    if (statSync13(normalizedPath).size > FOLD_SPAN_PARSE_MAX_BYTES) return [];
     const language = detectLanguage(normalizedPath);
     if (!isTreeSitterAvailable(language)) return [];
-    const fileText = readFileSync16(normalizedPath, "utf-8");
+    const fileText = readFileSync14(normalizedPath, "utf-8");
     const diskLines = fileText.split("\n");
     for (const row of rows) {
       const disk = diskLines[row.no - 1];
@@ -17136,7 +17140,7 @@ function parseFoldSpansFromDisk(normalizedPath, rows) {
 function resolveFoldSpans(normalizedPath, hasCommentSyntax, rows) {
   try {
     const entry = getFileEntry(normalizedPath);
-    if (entry !== null && entry.sha !== "" && entry.sha === fingerprintFile(normalizedPath) && entry.parserSha === PARSER_FINGERPRINT) {
+    if (entry !== null && entry.sha !== "" && !isVirtualIndexedPath(normalizedPath) && entry.sha === fingerprintFile(normalizedPath) && entry.parserSha === PARSER_FINGERPRINT) {
       return querySymbols({ filePath: normalizedPath, limit: BODY_FOLD_SYMBOL_LIMIT });
     }
     if (hasCommentSyntax) enqueueDirtyPathSafe(normalizedPath);
@@ -17351,8 +17355,8 @@ function isNodeModulesPath(p) {
   return check.includes("/node_modules/") || check.includes("\\node_modules\\");
 }
 function relPathWithinRoot(root, target) {
-  const rel = path19.relative(root, target).replace(/\\/g, "/");
-  if (rel.startsWith("..") || path19.isAbsolute(rel)) return null;
+  const rel = path17.relative(root, target).replace(/\\/g, "/");
+  if (rel.startsWith("..") || path17.isAbsolute(rel)) return null;
   return rel;
 }
 function _isDocFile(filePath) {
@@ -17436,7 +17440,7 @@ function scanRequestedSlice(absPath, offset, limit) {
   const windowEnd = offset + limit;
   let fd;
   try {
-    fd = fs22.openSync(absPath, "r");
+    fd = fs20.openSync(absPath, "r");
   } catch {
     return null;
   }
@@ -17450,7 +17454,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 = fs20.readSync(fd, buf, 0, buf.length, null);
       if (bytesRead === 0) {
         return {
           bytes: sliceBytes,
@@ -17469,7 +17473,7 @@ function scanRequestedSlice(absPath, offset, limit) {
     }
   } finally {
     try {
-      fs22.closeSync(fd);
+      fs20.closeSync(fd);
     } catch {
     }
   }
@@ -17500,11 +17504,11 @@ function isDiffableSource(basename10) {
 function isSourceExtension(basename10) {
   return languageHasFlag(detectLanguage(basename10), "sourceHints");
 }
-var BINARY_FILE_TYPE_EXTS = /* @__PURE__ */ new Set(["pdf", "docx", "xlsx", "pptx", "odt", "ods", "ott", "odp"]);
-var TEXT_FILE_TYPE_EXTS = /* @__PURE__ */ new Set(["html", "htm", "xhtml", "txt", "log", "out", "err", "trace", "csv", "tsv", "vtt", "srt", "svg", "xml"]);
+var BINARY_FILE_TYPE_EXTS = /* @__PURE__ */ new Set(["pdf", "docx", "xlsx", "pptx", "odt", "ods", "ott", "odp", "sqlite", "db", "sqlite3", "db3", "parquet"]);
+var TEXT_FILE_TYPE_EXTS = /* @__PURE__ */ new Set(["html", "htm", "xhtml", "txt", "log", "out", "err", "trace", "csv", "tsv", "vtt", "srt", "svg", "xml", "json", "yaml", "yml", "jsonl"]);
 var DISPATCHED_FILE_TYPE_EXTS = /* @__PURE__ */ new Set([...BINARY_FILE_TYPE_EXTS, ...TEXT_FILE_TYPE_EXTS]);
 function isDispatchedFileType(basename10) {
-  return DISPATCHED_FILE_TYPE_EXTS.has(path19.extname(basename10).slice(1).toLowerCase());
+  return DISPATCHED_FILE_TYPE_EXTS.has(path17.extname(basename10).slice(1).toLowerCase());
 }
 function surgicalHint(filePath, basename10, lineCount) {
   if (lineCount < loadConfig().hints.min_file_lines_for_hint) return "";
@@ -17567,7 +17571,7 @@ function loadSnapshotDiff(sessionId, normalized, basename10) {
   try {
     const sz = statSize(normalized);
     if (sz === null || sz > 256 * 1024) return { kind: "none" };
-    const currentContent = fs22.readFileSync(normalized, "utf8");
+    const currentContent = fs20.readFileSync(normalized, "utf8");
     const TRUNC_MARKER = "\n<snapshot truncated at ";
     const oldRaw = oldSnap.toString("utf8");
     const truncIdx = oldRaw.indexOf(TRUNC_MARKER);
@@ -17654,7 +17658,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 = fs20.readFileSync(normalized, "utf8");
       const evidence = findVerifiedFileEvidence(project.root, normalized, current);
       if (evidence !== null) {
         recordStat("evidence_cache_hit", 0);
@@ -17665,7 +17669,7 @@ function preReadHandlerInner(event) {
     } catch {
     }
   }
-  const basename10 = displaySafePath(path19.basename(normalized));
+  const basename10 = displaySafePath(path17.basename(normalized));
   if (isLockFile(basename10)) {
     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.'
@@ -17704,7 +17708,7 @@ function preReadHandlerInner(event) {
   const skillName = detectSkillFile(normalized);
   if (skillName && basename10 === "SKILL.md") {
     try {
-      const body = fs22.readFileSync(normalized, "utf-8");
+      const body = fs20.readFileSync(normalized, "utf-8");
       const bodySha = contentHash(body);
       const compact = getCompactAnySessionSync(skillName);
       const stale = isCompactStale(compact, skillName, bodySha);
@@ -17736,9 +17740,9 @@ function preReadHandlerInner(event) {
   const isNotebook = /\.ipynb$/i.test(basename10);
   if (event.toolName !== "Grep" && isNotebook) {
     try {
-      const rawBytes = fs22.readFileSync(normalized);
+      const rawBytes = fs20.readFileSync(normalized);
       const [sidecarPath] = getOrCreateSidecar(rawBytes, dataDir());
-      const sidecarContent = fs22.readFileSync(sidecarPath, "utf-8");
+      const sidecarContent = fs20.readFileSync(sidecarPath, "utf-8");
       const savedBytes = rawBytes.length - sidecarContent.length;
       if (savedBytes >= NB_STRIP_MIN_SAVINGS) {
         recordActualRead(event, normalized);
@@ -17759,7 +17763,7 @@ function preReadHandlerInner(event) {
       const sz = statSize(normalized);
       if (sz !== null && sz >= MARKDOWN_SIZE_THRESHOLD) {
         markdownSize = sz;
-        fileContent = fs22.readFileSync(normalized, "utf8");
+        fileContent = fs20.readFileSync(normalized, "utf8");
       }
     } catch {
     }
@@ -18043,7 +18047,7 @@ function preReadHandlerInner(event) {
       "Note: " + shown + " is large (" + kb + "KB). " + hint + contextPressureAdvisorySuffix()
     );
   }
-  const fileTypeExt = path19.extname(normalized).slice(1).toLowerCase();
+  const fileTypeExt = path17.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)) {
@@ -18052,7 +18056,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 = fs20.readFileSync(normalized, "utf8");
       } catch {
       }
     }
@@ -18084,7 +18088,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(fs20.readFileSync(normalized, "utf8"));
     }
   } catch {
   }
@@ -18107,13 +18111,13 @@ function postReadHandlerInner(event, suppressStructuralHint) {
   if (isTruncatedReadDelivery(event, respText)) {
     markFileTruncated(normalized);
   }
-  const postBasename = path19.basename(normalized);
+  const postBasename = path17.basename(normalized);
   const diffSourcesEnabled = loadConfig().hints.serve_diff_on_reread;
   if (/\.(md|mdx|markdown|rst|txt)$/i.test(postBasename) || isSessionArtifactFile(normalized) || diffSourcesEnabled && isDiffableSource(postBasename)) {
     try {
       const sz = statSize(normalized);
       if (sz !== null && sz <= 256 * 1024) {
-        const content = fs22.readFileSync(normalized);
+        const content = fs20.readFileSync(normalized);
         store(sessionStateKey(event), normalized, content);
       }
     } catch {
@@ -18123,7 +18127,7 @@ function postReadHandlerInner(event, suppressStructuralHint) {
     try {
       const cwd = getCwd(event) ?? process.cwd();
       const project = findProject(cwd) ?? makeProjectAt(cwd);
-      const source = decodeSource(fs22.readFileSync(normalized));
+      const source = decodeSource(fs20.readFileSync(normalized));
       recordEvidence({ projectRoot: project.root, source: normalized, representation: "file", text: source });
     } catch {
     }
@@ -18154,7 +18158,7 @@ function postReadHandlerInner(event, suppressStructuralHint) {
     try {
       const sz = statSize(normalized);
       if (sz !== null && sz <= SLICE_ESTIMATE_SCAN_CAP_BYTES) {
-        const lineCount = countTextLines(fs22.readFileSync(normalized, "utf8"));
+        const lineCount = countTextLines(fs20.readFileSync(normalized, "utf8"));
         const minLines = loadConfig().post_read_code_compress.min_lines;
         if (lineCount >= minLines && meetsSavingsFloor(sz) && !suppressStructuralHint) {
           recordStat("session_hint", 0, 0);
@@ -18171,7 +18175,7 @@ function postReadHandlerInner(event, suppressStructuralHint) {
 function readWindowFromDisk(event, normalized) {
   const size = statSize(normalized);
   if (size === null || size > SLICE_ESTIMATE_SCAN_CAP_BYTES) return null;
-  const text = decodeSource(fs22.readFileSync(normalized));
+  const text = decodeSource(fs20.readFileSync(normalized));
   const window2 = readRequestedSliceWindow(event);
   const start = window2.offset !== void 0 && window2.offset >= 1 ? window2.offset : 1;
   const limit = window2.limit;
@@ -18372,9 +18376,9 @@ registerHook("post_tool_use", postReadHandler, { toolName: "Read" });
 
 // src/cli_context_stats.ts
 init_define_import_meta_env();
-import * as fs24 from "node:fs";
+import * as fs22 from "node:fs";
 import * as os2 from "node:os";
-import * as path21 from "node:path";
+import * as path19 from "node:path";
 
 // src/confirm_apply.ts
 init_define_import_meta_env();
@@ -18430,8 +18434,8 @@ ${diff}
 
 // src/memory_prune.ts
 init_define_import_meta_env();
-import * as fs23 from "node:fs";
-import * as path20 from "node:path";
+import * as fs21 from "node:fs";
+import * as path18 from "node:path";
 var ENTRY_RE = /^\s*-\s*\[(?<title>[^\]]+)\]\((?<target>[^)]+?\.md)\)/;
 var URL_SCHEME_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
 function parseIndex(text) {
@@ -18476,10 +18480,10 @@ function pruneIndex(memoryDir, opts) {
     changed: false,
     tokensSaved: 0
   };
-  const memoryMd = path20.join(memoryDir, "MEMORY.md");
+  const memoryMd = path18.join(memoryDir, "MEMORY.md");
   let text;
   try {
-    text = fs23.readFileSync(memoryMd, "utf-8");
+    text = fs21.readFileSync(memoryMd, "utf-8");
   } catch {
     return result;
   }
@@ -18490,7 +18494,7 @@ function pruneIndex(memoryDir, opts) {
   const dups = [];
   for (const entry of entries) {
     const isUrl = URL_SCHEME_RE.test(entry.target);
-    const targetExists = isUrl ? true : path20.isAbsolute(entry.target) ? fs23.existsSync(entry.target) : fs23.existsSync(path20.join(memoryDir, entry.target));
+    const targetExists = isUrl ? true : path18.isAbsolute(entry.target) ? fs21.existsSync(entry.target) : fs21.existsSync(path18.join(memoryDir, entry.target));
     const foldedTarget = foldPath(entry.target);
     if (!targetExists) {
       dead.push(entry);
@@ -18544,7 +18548,7 @@ function jaccard(a, b) {
 function siblingSnippet(filePath) {
   let text;
   try {
-    text = fs23.readFileSync(filePath, { encoding: "utf-8" });
+    text = fs21.readFileSync(filePath, { encoding: "utf-8" });
   } catch {
     return "";
   }
@@ -18634,7 +18638,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) => path20.join(memoryDir, name)).sort();
+  const siblings = fs21.readdirSync(memoryDir).filter((name) => name.toLowerCase().endsWith(".md") && name.toLowerCase() !== "memory.md").map((name) => path18.join(memoryDir, name)).sort();
   if (siblings.length < 2) {
     return [];
   }
@@ -18658,7 +18662,7 @@ function auditClaudeMd(files) {
   for (const filePath of files) {
     let text;
     try {
-      text = fs23.readFileSync(filePath, { encoding: "utf-8" });
+      text = fs21.readFileSync(filePath, { encoding: "utf-8" });
     } catch {
       continue;
     }
@@ -18718,7 +18722,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) => path20.basename(p));
+        const others = Array.from(filesSet).filter((p) => p !== report.path).map((p) => path18.basename(p));
         if (others.length > 0) {
           if (stripped.length > 60) {
             overlaps.push(
@@ -18738,7 +18742,7 @@ function auditClaudeMd(files) {
 // src/cli_context_stats.ts
 function tok(filePath) {
   try {
-    const size = fs24.statSync(filePath).size;
+    const size = fs22.statSync(filePath).size;
     return Math.floor(size / 4);
   } catch {
     return 0;
@@ -18747,42 +18751,42 @@ function tok(filePath) {
 function findClaudeMdFiles(projectRoot, homeDir = os2.homedir()) {
   const found = [];
   const seen = /* @__PURE__ */ new Set();
-  let current = path21.resolve(projectRoot);
+  let current = path19.resolve(projectRoot);
   while (true) {
-    const candidate = path21.join(current, "CLAUDE.md");
-    if (!seen.has(candidate) && fs24.existsSync(candidate)) {
+    const candidate = path19.join(current, "CLAUDE.md");
+    if (!seen.has(candidate) && fs22.existsSync(candidate)) {
       found.push(candidate);
       seen.add(candidate);
     }
-    const parent = path21.dirname(current);
+    const parent = path19.dirname(current);
     if (parent === current) break;
     current = parent;
   }
-  const globalMd = path21.join(homeDir, ".claude", "CLAUDE.md");
-  if (!seen.has(globalMd) && fs24.existsSync(globalMd)) {
+  const globalMd = path19.join(homeDir, ".claude", "CLAUDE.md");
+  if (!seen.has(globalMd) && fs22.existsSync(globalMd)) {
     found.push(globalMd);
   }
   return found;
 }
 function findMemoryMd(projectRoot, homeDir = os2.homedir(), alternateRoots = []) {
   try {
-    const projectsDir = path21.join(homeDir, ".claude", "projects");
-    if (!fs24.existsSync(projectsDir)) return null;
-    const rootStr = path21.resolve(projectRoot);
+    const projectsDir = path19.join(homeDir, ".claude", "projects");
+    if (!fs22.existsSync(projectsDir)) return null;
+    const rootStr = path19.resolve(projectRoot);
     const candidateRoots = [rootStr];
     try {
-      const realRoot = fs24.realpathSync.native(rootStr);
+      const realRoot = fs22.realpathSync.native(rootStr);
       if (realRoot !== rootStr) candidateRoots.push(realRoot);
     } catch {
     }
     for (const alternate of alternateRoots) {
-      const resolved = path21.resolve(alternate);
+      const resolved = path19.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 = path21.join(projectsDir, expectedSlug, "memory", "MEMORY.md");
-      if (fs24.existsSync(candidate)) return candidate;
+      const candidate = path19.join(projectsDir, expectedSlug, "memory", "MEMORY.md");
+      if (fs22.existsSync(candidate)) return candidate;
     }
     return null;
   } catch {
@@ -18796,10 +18800,10 @@ function buildStats(projectRoot, homeDir = os2.homedir(), alternateRoots = []) {
   for (const p of claudeMds) {
     const t = tok(p);
     claudeMdTotal += t;
-    const parentDir = path21.basename(path21.dirname(p));
+    const parentDir = path19.basename(path19.dirname(p));
     const label = parentDir === ".claude" ? "~/.claude/CLAUDE.md" : (() => {
       try {
-        return path21.relative(projectRoot, p);
+        return path19.relative(projectRoot, p);
       } catch {
         return p;
       }
@@ -18863,11 +18867,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(path21.dirname(memPath), { dryRun: true });
+      const pruneResult = pruneIndex(path19.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 = fs22.readFileSync(memPath, "utf-8");
         const applyResult = await confirmAndApply(
           [{ path: memPath, before, after: pruneResult.after, label: "MEMORY.md" }],
           opts.yes === true ? { yes: true } : {}
@@ -18895,8 +18899,8 @@ async function runContextStats(opts = {}) {
 
 // src/baseline.ts
 init_define_import_meta_env();
-import * as fs25 from "node:fs";
-import * as path22 from "node:path";
+import * as fs23 from "node:fs";
+import * as path20 from "node:path";
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -18934,12 +18938,12 @@ function walkProject(rootDir, opts = {}) {
     if (dir === void 0) break;
     let entries;
     try {
-      entries = fs25.readdirSync(dir, { withFileTypes: true });
+      entries = fs23.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const full = path22.join(dir, entry.name);
+      const full = path20.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name) || extraSkipDirs.includes(entry.name)) continue;
         if (entry.name.startsWith(".") && entry.name !== ".") {
@@ -19021,7 +19025,7 @@ function fetchTopSymbols(limit, dbPath, rootDir) {
   }
 }
 function buildProjectMap(rootDir = process.cwd(), opts = {}) {
-  const root = path22.resolve(rootDir);
+  const root = path20.resolve(rootDir);
   const config = loadConfig();
   const { files, languages, truncated } = walkProject(root, { excludeTests: config.repomap.exclude_tests });
   const compact = opts.compact === true || files.length > config.repomap.compact_file_threshold;
@@ -19030,12 +19034,12 @@ function buildProjectMap(rootDir = process.cwd(), opts = {}) {
   const recentFiles = files.map((f) => {
     let mtime;
     try {
-      mtime = fs25.statSync(f).mtimeMs;
+      mtime = fs23.statSync(f).mtimeMs;
     } catch {
       mtime = 0;
     }
     return { f, mtime };
-  }).sort((a, b) => b.mtime - a.mtime).slice(0, compact ? 5 : 15).map((x) => path22.relative(root, x.f));
+  }).sort((a, b) => b.mtime - a.mtime).slice(0, compact ? 5 : 15).map((x) => path20.relative(root, x.f));
   return {
     rootDir: root,
     fileCount: files.length,
@@ -19048,7 +19052,7 @@ function buildProjectMap(rootDir = process.cwd(), opts = {}) {
 }
 function formatProjectMap(map, compact = false) {
   const lines2 = [];
-  const rel = path22.basename(map.rootDir);
+  const rel = path20.basename(map.rootDir);
   lines2.push(`# Project map: ${rel}`);
   lines2.push(map.fileCountTruncated === true ? `Files: at least ${map.fileCount} (walk stopped at the ${MAX_FILES_SCANNED}-file cap)` : `Files: ${map.fileCount}`);
   const langPairs = Object.entries(map.languages).sort((a, b) => b[1] - a[1]);
@@ -19059,7 +19063,7 @@ function formatProjectMap(map, compact = false) {
     lines2.push("");
     lines2.push("## Top symbols");
     for (const s of map.topSymbols) {
-      const loc = `${displaySafeText(toDisplayPath(map.rootDir, s.filePath))}:${s.lineStart}-${s.lineEnd}`;
+      const loc = formatSymbolLocation(displaySafeText(toDisplayPath(map.rootDir, s.filePath)), s.lineStart, s.lineEnd);
       lines2.push(`- ${displaySafeText(s.name)} (${displaySafeText(s.kind)}) \u2014 ${loc}`);
     }
   } else {
@@ -19077,7 +19081,7 @@ function formatProjectMap(map, compact = false) {
 }
 function mapLookupBytesSaved(map, emittedText) {
   const referencedFiles = /* @__PURE__ */ new Set([
-    ...map.recentFiles.map((f) => normalizePath(path22.resolve(map.rootDir, f))),
+    ...map.recentFiles.map((f) => normalizePath(path20.resolve(map.rootDir, f))),
     ...map.topSymbols.map((s) => normalizePath(s.filePath))
   ]);
   const listingText = Array.from(referencedFiles).sort().join("\n");
@@ -19092,14 +19096,14 @@ function findMemSuggestionCandidates(projectRoot) {
   const claudeMdFiles = findClaudeMdFiles(projectRoot);
   const candidateFiles = new Set(claudeMdFiles);
   for (const claudeMd of claudeMdFiles) {
-    const agentsMd = path22.join(path22.dirname(claudeMd), "AGENTS.md");
-    if (fs25.existsSync(agentsMd)) candidateFiles.add(agentsMd);
+    const agentsMd = path20.join(path20.dirname(claudeMd), "AGENTS.md");
+    if (fs23.existsSync(agentsMd)) candidateFiles.add(agentsMd);
   }
   const suggestions = [];
   for (const filePath of candidateFiles) {
     let text;
     try {
-      text = fs25.readFileSync(filePath, { encoding: "utf-8" });
+      text = fs23.readFileSync(filePath, { encoding: "utf-8" });
     } catch {
       continue;
     }
@@ -19128,7 +19132,7 @@ function formatMemSuggestions(projectRoot) {
   if (suggestions.length === 0) return "";
   const lines2 = ["", "## mem suggestions"];
   for (const s of suggestions) {
-    const basename10 = path22.basename(s.path);
+    const basename10 = path20.basename(s.path);
     lines2.push(
       "Consider: mem import --from-md " + s.path + "  # migrates " + s.count + " preference-shaped lines from " + basename10 + " as pending facts for review"
     );
@@ -19172,16 +19176,16 @@ function scanAndRecord(text) {
 
 // src/repomap.ts
 init_define_import_meta_env();
-import * as fs26 from "fs";
-import * as path23 from "path";
+import * as fs24 from "fs";
+import * as path21 from "path";
 function getTrackedFiles(cwd = process.cwd()) {
   try {
     let dir = cwd;
     let onlyFile = "";
     try {
-      if (fs26.statSync(cwd).isFile()) {
-        dir = path23.dirname(cwd);
-        onlyFile = path23.basename(cwd);
+      if (fs24.statSync(cwd).isFile()) {
+        dir = path21.dirname(cwd);
+        onlyFile = path21.basename(cwd);
       }
     } catch {
     }
@@ -19190,7 +19194,7 @@ function getTrackedFiles(cwd = process.cwd()) {
     if (result.exitCode !== 0 || !result.stdout) {
       return [];
     }
-    return result.stdout.split("\n").filter((line) => line.trim().length > 0).map((rel) => path23.join(dir, rel));
+    return result.stdout.split("\n").filter((line) => line.trim().length > 0).map((rel) => path21.join(dir, rel));
   } catch {
     return [];
   }
@@ -19430,6 +19434,8 @@ export {
   unzipBounded,
   docxOutline,
   docxText,
+  docxTables,
+  formatDocxTables,
   pptxOutline,
   pptxSlideText,
   pptxNotesText,
@@ -19444,6 +19450,8 @@ export {
   rangeSheet,
   formatXlsxRange,
   querySheet,
+  xlsxColumns,
+  formatXlsxColumns,
   isEmbeddableDocument,
   pathEqClause,
   detectWalkMode,
@@ -19509,13 +19517,6 @@ export {
   getFileServedOutputs,
   markFileTruncated,
   getSessionId,
-  DEFAULT_MAX_COUNT,
-  DEFAULT_MAX_AGE_MS,
-  isBlobStale,
-  storeBlob,
-  loadBlob,
-  listBlobs,
-  pruneBlobs,
   isBuildCommand,
   isTestRunnerCommand,
   getMonitoringRecallHint,
@@ -19574,10 +19575,6 @@ export {
   getSkillFilePath,
   installedSkillPath,
   pruneSkillOutputs,
-  ocrIntegrityFailed,
-  isOcrEngineAvailable,
-  ocrImage,
-  isTextHeavy,
   visionTokens,
   visionTokensSaved,
   visionTokensSavedByText,