token-goat 2.9.14 → 2.9.16

package/dist/{token-goat-chunk-T2IWWTHB.mjs → token-goat-chunk-DMQ32ZSR.mjs}

@@ -1,40 +1,28 @@
 import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
+import {
+  getDb
+} from "./token-goat-chunk-R3X5TCPB.mjs";
 import {
   getHarnessName,
   loadConfig
-} from "./token-goat-chunk-SAQ5PG4L.mjs";
+} from "./token-goat-chunk-H3DXI6VD.mjs";
 import {
   registerReset
 } from "./token-goat-chunk-EEIDFMEM.mjs";
 import {
-  _detectOpenQuote,
-  _lineClosesQuote,
-  isAblSource,
-  isLatexClassFile,
-  isMatlabSource,
-  isObjcHeader,
-  isObjcSource,
-  isPascalSource,
-  isPerlSource,
-  isPrologSource
-} from "./token-goat-chunk-POBYR64E.mjs";
-import {
-  SYMBOL_BODY_CHAR_CAP,
   VERSION,
   atomicWriteText,
   countNoun,
   dataDir,
   dataDirForHome,
-  displaySafeText,
   ensureDirSync,
-  foldCase,
-  foldPath,
-  safeJoin,
   sanitizeIdForFilename,
-  sleepSync,
   tokenGoatHome
-} from "./token-goat-chunk-AMYCQJX4.mjs";
+} from "./token-goat-chunk-3H6FQT62.mjs";
+import {
+  displaySafeText
+} from "./token-goat-chunk-ERTXEKB6.mjs";
 import {
   growsExponentially,
   hasNestedQuantifier
@@ -43,1087 +31,6 @@ import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
 
-// src/parser_types.ts
-init_define_import_meta_env();
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-// src/language_specs.ts
-init_define_import_meta_env();
-var CODE = { symbolBearing: true, sourceHints: true, grepSource: true, diffable: true };
-var DATA = { symbolBearing: false, sourceHints: false, grepSource: false, diffable: false };
-var LANGUAGE_SPECS = [
-  { id: "typescript", extraction: "tree-sitter", extensions: [".ts", ".tsx", ".mts", ".cts"], ...CODE, fence: "typescript", fenceByExtension: { ".tsx": "tsx" } },
-  { id: "javascript", extraction: "tree-sitter", extensions: [".js", ".jsx", ".mjs", ".cjs"], ...CODE, fence: "javascript", fenceByExtension: { ".jsx": "jsx" } },
-  // Bazel and Starlark (`.bzl`, `.star`, BUILD/WORKSPACE/MODULE.bazel) are a Python dialect: `def` and top-level calls such as `load(...)` parse with the Python grammar (https://github.com/bazelbuild/starlark/blob/master/spec.md).
-  { id: "python", extraction: "tree-sitter", extensions: [".py", ".pyi", ".bzl", ".star"], basenames: ["build.bazel", "workspace.bazel", "module.bazel"], exactBasenames: ["BUILD", "WORKSPACE"], ...CODE, fence: "python" },
-  { id: "go", extraction: "tree-sitter", extensions: [".go"], ...CODE, fence: "go" },
-  { id: "rust", extraction: "tree-sitter", extensions: [".rs"], ...CODE, fence: "rust" },
-  // Rake task files, Gemfile, Rakefile and the other extensionless Ruby DSL files are plain Ruby syntax.
-  { id: "ruby", extraction: "tree-sitter", extensions: [".rb", ".ruby", ".rake"], basenames: ["gemfile", "rakefile", "vagrantfile", "guardfile", "podfile", "capfile", "fastfile", "brewfile"], ...CODE, fence: "ruby" },
-  { id: "java", extraction: "tree-sitter", extensions: [".java"], ...CODE, fence: "java" },
-  // `.h` is C unless it declares an Objective-C `@interface` or `@protocol` (refineLanguageByContent); a C++ header parses with the C grammar.
-  { id: "c", extraction: "tree-sitter", extensions: [".c", ".h"], label: "C", ...CODE, fence: "c" },
-  { id: "cpp", extraction: "tree-sitter", extensions: [".cpp", ".cc", ".cxx", ".hpp", ".hxx"], label: "C++", ...CODE, fence: "cpp" },
-  // zsh, ksh and bats scripts share the POSIX `name() {` and `function name {` function forms the bash adapter reads.
-  { id: "bash", extraction: "regex", extensions: [".sh", ".bash", ".zsh", ".ksh", ".bats"], ...DATA, symbolBearing: true, fence: "bash" },
-  // MDX headings are plain ATX; `.rst` needs an underline heading parser this adapter lacks, so it stays unmapped.
-  { id: "markdown", extraction: "regex", extensions: [".md", ".markdown", ".mdx"], ...DATA, fence: "markdown" },
-  { id: "toml", extraction: "regex", extensions: [".toml"], basenames: ["cargo.toml", "pyproject.toml"], label: "TOML", ...DATA, diffable: true, fence: "toml" },
-  // JSON with comments (`.jsonc`) and Avro schemas (`.avsc`) read with the JSON adapter, which skips `//` and `/* */` comments.
-  { id: "json", extraction: "regex", extensions: [".json", ".jsonc", ".avsc"], basenames: ["package.json", "tsconfig.json"], label: "JSON", ...DATA, diffable: true, fence: "json" },
-  { id: "yaml", extraction: "regex", extensions: [".yaml", ".yml"], label: "YAML", ...DATA, diffable: true, fence: "yaml" },
-  { id: "css", extraction: "regex", extensions: [".css", ".scss", ".sass", ".less"], label: "CSS", ...DATA, grepSource: true, diffable: true, fence: "css", fenceByExtension: { ".scss": "scss", ".sass": "sass", ".less": "less" } },
-  { id: "dockerfile", extraction: "regex", extensions: [], basenames: ["dockerfile"], ...DATA, fence: "dockerfile" },
-  { id: "csharp", extraction: "regex", extensions: [".cs"], label: "C#", ...CODE, fence: "csharp" },
-  { id: "php", extraction: "regex", extensions: [".php"], label: "PHP", ...CODE, fence: "php" },
-  { id: "html", extraction: "regex", extensions: [".html", ".htm"], label: "HTML", ...DATA, fence: "html" },
-  { id: "liquid", extraction: "regex", extensions: [".liquid"], ...DATA, fence: "liquid" },
-  // Six template dialects, each masking its own delimiters out then handing off to the HTML
-  // extractor (src/languages/templates_idx.ts) -- markup formats, so DATA defaults like html/liquid.
-  { id: "jinja2", extraction: "regex", extensions: [".j2", ".jinja", ".jinja2"], label: "Jinja2", ...DATA, fence: "jinja" },
-  { id: "handlebars", extraction: "regex", extensions: [".hbs", ".handlebars"], label: "Handlebars", ...DATA, fence: "handlebars" },
-  { id: "erb", extraction: "regex", extensions: [".erb"], label: "ERB", ...DATA, fence: "erb" },
-  { id: "ejs", extraction: "regex", extensions: [".ejs"], label: "EJS", ...DATA, fence: "ejs" },
-  { id: "nunjucks", extraction: "regex", extensions: [".njk"], label: "Nunjucks", ...DATA, fence: "html" },
-  { id: "twig", extraction: "regex", extensions: [".twig"], label: "Twig", ...DATA, fence: "twig" },
-  { id: "kotlin", extraction: "regex", extensions: [".kt", ".kts"], ...CODE, fence: "kotlin" },
-  { id: "swift", extraction: "regex", extensions: [".swift"], ...CODE, fence: "swift" },
-  { id: "scala", extraction: "regex", extensions: [".scala", ".sc"], ...CODE, fence: "scala" },
-  { id: "lua", extraction: "regex", extensions: [".lua"], ...CODE, fence: "lua" },
-  { id: "elixir", extraction: "regex", extensions: [".ex", ".exs"], ...CODE, fence: "elixir" },
-  { id: "dart", extraction: "regex", extensions: [".dart"], ...CODE, fence: "dart" },
-  { id: "zig", extraction: "regex", extensions: [".zig"], ...CODE, fence: "zig" },
-  { id: "r", extraction: "regex", extensions: [".r"], ...CODE, fence: "r" },
-  { id: "graphql", extraction: "regex", extensions: [".graphql", ".gql"], label: "GraphQL", ...DATA, symbolBearing: true, fence: "graphql" },
-  // Oracle PL/SQL sources: package spec and body, standalone procedure/function, trigger, and object type spec and body.
-  { id: "sql", extraction: "regex", extensions: [".sql", ".pks", ".pkb", ".pls", ".plsql", ".pck", ".prc", ".fnc", ".trg", ".tps", ".tpb"], label: "SQL", ...DATA, symbolBearing: true, diffable: true, fence: "sql" },
-  { id: "ini", extraction: "regex", extensions: [".ini", ".cfg", ".conf"], label: "INI", ...DATA, fence: "ini" },
-  // `.mk` fragments (config.mk, rules.mk) share a bare Makefile's syntax.
-  { id: "makefile", extraction: "regex", extensions: [".mk"], basenames: ["makefile", "gnumakefile", "bsdmakefile"], ...DATA, fence: "makefile", basenameImportsExtension: ".mk" },
-  { id: "proto", extraction: "regex", extensions: [".proto"], label: "Protocol Buffers", ...DATA, symbolBearing: true, fence: "protobuf" },
-  { id: "terraform", extraction: "regex", extensions: [".tf", ".tfvars", ".hcl"], ...DATA, symbolBearing: true, fence: "hcl" },
-  // `.env` and `.env.<suffix>` are matched by parser_types.ts's DOTENV_VARIANT_RE before this table.
-  { id: "env_file", extraction: "regex", extensions: [".env"], basenames: [".envrc"], label: "env file", ...DATA },
-  { id: "powershell", extraction: "regex", extensions: [".ps1", ".psm1"], label: "PowerShell", ...CODE, fence: "powershell" },
-  // VB.NET, VB6/VBA standard modules, VBScript and VB6 forms. A VB6 class module shares `.cls` with Apex (and LaTeX) and is told apart by content in refineLanguageByContent.
-  { id: "vb", extraction: "regex", extensions: [".vb", ".bas", ".vbs", ".frm"], label: "Visual Basic", ...CODE, fence: "vb", fenceByExtension: { ".vb": "vbnet", ".vbs": "vbscript" } },
-  {
-    id: "cobol",
-    extraction: "own-result",
-    extensions: [".cbl", ".cob", ".cobol", ".cpy"],
-    label: "COBOL",
-    ...CODE,
-    fence: "cobol",
-    partialRefsReason: "PERFORM, GO TO and CALL 'literal' are recorded as references, but a paragraph also runs by falling through from the one above it and a program can be called through a data item holding its name, so `dead` skips COBOL"
-  },
-  // Natural object sources as NaturalONE and SYSOBJH export them. Maps (.nsm) and DDMs (.nsd) are layouts, not code, and stay unmapped.
-  {
-    id: "natural",
-    extraction: "own-result",
-    extensions: [".nsp", ".nsn", ".nss", ".nsa", ".nsl", ".nsg", ".nsc", ".nsh"],
-    label: "Natural",
-    ...CODE,
-    fence: "natural",
-    partialRefsReason: "PERFORM, CALLNAT 'literal' and FETCH 'literal' are recorded as references, but an object can also be called through a variable holding its name, so `dead` skips Natural"
-  },
-  { id: "abap", extraction: "regex", extensions: [".abap"], label: "ABAP", ...CODE, fence: "abap" },
-  { id: "sas", extraction: "regex", extensions: [".sas"], label: "SAS", ...CODE, fence: "sas" },
-  { id: "pli", extraction: "regex", extensions: [".pli", ".pl1"], label: "PL/I", ...CODE, fence: "pli" },
-  // `.rpg` stays unmapped: RPG II and RPG III sources use it, and their fixed layout predates the ILE RPG forms this adapter reads.
-  { id: "rpg", extraction: "regex", extensions: [".rpgle", ".sqlrpgle"], label: "RPG", ...CODE, fence: "rpgle" },
-  { id: "jcl", extraction: "regex", extensions: [".jcl"], label: "JCL", ...CODE, fence: "jcl" },
-  // `.mm` is always Objective-C++. A `.m` (MATLAB uses it too) is Objective-C only on an `#import`, `@interface`, `@implementation` or `@protocol` line, and a `.h` only on `@interface` or `@protocol`: refineLanguageByContent in parser_types.ts decides.
-  { id: "objc", extraction: "regex", extensions: [".mm"], label: "Objective-C", ...CODE, fence: "objectivec" },
-  // Gradle build scripts and Jenkinsfiles are Groovy.
-  { id: "groovy", extraction: "regex", extensions: [".groovy", ".gvy", ".gradle"], basenames: ["jenkinsfile"], label: "Groovy", ...CODE, fence: "groovy", basenameImportsExtension: ".groovy" },
-  // A Prolog `.pl` stays unknown (refineLanguageByContent), and a `.t` is Perl only on a Perl marker line.
-  { id: "perl", extraction: "regex", extensions: [".pl", ".pm"], label: "Perl", ...CODE, fence: "perl" },
-  { id: "solidity", extraction: "regex", extensions: [".sol"], label: "Solidity", ...CODE, fence: "solidity" },
-  { id: "thrift", extraction: "regex", extensions: [".thrift"], label: "Thrift", ...DATA, symbolBearing: true, fence: "thrift" },
-  { id: "glsl", extraction: "regex", extensions: [".glsl", ".vert", ".frag", ".comp", ".geom", ".tesc", ".tese"], label: "GLSL", ...CODE, fence: "glsl" },
-  // `.fx` stays unmapped: other languages use it too.
-  { id: "hlsl", extraction: "regex", extensions: [".hlsl", ".hlsli"], label: "HLSL", ...CODE, fence: "hlsl" },
-  { id: "wgsl", extraction: "regex", extensions: [".wgsl"], label: "WGSL", ...CODE, fence: "wgsl" },
-  { id: "metal", extraction: "regex", extensions: [".metal"], label: "Metal", ...CODE, fence: "metal" },
-  // `.f`, `.for` and `.f77` are read as fixed form unless code starts in column 1. `.fpp` stays unmapped: it is used for both forms.
-  { id: "fortran", extraction: "regex", extensions: [".f", ".for", ".f77", ".f90", ".f95", ".f03", ".f08"], label: "Fortran", ...CODE, fence: "fortran" },
-  // `.inc` stays unmapped (many languages use it), and a `.pp` (Puppet uses it too) is Pascal only on a unit, program or library header: refineLanguageByContent in parser_types.ts decides. Text-form `.dfm` forms list their components.
-  { id: "pascal", extraction: "regex", extensions: [".pas", ".dpr", ".dpk", ".lpr", ".dfm"], label: "Pascal", ...CODE, fence: "pascal" },
-  // MATLAB has no extension of its own: a `.m` that is not Objective-C is MATLAB only on a `function` or `classdef` header line, which refineLanguageByContent in parser_types.ts checks, so a Mathematica or Mercury `.m` stays unknown.
-  { id: "matlab", extraction: "regex", extensions: [], label: "MATLAB", ...CODE, fence: "matlab" },
-  { id: "cmake", extraction: "regex", extensions: [".cmake"], basenames: ["cmakelists.txt"], label: "CMake", ...CODE, fence: "cmake", basenameImportsExtension: ".cmake" },
-  // One adapter for the three assembly dialects that share these extensions: GNU as (`.s`, and `.S` through the lowercase lookup), NASM (`.asm`, `.nasm`) and IBM High Level Assembler (`.asm`), which the adapter tells apart by content. `.inc` stays unmapped: many languages use it.
-  { id: "asm", extraction: "regex", extensions: [".s", ".asm", ".nasm"], label: "Assembly", ...CODE, fence: "asm" },
-  { id: "batch", extraction: "regex", extensions: [".bat", ".cmd"], label: "Windows batch", ...CODE, fence: "batch" },
-  { id: "erlang", extraction: "regex", extensions: [".erl", ".hrl"], label: "Erlang", ...CODE, fence: "erlang" },
-  { id: "vhdl", extraction: "regex", extensions: [".vhd", ".vhdl"], label: "VHDL", ...CODE, fence: "vhdl" },
-  // Five Lisp-family dialects, each its own row: none shares an extractor (see common_lisp.ts's
-  // module doc for why their lexical rules stay separate rather than a single Lisp masker).
-  { id: "common_lisp", extraction: "regex", extensions: [".lisp", ".lsp", ".cl"], label: "Common Lisp", ...CODE, fence: "lisp" },
-  { id: "scheme", extraction: "regex", extensions: [".scm", ".ss"], label: "Scheme", ...CODE, fence: "scheme" },
-  { id: "racket", extraction: "regex", extensions: [".rkt", ".rktl"], label: "Racket", ...CODE, fence: "racket" },
-  { id: "clojure", extraction: "regex", extensions: [".clj", ".cljs", ".cljc"], label: "Clojure", ...CODE, fence: "clojure" },
-  { id: "emacs_lisp", extraction: "regex", extensions: [".el"], label: "Emacs Lisp", ...CODE, fence: "lisp" },
-  // `.lhs` (literate Haskell) is deliberately not claimed here -- see haskell.ts's module doc.
-  { id: "haskell", extraction: "regex", extensions: [".hs"], label: "Haskell", ...CODE, fence: "haskell" },
-  // `.mli` interface files share `.ml`'s lexical rules (comments, strings, quoted strings) and are read with the same extractor -- see ocaml.ts's module doc.
-  { id: "ocaml", extraction: "regex", extensions: [".ml", ".mli"], label: "OCaml", ...CODE, fence: "ocaml" },
-  // `.fsi` signature files and `.fsx` scripts share `.fs`'s lexical rules and are read with the same extractor -- see fsharp.ts's module doc.
-  { id: "fsharp", extraction: "regex", extensions: [".fs", ".fsi", ".fsx"], label: "F#", ...CODE, fence: "fsharp" },
-  { id: "nix", extraction: "regex", extensions: [".nix"], label: "Nix", ...CODE, fence: "nix" },
-  // OpenEdge ABL has no extension of its own: a `.p` or `.w` (Pascal and CWEB use them too) or a `.cls` (Apex, VB6, LaTeX) is ABL only when its head carries an ABL marker, which refineLanguageByContent in parser_types.ts checks. The path-only hooks see a `.p` or `.w` as unknown and a `.cls` as Apex.
-  { id: "abl", extraction: "regex", extensions: [], label: "OpenEdge ABL", ...CODE, fence: "abl" },
-  { id: "apex", extraction: "regex", extensions: [".cls", ".trigger"], label: "Apex", ...CODE, fence: "apex" },
-  // Matched by the `-meta.xml` suffix in detectLanguage, not by an extension.
-  { id: "salesforce_metadata", extraction: "regex", extensions: [], label: "Salesforce metadata", ...DATA, symbolBearing: true, sourceHints: true, grepSource: true, fence: "xml" },
-  { id: "salesforce_markup", extraction: "own-result", extensions: [".cmp", ".app", ".evt", ".intf", ".design", ".auradoc", ".tokens", ".page", ".component", ".email"], label: "Salesforce markup", ...DATA, symbolBearing: true, sourceHints: true, grepSource: true, fence: "xml" },
-  { id: "vue", extraction: "own-result", extensions: [".vue"], ...DATA, fence: "vue" },
-  { id: "svelte", extraction: "own-result", extensions: [".svelte"], ...DATA, fence: "svelte" },
-  { id: "astro", extraction: "own-result", extensions: [".astro"], ...DATA, fence: "astro" },
-  // Notebooks index through their code cells as Python, in parser.ts's ipynb branch.
-  { id: "ipynb", extraction: "own-result", extensions: [".ipynb"], label: "Jupyter notebook", ...DATA, fence: "json" }
-];
-var SPEC_BY_ID = new Map(LANGUAGE_SPECS.map((s) => [s.id, s]));
-function rows() {
-  return LANGUAGE_SPECS;
-}
-var EXTENSION_LANGUAGE = new Map(
-  LANGUAGE_SPECS.flatMap((s) => s.extensions.map((e) => [e, s.id]))
-);
-var FILENAME_LANGUAGE = new Map(
-  rows().flatMap((s) => (s.basenames ?? []).map((b) => [b, s.id]))
-);
-var EXACT_FILENAME_LANGUAGE = new Map(
-  rows().flatMap((s) => (s.exactBasenames ?? []).map((b) => [b, s.id]))
-);
-var TREE_SITTER_LANGUAGES = LANGUAGE_SPECS.filter((s) => s.extraction === "tree-sitter").map((s) => s.id);
-function languageHasFlag(language, flag) {
-  return SPEC_BY_ID.get(language)?.[flag] === true;
-}
-function languageLabel(language) {
-  if (language === "unknown") return "this file type";
-  return SPEC_BY_ID.get(language)?.label ?? language;
-}
-function fenceFor(language, ext) {
-  const spec = SPEC_BY_ID.get(language);
-  if (spec === void 0) return "";
-  return spec.fenceByExtension?.[ext] ?? spec.fence ?? "";
-}
-function basenameImportsExtension(language) {
-  return SPEC_BY_ID.get(language)?.basenameImportsExtension;
-}
-function partialRefsReason(language) {
-  return SPEC_BY_ID.get(language)?.partialRefsReason;
-}
-
-// src/parser_types.ts
-var DOTENV_VARIANT_RE = /^\.env(\..+)?$/;
-var VB6_HEADER_SCAN_LINES = 40;
-function isVb6ClassModule(content) {
-  if (content.includes("\0")) return false;
-  const lines = (content.charCodeAt(0) === 65279 ? content.slice(1) : content).split(/\r?\n/, VB6_HEADER_SCAN_LINES);
-  const first = lines.find((l) => l.trim() !== "");
-  if (first !== void 0 && /^VERSION\s+1\.0\s+CLASS\b/i.test(first.trim())) return true;
-  return lines.some((l) => /^Attribute\s+VB_Name\s*=\s*"/i.test(l.trim()));
-}
-function refineLanguageByContent(filePath, language, content) {
-  const sniff = CONTENT_SNIFFS.get(path.extname(filePath).toLowerCase());
-  if (sniff === void 0 || sniff.from !== language) return language;
-  return sniff.refine(content) ?? language;
-}
-var LANGUAGE_SNIFF_BYTES = 8192;
-function sniffHead(content) {
-  const head = content.slice(0, LANGUAGE_SNIFF_BYTES);
-  return Buffer.byteLength(head, "utf8") <= LANGUAGE_SNIFF_BYTES ? head : Buffer.from(head, "utf8").subarray(0, LANGUAGE_SNIFF_BYTES).toString("utf8");
-}
-var ablOrUnknown = (c) => isAblSource(c) ? "abl" : void 0;
-var clsRefine = (c) => {
-  if (isVb6ClassModule(c)) return "vb";
-  const abl = ablOrUnknown(c);
-  if (abl !== void 0) return abl;
-  if (isLatexClassFile(c)) return "unknown";
-  return void 0;
-};
-var CONTENT_SNIFFS = /* @__PURE__ */ new Map([
-  [".cls", { from: "apex", refine: clsRefine }],
-  [".p", { from: "unknown", refine: ablOrUnknown }],
-  [".w", { from: "unknown", refine: ablOrUnknown }],
-  [".m", { from: "unknown", refine: (c) => isObjcSource(sniffHead(c)) ? "objc" : isMatlabSource(sniffHead(c)) ? "matlab" : void 0 }],
-  [".pp", { from: "unknown", refine: (c) => isPascalSource(sniffHead(c)) ? "pascal" : void 0 }],
-  [".h", { from: "c", refine: (c) => isObjcHeader(sniffHead(c)) ? "objc" : void 0 }],
-  [".pl", { from: "perl", refine: (c) => isPrologSource(sniffHead(c)) ? "unknown" : void 0 }],
-  [".t", { from: "unknown", refine: (c) => isPerlSource(sniffHead(c)) ? "perl" : void 0 }]
-]);
-function needsContentSniff(filePath, language) {
-  return CONTENT_SNIFFS.get(path.extname(filePath).toLowerCase())?.from === language;
-}
-function detectLanguageOfFile(filePath) {
-  const language = detectLanguage(filePath);
-  if (!needsContentSniff(filePath, language)) return language;
-  try {
-    const fd = fs.openSync(filePath, "r");
-    try {
-      const buf = Buffer.alloc(LANGUAGE_SNIFF_BYTES);
-      const n = fs.readSync(fd, buf, 0, buf.length, 0);
-      return refineLanguageByContent(filePath, language, buf.subarray(0, n).toString("utf8"));
-    } finally {
-      fs.closeSync(fd);
-    }
-  } catch {
-    return language;
-  }
-}
-function detectLanguage(filePath) {
-  const exactBase = path.basename(filePath);
-  const base = exactBase.toLowerCase();
-  if (DOTENV_VARIANT_RE.test(base)) return "env_file";
-  const byName = EXACT_FILENAME_LANGUAGE.get(exactBase) ?? FILENAME_LANGUAGE.get(base);
-  if (byName !== void 0) return byName;
-  if (base.endsWith("-meta.xml")) {
-    return "salesforce_metadata";
-  }
-  const ext = path.extname(base).toLowerCase();
-  return EXTENSION_LANGUAGE.get(ext) ?? "unknown";
-}
-var UNSUPPORTED_LANGUAGE_EXTENSIONS = /* @__PURE__ */ new Map([
-  [".rpg", "RPG II or RPG III"],
-  [".nsm", "Natural map"],
-  [".nsd", "Natural DDM"]
-]);
-function nonTreeSitterLanguageCount() {
-  return LANGUAGE_SPECS.filter((s) => s.extraction !== "tree-sitter" && s.id !== "ipynb").length;
-}
-function unsupportedLanguageName(filePath) {
-  const ext = path.extname(filePath).toLowerCase();
-  return UNSUPPORTED_LANGUAGE_EXTENSIONS.get(ext);
-}
-
-// src/dotenv_redact.ts
-init_define_import_meta_env();
-var DOTENV_VALUE_PLACEHOLDER = "[REDACTED:dotenv_value]";
-var ASSIGNMENT_RE = /^(\s*(?:export\s+)?[A-Za-z_][\w.-]*\s*(?:\+?=|:(?!\/\/)))/;
-var SAFE_LINE_RE = /^\s*(?:[#;].*)?$/;
-function isDotenvPath(filePath) {
-  return detectLanguage(filePath) === "env_file";
-}
-function redactDotenvValues(text) {
-  const lines = text.split("\n");
-  const out = [];
-  let openQuote = null;
-  for (const raw of lines) {
-    const hasCr = raw.endsWith("\r");
-    const line = hasCr ? raw.slice(0, -1) : raw;
-    const eol = hasCr ? "\r" : "";
-    const emit = (s) => {
-      out.push(`${s}${eol}`);
-    };
-    if (openQuote !== null) {
-      if (_lineClosesQuote(line, openQuote)) openQuote = null;
-      emit(DOTENV_VALUE_PLACEHOLDER);
-      continue;
-    }
-    if (SAFE_LINE_RE.test(line)) {
-      emit(line);
-      continue;
-    }
-    const m = ASSIGNMENT_RE.exec(line);
-    if (m === null || m[1] === void 0) {
-      emit(DOTENV_VALUE_PLACEHOLDER);
-      continue;
-    }
-    const prefix = m[1];
-    openQuote = _detectOpenQuote(line.slice(prefix.length));
-    emit(`${prefix}${DOTENV_VALUE_PLACEHOLDER}`);
-  }
-  return out.join("\n");
-}
-function redactIfDotenv(filePath, text) {
-  return isDotenvPath(filePath) ? redactDotenvValues(text) : text;
-}
-
-// src/db.ts
-init_define_import_meta_env();
-import * as fs3 from "node:fs";
-import { createRequire as createRequire2 } from "node:module";
-import * as path2 from "node:path";
-
-// src/sqlite_driver.ts
-init_define_import_meta_env();
-import * as fs2 from "node:fs";
-import { createRequire } from "node:module";
-var _require = createRequire(import.meta.url);
-function suppressSqliteExperimentalWarning() {
-  const original = process.emit;
-  let armed = true;
-  const restore = () => {
-    if (!armed) return;
-    armed = false;
-    process.emit = original;
-  };
-  process.emit = function patched(name, ...rest) {
-    const data = rest[0];
-    if (armed && name === "warning" && data instanceof Error && data.name === "ExperimentalWarning" && /sqlite/i.test(data.message)) {
-      restore();
-      return false;
-    }
-    return original.call(this, name, ...rest);
-  };
-  setImmediate(restore);
-  return restore;
-}
-var restoreWarnings = suppressSqliteExperimentalWarning();
-var nodeSqlite;
-try {
-  nodeSqlite = _require("node:sqlite");
-} catch (e) {
-  restoreWarnings();
-  throw e;
-}
-var { DatabaseSync } = nodeSqlite;
-var SQLITE_PRIMARY_CODES = [
-  "SQLITE_OK",
-  "SQLITE_ERROR",
-  "SQLITE_INTERNAL",
-  "SQLITE_PERM",
-  "SQLITE_ABORT",
-  "SQLITE_BUSY",
-  "SQLITE_LOCKED",
-  "SQLITE_NOMEM",
-  "SQLITE_READONLY",
-  "SQLITE_INTERRUPT",
-  "SQLITE_IOERR",
-  "SQLITE_CORRUPT",
-  "SQLITE_NOTFOUND",
-  "SQLITE_FULL",
-  "SQLITE_CANTOPEN",
-  "SQLITE_PROTOCOL",
-  "SQLITE_EMPTY",
-  "SQLITE_SCHEMA",
-  "SQLITE_TOOBIG",
-  "SQLITE_CONSTRAINT",
-  "SQLITE_MISMATCH",
-  "SQLITE_MISUSE",
-  "SQLITE_NOLFS",
-  "SQLITE_AUTH",
-  "SQLITE_FORMAT",
-  "SQLITE_RANGE",
-  "SQLITE_NOTADB",
-  "SQLITE_NOTICE",
-  "SQLITE_WARNING"
-];
-var SQLITE_EXTENDED_SUFFIXES = {
-  SQLITE_OK: ["LOAD_PERMANENTLY", "SYMLINK"],
-  SQLITE_ERROR: ["MISSING_COLLSEQ", "RETRY", "SNAPSHOT"],
-  SQLITE_ABORT: [null, "ROLLBACK"],
-  SQLITE_BUSY: ["RECOVERY", "SNAPSHOT", "TIMEOUT"],
-  SQLITE_LOCKED: ["SHAREDCACHE", "VTAB"],
-  SQLITE_READONLY: ["RECOVERY", "CANTLOCK", "ROLLBACK", "DBMOVED", "CANTINIT", "DIRECTORY"],
-  SQLITE_IOERR: [
-    "READ",
-    "SHORT_READ",
-    "WRITE",
-    "FSYNC",
-    "DIR_FSYNC",
-    "TRUNCATE",
-    "FSTAT",
-    "UNLOCK",
-    "RDLOCK",
-    "DELETE",
-    "BLOCKED",
-    "NOMEM",
-    "ACCESS",
-    "CHECKRESERVEDLOCK",
-    "LOCK",
-    "CLOSE",
-    "DIR_CLOSE",
-    "SHMOPEN",
-    "SHMSIZE",
-    "SHMLOCK",
-    "SHMMAP",
-    "SEEK",
-    "DELETE_NOENT",
-    "MMAP",
-    "GETTEMPPATH",
-    "CONVPATH",
-    "VNODE",
-    "AUTH",
-    "BEGIN_ATOMIC",
-    "COMMIT_ATOMIC",
-    "ROLLBACK_ATOMIC",
-    "DATA",
-    "CORRUPTFS",
-    "IN_PAGE"
-  ],
-  SQLITE_CORRUPT: ["VTAB", "SEQUENCE", "INDEX"],
-  SQLITE_CANTOPEN: ["NOTEMPDIR", "ISDIR", "FULLPATH", "CONVPATH", "DIRTYWAL", "SYMLINK"],
-  SQLITE_CONSTRAINT: [
-    "CHECK",
-    "COMMITHOOK",
-    "FOREIGNKEY",
-    "FUNCTION",
-    "NOTNULL",
-    "PRIMARYKEY",
-    "TRIGGER",
-    "UNIQUE",
-    "VTAB",
-    "ROWID",
-    "PINNED",
-    "DATATYPE"
-  ],
-  SQLITE_AUTH: ["USER"],
-  SQLITE_NOTICE: ["RECOVER_WAL", "RECOVER_ROLLBACK", "RBU"],
-  SQLITE_WARNING: ["AUTOINDEX"]
-};
-function sqliteResultCodeName(errcode) {
-  if (!Number.isInteger(errcode) || errcode < 0) return "ERR_SQLITE_ERROR";
-  if (errcode === 100) return "SQLITE_ROW";
-  if (errcode === 101) return "SQLITE_DONE";
-  const primary = SQLITE_PRIMARY_CODES[errcode & 255];
-  if (primary === void 0) return "ERR_SQLITE_ERROR";
-  const subcode = errcode >> 8;
-  if (subcode === 0) return primary;
-  const suffix = SQLITE_EXTENDED_SUFFIXES[primary]?.[subcode - 1];
-  return suffix === void 0 || suffix === null ? primary : `${primary}_${suffix}`;
-}
-function attempt(fn) {
-  try {
-    return fn();
-  } catch (e) {
-    const err = e;
-    if (err.code === "ERR_SQLITE_ERROR" && typeof err.errcode === "number") {
-      err.code = sqliteResultCodeName(err.errcode);
-    }
-    throw e;
-  }
-}
-var Statement = class {
-  #stmt;
-  #pluck = false;
-  constructor(stmt) {
-    this.#stmt = stmt;
-  }
-  get source() {
-    return this.#stmt.sourceSQL;
-  }
-  /**
-   * better-sqlite3's `reader` flag: does this statement return rows?
-   *
-   * `node:sqlite` has no equivalent, so it is derived from the prepared statement's own column
-   * count -- SQLite gives a row-producing statement its result columns at prepare time and gives a
-   * non-producing one none. That is a derivation, and this is the third defence-in-depth layer in
-   * `sqlite_query.ts`'s read-only guard, so it is not taken on faith: the driver tests run both
-   * libraries side by side over SELECT, a CTE, VALUES, EXPLAIN, an empty-result SELECT, INSERT,
-   * UPDATE, DELETE, CREATE, a reading PRAGMA and an assigning PRAGMA, and require every verdict to
-   * agree. If a future SQLite statement form ever breaks the equivalence, that test fails rather
-   * than the guard quietly weakening.
-   */
-  get reader() {
-    return attempt(() => this.#stmt.columns()).length > 0;
-  }
-  // A plucked row is "the first column", which for an object row means the first *inserted* key. V8 preserves insertion order for string keys, and node:sqlite builds the row by walking the result columns left to right, so Object.values()[0] is the leftmost column -- not the column named in the SQL text, the same rule better-sqlite3 applies.
-  #shape(row) {
-    if (!this.#pluck || row === void 0 || row === null) return row;
-    const values = Object.values(row);
-    return values.length === 0 ? void 0 : values[0];
-  }
-  get(...params) {
-    return this.#shape(attempt(() => this.#stmt.get(...params)));
-  }
-  all(...params) {
-    const rows2 = attempt(() => this.#stmt.all(...params));
-    return this.#pluck ? rows2.map((r) => this.#shape(r)) : rows2;
-  }
-  run(...params) {
-    return attempt(() => this.#stmt.run(...params));
-  }
-  // Wrapped rather than returned directly so pluck applies lazily, one row at a time: the whole point of iterate() here is that sqlite_query.ts caps the row count without buffering the rest, and mapping the iterator through .all() first would defeat that.
-  *iterate(...params) {
-    const rows2 = attempt(() => this.#stmt.iterate(...params))[Symbol.iterator]();
-    for (; ; ) {
-      const next = attempt(() => rows2.next());
-      if (next.done === true) return;
-      yield this.#shape(next.value);
-    }
-  }
-  pluck(toggle = true) {
-    this.#pluck = toggle;
-    return this;
-  }
-  safeIntegers(toggle = true) {
-    this.#stmt.setReadBigInts(toggle);
-    return this;
-  }
-  columns() {
-    return attempt(() => this.#stmt.columns());
-  }
-};
-var Database = class {
-  #db;
-  #path;
-  #readonly;
-  #savepoints = 0;
-  constructor(dbPath, options = {}) {
-    const wantsExisting = options.readonly === true || options.fileMustExist === true;
-    if (wantsExisting && dbPath !== ":memory:" && !fs2.existsSync(dbPath)) {
-      throw new Error("unable to open database file");
-    }
-    this.#db = attempt(() => new DatabaseSync(dbPath, {
-      readOnly: options.readonly === true,
-      // sqlite-vec is loaded through db.loadExtension by initConnection, which node:sqlite refuses unless the connection opted in at construction. Harmless when no extension is ever loaded.
-      allowExtension: true,
-      // better-sqlite3 opens every connection with busy_timeout at 5000ms; node:sqlite opens at 0, so a connection that named no timeout would silently go from five seconds of patience to none. db.ts overrides this to 15000 in initConnection, but sqlite_query.ts opens a user's arbitrary database readonly and takes whatever the default is -- which would have turned ordinary contention with another writer into an immediate "database is locked".
-      timeout: options.timeout ?? 5e3
-    }));
-    this.#path = dbPath;
-    this.#readonly = options.readonly === true;
-  }
-  get open() {
-    return this.#db.isOpen;
-  }
-  get inTransaction() {
-    return this.#db.isTransaction;
-  }
-  get readonly() {
-    return this.#readonly;
-  }
-  get name() {
-    return this.#path;
-  }
-  prepare(sql) {
-    return new Statement(attempt(() => this.#db.prepare(sql)));
-  }
-  exec(sql) {
-    attempt(() => this.#db.exec(sql));
-  }
-  pragma(source, options = {}) {
-    const rows2 = attempt(() => this.#db.prepare(`PRAGMA ${source}`).all());
-    if (options.simple !== true) return rows2;
-    const first = rows2[0];
-    if (first === void 0) return void 0;
-    const values = Object.values(first);
-    return values.length === 0 ? void 0 : values[0];
-  }
-  function(name, options, fn) {
-    attempt(() => this.#db.function(name, options, fn));
-  }
-  loadExtension(extensionPath) {
-    attempt(() => this.#db.loadExtension(extensionPath));
-  }
-  close() {
-    attempt(() => this.#db.close());
-  }
-  /**
-   * Wrap `fn` so it runs inside a transaction, committing on return and rolling back on throw.
-   *
-   * Nesting uses SAVEPOINT, which is what makes it safe for a transactional helper to call another
-   * one: an inner `BEGIN` would throw ("cannot start a transaction within a transaction"), an inner
-   * SAVEPOINT composes. Whether we are nested is read from SQLite via `isTransaction` rather than
-   * tracked in a counter here, so a transaction some other code path opened still nests correctly.
-   *
-   * The rollback is best-effort and never replaces the caller's error: if the ROLLBACK itself fails
-   * -- the connection died, the transaction was already unwound -- the original failure is still
-   * what propagates, because that is the one that explains what went wrong.
-   */
-  transaction(fn) {
-    const build = (beginSql) => (...args) => {
-      if (this.#db.isTransaction) {
-        const name = `tg_sp_${this.#savepoints++}`;
-        attempt(() => this.#db.exec(`SAVEPOINT ${name}`));
-        try {
-          const result = fn(...args);
-          attempt(() => this.#db.exec(`RELEASE ${name}`));
-          return result;
-        } catch (e) {
-          try {
-            attempt(() => this.#db.exec(`ROLLBACK TO ${name}`));
-            attempt(() => this.#db.exec(`RELEASE ${name}`));
-          } catch {
-          }
-          throw e;
-        }
-      }
-      attempt(() => this.#db.exec(beginSql));
-      try {
-        const result = fn(...args);
-        attempt(() => this.#db.exec("COMMIT"));
-        return result;
-      } catch (e) {
-        try {
-          attempt(() => this.#db.exec("ROLLBACK"));
-        } catch {
-        }
-        throw e;
-      }
-    };
-    const wrapped = build("BEGIN");
-    wrapped.default = wrapped;
-    wrapped.deferred = build("BEGIN");
-    wrapped.immediate = build("BEGIN IMMEDIATE");
-    wrapped.exclusive = build("BEGIN EXCLUSIVE");
-    return wrapped;
-  }
-};
-
-// src/db.ts
-var _require2 = createRequire2(import.meta.url);
-var _connections = /* @__PURE__ */ new Map();
-var SCHEMA_SQL = `
-CREATE TABLE IF NOT EXISTS files (
-  path TEXT PRIMARY KEY,
-  sha TEXT,
-  mtime REAL,
-  language TEXT,
-  indexed_at REAL,
-  embed_sha TEXT,
-  retry_count INTEGER NOT NULL DEFAULT 0,
-  parser_sha TEXT
-);
--- Expression index on TG_LOWER(path) -- see pathEqClause (sql_path.ts) and TG_LOWER's
--- registration above. TG_LOWER is registered { deterministic: true }, which is required for
--- SQLite to index an expression at all; without it CREATE INDEX on a function call throws
--- "non-deterministic functions prohibited in index expressions". Because pathEqClause emits
--- this exact 'TG_LOWER(path) = ?' text for every case-insensitive-filesystem query, the planner
--- matches it against this index and uses SEARCH instead of a full table SCAN, without requiring
--- any writer to populate a separate folded column (verified via EXPLAIN QUERY PLAN in
--- db.test.ts / sql_path.test.ts). CREATE INDEX IF NOT EXISTS is purely additive and safe to run
--- against an already-populated table on every connection open, unlike an ALTER TABLE column add
--- -- no MIGRATIONS entry or SCHEMA_VERSION bump is needed for this index.
-CREATE INDEX IF NOT EXISTS idx_files_path_folded ON files(TG_LOWER(path));
-
-CREATE TABLE IF NOT EXISTS symbols (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  file_path TEXT,
-  name TEXT,
-  kind TEXT,
-  line_start INTEGER,
-  line_end INTEGER,
-  body TEXT,
-  docstring TEXT,
-  parent TEXT NOT NULL DEFAULT ''
-);
-CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
-CREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file_path);
-CREATE INDEX IF NOT EXISTS idx_symbols_name_kind ON symbols(name, kind);
-CREATE INDEX IF NOT EXISTS idx_symbols_file_folded ON symbols(TG_LOWER(file_path));
-CREATE INDEX IF NOT EXISTS idx_symbols_file_name_folded ON symbols(TG_LOWER(file_path), name);
--- Partial index backing checkSymbolBodySize (cli_doctor.ts), which every SessionStart hook runs.
--- Its predicate cannot be served by any index above, so the check had to read the whole symbols
--- table -- 226 MB / 231324 rows here, 229 ms per session start, and the early-exit LIMIT 1 never
--- fires on a healthy index because there is nothing to find. Indexing the *violating* rows only
--- makes the check a lookup into a b-tree that is empty on a healthy index: measured 229 ms -> 0.0
--- ms, 4 KB on disk, and no measurable insert cost (-0.2%, within noise, over 40000 real rows),
--- because SQLite evaluates the predicate and skips the b-tree write for every row under the cap.
--- SQLite uses a partial index only where the query's WHERE implies the index's, so the probe in
--- cli_doctor.ts spells its comparison the same way and against the same constant. That makes the
--- threshold part of the stored schema -- see SYMBOL_BODY_CHAR_CAP in constants.ts for what
--- changing it requires. A query with a lower threshold correctly gets a full scan instead, so no
--- other reader can be served stale rows by this index.
-CREATE INDEX IF NOT EXISTS idx_symbols_oversized_body ON symbols(id) WHERE LENGTH(body) > ${SYMBOL_BODY_CHAR_CAP};
-
-CREATE TABLE IF NOT EXISTS refs (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  file_path TEXT,
-  name TEXT,
-  line INTEGER,
-  col INTEGER,
-  context TEXT
-);
-CREATE INDEX IF NOT EXISTS idx_refs_name ON refs(name);
-CREATE INDEX IF NOT EXISTS idx_refs_file ON refs(file_path);
-CREATE INDEX IF NOT EXISTS idx_refs_file_folded ON refs(TG_LOWER(file_path));
-CREATE INDEX IF NOT EXISTS idx_refs_file_name_folded ON refs(TG_LOWER(file_path), name);
-
-CREATE TABLE IF NOT EXISTS chunks (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  file_path TEXT,
-  start_line INTEGER,
-  end_line INTEGER,
-  text TEXT,
-  kind TEXT
-);
-CREATE INDEX IF NOT EXISTS idx_chunks_file ON chunks(file_path);
-CREATE INDEX IF NOT EXISTS idx_chunks_file_folded ON chunks(TG_LOWER(file_path));
-CREATE INDEX IF NOT EXISTS idx_chunks_file_kind_folded ON chunks(TG_LOWER(file_path), kind);
-
--- Tracks every project root a hook has ever seen an edit for, so the worker's periodic sweep
--- (sweepKnownRoots in index_prune.ts) knows which roots to auto-prune without scanning the
--- entire shared files table for distinct top-level directories on every cycle. Purely additive
--- (no SCHEMA_VERSION bump needed): last_seen_ms is refreshed on every observed edit,
--- first_missing_ms is set the first sweep that finds the root unreachable and cleared the
--- moment it's seen reachable again -- see sweepKnownRoots' grace-period logic.
-CREATE TABLE IF NOT EXISTS known_roots (
-  root TEXT PRIMARY KEY,
-  last_seen_ms REAL NOT NULL,
-  first_missing_ms REAL
-);
-
--- Resume point for a budget-truncated reconcile sweep (reconcile.ts), one row per project root. A
--- project too large to finish a sweep inside DEFAULT_RECONCILE_BUDGET_MS would otherwise scan the
--- same deterministic (git ls-files) prefix every session forever, leaving every file after the
--- budget cutoff permanently unchecked. last_scanned_path is the last tracked file the sweep
--- finished examining before its budget ran out; the next sweep rotates its scan order to resume
--- right after that file, wrapping back to the start, so repeated truncated sweeps eventually cover
--- the whole project. Cleared (row deleted) the moment a sweep completes a full lap without running
--- out of budget. Purely additive (no SCHEMA_VERSION bump needed): a missing row just means "start
--- from the beginning", the same as a fresh database.
-CREATE TABLE IF NOT EXISTS reconcile_cursor (
-  root TEXT PRIMARY KEY,
-  last_scanned_path TEXT NOT NULL,
-  updated_at REAL NOT NULL
-);
-
--- Cross-cache full-text search index for 'token-goat recall' (recall_index.ts). One row
--- per bash-output/web-output/mcp-output blob-store entry (see disk_cache.ts), refreshed
--- in place (ON CONFLICT DO UPDATE) whenever storeBashOutput/storeWebOutput/storeMcpOutput
--- write that entry, so recall never needs a separate rebuild step. row_id is a plain
--- surrogate integer key -- entry_id is the real blob-store id (bash/mcp ids are hex,
--- web ids are the cache's own scheme) and is not unique on its own since bash-output and
--- mcp-output ids share one namespace (BASH_OUTPUT_SUBDIR) while web-output ids are a
--- separate namespace; cache_type disambiguates.
-CREATE TABLE IF NOT EXISTS cache_recall (
-  row_id INTEGER PRIMARY KEY AUTOINCREMENT,
-  cache_type TEXT NOT NULL,
-  entry_id TEXT NOT NULL,
-  label TEXT,
-  content TEXT,
-  stored_at REAL,
-  UNIQUE(cache_type, entry_id)
-);
-CREATE INDEX IF NOT EXISTS idx_cache_recall_type ON cache_recall(cache_type);
-
--- Per-emission ledger for 'token-goat hint-stats' (hint_stats.ts). One row per hint
--- emission event (a hook returning a 'context' HookOutput classified as a discretionary
--- efficiency nudge, as opposed to a mandatory informational injection -- see hint_stats.ts's
--- doc comment for the exact category list and what is deliberately excluded). correlator is a
--- best-effort file-path/output-id substring extracted from the hint's own text, used to check
--- whether a later Bash tool call in the same session actually followed the hint's specific
--- pointer (see resolvePendingHintsForEvent) -- NULL when no such pointer could be extracted,
--- in which case the row is inserted already resolved with acted_on=0 (counted as emitted, never
--- eligible for auto-detected credit). calls_remaining is the countdown of subsequent tool-use
--- events still eligible to resolve this row before it is considered timed out.
-CREATE TABLE IF NOT EXISTS hint_emissions (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  category TEXT NOT NULL,
-  session_id TEXT NOT NULL,
-  harness TEXT NOT NULL,
-  correlator TEXT,
-  emitted_at REAL NOT NULL,
-  resolved INTEGER NOT NULL DEFAULT 0,
-  acted_on INTEGER NOT NULL DEFAULT 0,
-  calls_remaining INTEGER NOT NULL DEFAULT 0,
-  bytes_emitted INTEGER
-);
-CREATE INDEX IF NOT EXISTS idx_hint_emissions_category ON hint_emissions(category);
-CREATE INDEX IF NOT EXISTS idx_hint_emissions_session_pending ON hint_emissions(session_id, resolved);
-
--- Manual efficacy votes for a hint category (token-goat hint-stats --mark-effective/--mark-ineffective),
--- kept separate from hint_emissions' automatic acted_on signal so the two are never silently
--- blended -- see hint_stats.ts's doc comment on why some categories only support this manual signal.
-CREATE TABLE IF NOT EXISTS hint_manual_marks (
-  category TEXT PRIMARY KEY,
-  effective_count INTEGER NOT NULL DEFAULT 0,
-  ineffective_count INTEGER NOT NULL DEFAULT 0
-);
-
--- Durable counter backing hint_stats.ts's backoff-threshold probe-recovery schedule: how many
--- CONSECUTIVE suppressed occasions have elapsed for (category, harness) since a hint in this
--- category was last actually shown (either organically, because shouldSuppress no longer holds,
--- or via a prior probe). shouldSuppress itself stays a pure function of hint_emissions -- this
--- table exists only because a suppressed occasion is deliberately never written to
--- hint_emissions (see that table's own comment), so without a separate durable counter here
--- there would be no way to know "how many suppressed occasions have we seen" across the
--- short-lived hook CLI processes that call applyHintTracking. Keyed by (category, harness), not
--- category alone, to match shouldSuppress/categoryStats' own per-harness scoping -- unlike
--- hint_manual_marks (a human-entered vote, deliberately not harness-split).
-CREATE TABLE IF NOT EXISTS hint_suppression_probes (
-  category TEXT NOT NULL,
-  harness TEXT NOT NULL,
-  streak INTEGER NOT NULL DEFAULT 0,
-  PRIMARY KEY (category, harness)
-);
-
--- Free-text architecture/rationale notes (the "why" layer -- see notes.ts), attached either to
--- a whole file (symbol = '') or to one specific indexed symbol within it (symbol = that
--- symbol's name). '' rather than NULL for the whole-file case because SQLite's UNIQUE treats
--- NULLs as pairwise-distinct (never conflicting with each other), which would let note-add
--- accumulate unlimited duplicate whole-file notes for the same file instead of upserting one;
--- '' is a real, comparable value so UNIQUE(file_path, symbol) enforces "at most one note per
--- attachment point" for both cases identically. 'fingerprint' is a SHA-256 digest (see
--- fingerprintContent in fingerprint.ts) captured at write time of exactly what the note
--- describes -- the resolved symbol's current body text for a symbol-scoped note, or a stable
--- digest of the file's current top-level symbol manifest (name:kind:line-range per symbol,
--- sorted) for a file-scoped note -- so 'token-goat note-list --stale-only' can recompute the
--- same fingerprint against the live index later and flag a mismatch (see notes.ts's
--- isNoteStale). Staleness detection is purely advisory: nothing here ever auto-rewrites or
--- deletes a note's content, only flags that the code it describes has moved since it was
--- written -- a human/agent re-review decides what to do with a stale note.
-CREATE TABLE IF NOT EXISTS notes (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  file_path TEXT NOT NULL,
-  symbol TEXT NOT NULL DEFAULT '',
-  content TEXT NOT NULL,
-  fingerprint TEXT NOT NULL,
-  created_at REAL NOT NULL,
-  updated_at REAL NOT NULL,
-  UNIQUE(file_path, symbol)
-);
-CREATE INDEX IF NOT EXISTS idx_notes_file_folded ON notes(TG_LOWER(file_path));
-
--- Baseline for skill_version_drift.ts's one-shot nudge: the token-goat CLI version (and its
--- flat command-name set, JSON-encoded) active the moment the token-goat skill's body was
--- last (re)loaded into this session -- see hooks_skill.ts's postSkillHandler. A session that
--- keeps running after the CLI is upgraded has no other way to learn that new surgical-read
--- commands now exist (the skill only re-announces itself on an explicit reload), so
--- checkSkillVersionDrift compares this snapshot against the live command set on each user turn
--- and fires the nudge exactly once (notified_at) per (re)load. session_id is the primary key
--- because only one skill (token-goat) is ever tracked here.
-CREATE TABLE IF NOT EXISTS skill_version_snapshots (
-  session_id TEXT PRIMARY KEY,
-  skill_name TEXT NOT NULL,
-  loaded_version TEXT NOT NULL,
-  loaded_commands_json TEXT NOT NULL,
-  notified_at REAL
-);
-
--- Which embedding stack produced the vectors currently in chunk_vectors -- the model, its
--- pinned revision, and the inference runtime (see embeddingProvenance in embeddings.ts). The
--- vector table itself is vec0(rowid, embedding) and has nowhere to record this, so without
--- this row a database that was embedded by one stack and then added to by another holds two
--- incomparable sets of vectors under one index, with nothing able to tell them apart. That is
--- not hypothetical: global.db is machine-wide across every project on the machine (see
--- constants.ts), so upgrading the runtime, or changing the model or its pinned revision, mixes
--- old and new vectors for as long as the old files go untouched. Measured drift between two
--- runtime versions of the same quantized model is 0.9925-0.9978 cosine on the final vector --
--- small, but enough to reorder near-ties, and invisible to every existing check.
---
--- Single-row by construction (the CHECK pins the key), because there is exactly one vector
--- table per database. An EMPTY table on a database that already holds chunks means the vectors
--- predate this stamp and their provenance is unknowable -- see ensureEmbeddingProvenance, which
--- treats that exactly like a mismatch. That is what makes this work without a migration step.
-CREATE TABLE IF NOT EXISTS embedding_provenance (
-  id INTEGER PRIMARY KEY CHECK (id = 1),
-  provenance TEXT NOT NULL
-);
-`;
-var FTS_TOKENIZER = "unicode61 remove_diacritics 2";
-var FTS_SQL = `
-CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(
-  name,
-  body,
-  docstring,
-  content='symbols',
-  content_rowid='id',
-  tokenize='${FTS_TOKENIZER}'
-);
-CREATE TRIGGER IF NOT EXISTS symbols_ai AFTER INSERT ON symbols BEGIN
-  INSERT INTO symbols_fts(rowid, name, body, docstring)
-  VALUES (new.id, new.name, new.body, new.docstring);
-END;
-CREATE TRIGGER IF NOT EXISTS symbols_ad AFTER DELETE ON symbols BEGIN
-  INSERT INTO symbols_fts(symbols_fts, rowid, name, body, docstring)
-  VALUES ('delete', old.id, old.name, old.body, old.docstring);
-END;
-CREATE TRIGGER IF NOT EXISTS symbols_au AFTER UPDATE ON symbols BEGIN
-  INSERT INTO symbols_fts(symbols_fts, rowid, name, body, docstring)
-  VALUES ('delete', old.id, old.name, old.body, old.docstring);
-  INSERT INTO symbols_fts(rowid, name, body, docstring)
-  VALUES (new.id, new.name, new.body, new.docstring);
-END;
-
--- Content-linked FTS5 mirror of cache_recall (recall_index.ts), same shape as symbols_fts
--- above. An INSERT ... ON CONFLICT DO UPDATE against cache_recall fires the AFTER UPDATE
--- trigger (not AFTER INSERT) on the conflicting row, same as any other SQLite upsert, so the
--- delete+reinsert pattern below keeps the fts index correct on a re-indexed (overwritten)
--- entry, not just a brand-new one.
-CREATE VIRTUAL TABLE IF NOT EXISTS cache_recall_fts USING fts5(
-  label,
-  content,
-  content='cache_recall',
-  content_rowid='row_id',
-  tokenize='${FTS_TOKENIZER}'
-);
-CREATE TRIGGER IF NOT EXISTS cache_recall_ai AFTER INSERT ON cache_recall BEGIN
-  INSERT INTO cache_recall_fts(rowid, label, content)
-  VALUES (new.row_id, new.label, new.content);
-END;
-CREATE TRIGGER IF NOT EXISTS cache_recall_ad AFTER DELETE ON cache_recall BEGIN
-  INSERT INTO cache_recall_fts(cache_recall_fts, rowid, label, content)
-  VALUES ('delete', old.row_id, old.label, old.content);
-END;
-CREATE TRIGGER IF NOT EXISTS cache_recall_au AFTER UPDATE ON cache_recall BEGIN
-  INSERT INTO cache_recall_fts(cache_recall_fts, rowid, label, content)
-  VALUES ('delete', old.row_id, old.label, old.content);
-  INSERT INTO cache_recall_fts(rowid, label, content)
-  VALUES (new.row_id, new.label, new.content);
-END;
-`;
-var SCHEMA_VERSION = 14;
-function alterTableIdempotent(conn, sql) {
-  try {
-    conn.exec(sql);
-  } catch (err) {
-    if (!(err instanceof Error) || !/duplicate column/i.test(err.message)) throw err;
-  }
-}
-function purgeDotenvEmbeddings(conn) {
-  let paths;
-  try {
-    paths = conn.prepare("SELECT DISTINCT file_path FROM chunks").all().map((r) => r.file_path).filter(isDotenvPath);
-  } catch {
-    return;
-  }
-  if (paths.length === 0) return;
-  for (const p of paths) {
-    try {
-      conn.prepare("DELETE FROM chunk_vectors WHERE rowid IN (SELECT id FROM chunks WHERE file_path = ?)").run(p);
-    } catch {
-    }
-    conn.prepare("DELETE FROM chunks WHERE file_path = ?").run(p);
-    try {
-      conn.prepare("UPDATE files SET embed_sha = NULL WHERE path = ?").run(p);
-    } catch {
-    }
-  }
-}
-function rebuildFtsAtCurrentTokenizer(conn) {
-  try {
-    const declarations = conn.prepare("SELECT sql FROM sqlite_master WHERE name IN ('symbols_fts','cache_recall_fts')").all();
-    const current = declarations.map((d) => /tokenize\s*=\s*'([^']*)'/.exec(d.sql ?? "")?.[1] ?? "");
-    if (current.length === 2 && current.every((t) => t === FTS_TOKENIZER)) return;
-    conn.transaction(() => {
-      conn.exec("DROP TABLE IF EXISTS symbols_fts; DROP TABLE IF EXISTS cache_recall_fts;");
-      conn.exec(FTS_SQL);
-      conn.exec("INSERT INTO symbols_fts(symbols_fts) VALUES('rebuild');");
-      conn.exec("INSERT INTO cache_recall_fts(cache_recall_fts) VALUES('rebuild');");
-    }).immediate();
-  } catch {
-  }
-}
-var MIGRATIONS = {
-  // v1 -> v2: adds files.embed_sha, tracked separately from files.sha so embedding freshness can be gated independently of parse freshness (see makeIndexer in worker.ts). A pre-existing v1 database's `files` table predates the column, so it needs an explicit ALTER TABLE here; a brand-new database already has the column from SCHEMA_SQL's CREATE TABLE above, so the ALTER TABLE would fail with "duplicate column name" there -- swallow exactly that error and rethrow anything else, so a genuine ALTER TABLE failure is never silently lost.
-  1: (conn) => alterTableIdempotent(conn, "ALTER TABLE files ADD COLUMN embed_sha TEXT"),
-  // v2 -> v3: adds files.retry_count, a durable per-path counter for consecutive transient-read-failure requeues (see MAX_TRANSIENT_RETRIES / requeueDirtyPath / clearRetryCount in worker.ts). Previously this counter lived only in an in-memory Map inside worker.ts, which meant the retry-count reset -- run at the time in the short-lived hook CLI process -- could never actually reach the long-lived detached daemon process's own copy of that Map: they are different Node processes with no shared memory, so the reset was a silent no-op in the real deployed topology. Persisting the counter in `files` makes it visible to both processes via the one thing they do share: the index DB. Same swallow-duplicate-column pattern as v1 -> v2 above.
-  2: (conn) => alterTableIdempotent(conn, "ALTER TABLE files ADD COLUMN retry_count INTEGER NOT NULL DEFAULT 0"),
-  // v8 -> v9: adds symbols.parent (see SCHEMA_VERSION comment above for why). A pre-existing v8 database's `symbols` table predates the column, so it needs an explicit ALTER TABLE here; a brand-new database already has the column from SCHEMA_SQL's CREATE TABLE above, so the ALTER TABLE would fail with "duplicate column name" there -- swallow exactly that error and rethrow anything else, same pattern as v1 -> v2 / v2 -> v3 above.
-  8: (conn) => alterTableIdempotent(conn, "ALTER TABLE symbols ADD COLUMN parent TEXT NOT NULL DEFAULT ''"),
-  // v9 -> v10: adds hint_emissions.bytes_emitted (see SCHEMA_VERSION comment above for why). A pre-existing v9 database's `hint_emissions` table predates the column, so it needs an explicit ALTER TABLE here; a brand-new database already has the column from SCHEMA_SQL's CREATE TABLE above, so the ALTER TABLE would fail with "duplicate column name" there -- swallow exactly that error and rethrow anything else, same pattern as v1 -> v2 / v2 -> v3 / v8 -> v9 above.
-  9: (conn) => alterTableIdempotent(conn, "ALTER TABLE hint_emissions ADD COLUMN bytes_emitted INTEGER"),
-  // v10 -> v11: purge chunks (and their vectors) for dotenv files. Until this version, a tracked `.env` was chunked and embedded verbatim on the git path, so `semantic` returned its values -- see dotenv_redact.ts. Redacting from now on is not enough on its own: the embed-freshness gate (isEmbedFresh in parser.ts) skips a file whose bytes have not changed, so an already-indexed .env would have kept serving its pre-fix chunks indefinitely. Deleting the rows here both removes the stored secrets and, by clearing embed_sha, makes the next drain re-embed the file through the redacting path.
-  10: purgeDotenvEmbeddings,
-  // v12 -> v13: adds files.parser_sha, the digest of the extraction logic that produced this file's rows, tracked separately from files.sha for the same reason embed_sha is -- content freshness and parse freshness are different questions, and the content sha alone could only ever answer the first. A pre-existing v12 database's `files` table predates the column, so it needs an explicit ALTER TABLE here; a brand-new database already has it from SCHEMA_SQL's CREATE TABLE above, so the ALTER TABLE would fail with "duplicate column name" there -- swallow exactly that error and rethrow anything else, same pattern as v1 -> v2 / v2 -> v3 / v8 -> v9 / v9 -> v10 above. Deliberately left NULL for every existing row rather than backfilled with the current fingerprint: NULL is the truthful answer (nobody recorded which parser wrote those rows), and it is also the answer that makes the freshness gates reparse them once, which is exactly what a database indexed by an older parser needs. v13 -> v14: changes both FTS5 tables' tokenizer to `unicode61 remove_diacritics 2`, so a search for `Noi` or `Viet` finds `Hà Nội` and `Việt Nam` -- combining marks that `remove_diacritics 1`, FTS5's default, leaves in place. This is the first schema change that `CREATE VIRTUAL TABLE IF NOT EXISTS` cannot express at all rather than merely cannot express on a populated table: against an existing virtual table that statement is a silent no-op, so without MIGRATIONS[13] the new tokenizer would reach only databases created after this release. The step drops both tables, re-runs FTS_SQL to re-create them at the current declaration, and rebuilds each from its content table.
-  12: (conn) => alterTableIdempotent(conn, "ALTER TABLE files ADD COLUMN parser_sha TEXT"),
-  // v13 -> v14: re-creates both FTS5 tables at the tokenizer FTS_SQL currently declares (see the SCHEMA_VERSION comment above for why no `IF NOT EXISTS` form can do this).
-  13: rebuildFtsAtCurrentTokenizer
-};
-function runMigrations(conn, fromVersion, toVersion) {
-  for (let v = fromVersion; v < toVersion; v++) {
-    MIGRATIONS[v]?.(conn);
-  }
-}
-var WAL_SWITCH_DEADLINE_MS = 15e3;
-function enableWalWithRetry(conn, budgetMs = WAL_SWITCH_DEADLINE_MS) {
-  const deadline = Date.now() + budgetMs;
-  let lastError;
-  for (; ; ) {
-    try {
-      const mode = conn.pragma("journal_mode = WAL", { simple: true });
-      if (String(mode).toLowerCase() === "wal") return;
-      lastError = new Error(`got: ${String(mode)}`);
-    } catch (e) {
-      lastError = e;
-    }
-    try {
-      if (String(conn.pragma("journal_mode", { simple: true })).toLowerCase() === "wal") return;
-    } catch {
-    }
-    if (Date.now() >= deadline) {
-      throw new Error(`db: failed to enable WAL mode (${lastError instanceof Error ? lastError.message : String(lastError)})`);
-    }
-    sleepSync(25);
-  }
-}
-function initConnection(conn) {
-  conn.pragma("busy_timeout = 15000");
-  enableWalWithRetry(conn);
-  conn.pragma("synchronous = NORMAL");
-  conn.pragma("cache_size = -32000");
-  conn.pragma("temp_store = MEMORY");
-  conn.pragma("mmap_size = 134217728");
-  conn.function(
-    "TG_LOWER",
-    { deterministic: true },
-    (value) => value === null ? null : foldCase(String(value))
-  );
-  const storedVersion = Number(conn.pragma("user_version", { simple: true }));
-  if (storedVersion > SCHEMA_VERSION) {
-    throw new Error(
-      `db: index schema version ${storedVersion} is newer than this token-goat build supports (expected ${SCHEMA_VERSION}). Update token-goat, or delete the stale index database and let it rebuild.`
-    );
-  }
-  conn.exec(SCHEMA_SQL);
-  try {
-    conn.exec(FTS_SQL);
-  } catch {
-  }
-  try {
-    const sqliteVec = _require2("sqlite-vec");
-    sqliteVec.load(conn);
-    conn.exec(
-      `CREATE VIRTUAL TABLE IF NOT EXISTS chunk_vectors USING vec0(
-         embedding float[384]
-       );`
-    );
-  } catch {
-  }
-  if (storedVersion < SCHEMA_VERSION) {
-    runMigrations(conn, storedVersion, SCHEMA_VERSION);
-    conn.pragma(`user_version = ${SCHEMA_VERSION}`);
-  }
-}
-function resolveDbPath(dbPath) {
-  if (path2.isAbsolute(dbPath)) return dbPath;
-  if (dbPath.includes("/") || dbPath.includes("\\")) return path2.resolve(dbPath);
-  return safeJoin(dataDir(), dbPath);
-}
-function connectionKey(dbPath) {
-  const resolved = resolveDbPath(dbPath);
-  return { resolved, key: foldPath(resolved) };
-}
-function getDb(dbPath) {
-  const { resolved, key } = connectionKey(dbPath);
-  const existing = _connections.get(key);
-  if (existing !== void 0) return existing;
-  const dir = path2.dirname(resolved);
-  try {
-    ensureDirSync(dir);
-  } catch (e) {
-    if (e.code !== "EEXIST" || !fs3.existsSync(dir)) throw e;
-  }
-  const conn = new Database(resolved);
-  try {
-    initConnection(conn);
-  } catch (e) {
-    try {
-      conn.close();
-    } catch {
-    }
-    throw e;
-  }
-  _connections.set(key, conn);
-  return conn;
-}
-function closeAllDbs() {
-  for (const conn of _connections.values()) {
-    try {
-      conn.close();
-    } catch {
-    }
-  }
-  _connections.clear();
-}
-registerReset(closeAllDbs);
-
 // src/render/ansi.ts
 init_define_import_meta_env();
 function _colorStream(isatty) {
@@ -1201,7 +108,7 @@ var C = {
 
 // src/stats.ts
 init_define_import_meta_env();
-import * as path3 from "node:path";
+import * as path from "node:path";
 
 // src/render/stats_renderer.ts
 init_define_import_meta_env();
@@ -1566,6 +473,7 @@ var _KIND_GROUPS = [
       "gdrive_image",
       "webfetch_image",
       "image_shrink_skipped",
+      "image_shrink_over_pixel_limit",
       "image_shrink_cache_hit",
       "image_ocr"
     ])
@@ -1965,6 +873,7 @@ var KIND_TO_SOURCE = {
   image_shrink: SOURCE_IMAGE,
   image_shrink_cache_hit: SOURCE_IMAGE,
   image_shrink_skipped: SOURCE_IMAGE,
+  image_shrink_over_pixel_limit: SOURCE_IMAGE,
   image_ocr: SOURCE_IMAGE,
   webfetch_image: SOURCE_IMAGE,
   gdrive_image: SOURCE_IMAGE,
@@ -2329,7 +1238,7 @@ function statsHasVersionColumn(db) {
 }
 function getGlobalDb(homeDir) {
   const basePath = homeDir ? dataDirForHome(homeDir) : dataDir();
-  const dbPath = path3.join(basePath, "global.db");
+  const dbPath = path.join(basePath, "global.db");
   const db = getDb(dbPath);
   if (!_globalSchemaApplied.has(dbPath)) {
     db.exec(GLOBAL_SCHEMA_SQL);
@@ -2470,10 +1379,10 @@ function summarize(windowDays = 30, testDb, homeDir) {
   ].join(", ");
   const query = sinceTs !== null ? `SELECT ${cols} FROM stats WHERE ts >= ? ORDER BY ts DESC` : `SELECT ${cols} FROM stats ORDER BY ts DESC`;
   const stmt = db.prepare(query);
-  const rows2 = sinceTs !== null ? stmt.all(sinceTs) : stmt.all();
+  const rows = sinceTs !== null ? stmt.all(sinceTs) : stmt.all();
   const tsToDateCache = {};
   const counts = {};
-  for (const row of rows2) {
+  for (const row of rows) {
     const bytesSaved = row.bytes_saved ?? 0;
     const recorded = row.tokens_saved ?? 0;
     const kind = row.kind;
@@ -2895,23 +1804,23 @@ function redactSecrets(text, config = loadConfig()) {
 
 // src/disk_cache.ts
 init_define_import_meta_env();
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
+import * as fs from "node:fs";
+import * as path2 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 path4.join(tokenGoatHome(), subdir);
+  return path2.join(tokenGoatHome(), subdir);
 }
 function blobPath(subdir, id) {
   const safe = sanitizeId(id);
   if (!safe) return null;
   const dir = blobDir(subdir);
-  const candidate = path4.join(dir, `${safe}.json`);
+  const candidate = path2.join(dir, `${safe}.json`);
   try {
-    const rel = path4.relative(dir, candidate);
+    const rel = path2.relative(dir, candidate);
     if (rel.startsWith("..")) return null;
   } catch {
     return null;
@@ -2922,7 +1831,7 @@ function isBlobStale(subdir, id) {
   const p = blobPath(subdir, id);
   if (p === null) return false;
   try {
-    const stat = fs4.statSync(p);
+    const stat = fs.statSync(p);
     return Date.now() - stat.mtimeMs > DEFAULT_MAX_AGE_MS;
   } catch {
     return false;
@@ -2963,8 +1872,8 @@ function storeBlob(subdir, id, value, opts = {}) {
   }
   if (Number.isFinite(maxBytesPerItem) && Buffer.byteLength(json, "utf-8") > maxBytesPerItem) return false;
   try {
-    const dir = path4.dirname(p);
-    if (!fs4.existsSync(dir)) ensureDirSync(dir);
+    const dir = path2.dirname(p);
+    if (!fs.existsSync(dir)) ensureDirSync(dir);
     atomicWriteText(p, json);
   } catch {
     return false;
@@ -2982,8 +1891,8 @@ function loadBlob(subdir, id) {
   const p = blobPath(subdir, id);
   if (!p) return null;
   try {
-    if (!fs4.existsSync(p)) return null;
-    return JSON.parse(fs4.readFileSync(p, "utf8"));
+    if (!fs.existsSync(p)) return null;
+    return JSON.parse(fs.readFileSync(p, "utf8"));
   } catch {
     return null;
   }
@@ -2992,13 +1901,13 @@ function listBlobs(subdir) {
   const dir = blobDir(subdir);
   const out = [];
   try {
-    if (!fs4.existsSync(dir)) return out;
-    for (const file of fs4.readdirSync(dir)) {
+    if (!fs.existsSync(dir)) return out;
+    for (const file of fs.readdirSync(dir)) {
       if (!file.endsWith(".json")) continue;
       const id = file.slice(0, -5);
       let mtime = 0;
       try {
-        mtime = fs4.statSync(path4.join(dir, file)).mtimeMs;
+        mtime = fs.statSync(path2.join(dir, file)).mtimeMs;
       } catch {
       }
       const value = loadBlob(subdir, id);
@@ -3015,15 +1924,15 @@ function pruneBlobs(subdir, maxCount = DEFAULT_MAX_COUNT, maxAgeMs = DEFAULT_MAX
 function pruneBlobDir(dir, maxCount = DEFAULT_MAX_COUNT, maxAgeMs = DEFAULT_MAX_AGE_MS, maxBytes = Number.POSITIVE_INFINITY, protectedPath) {
   let removed = 0;
   try {
-    if (!fs4.existsSync(dir)) return 0;
+    if (!fs.existsSync(dir)) return 0;
     const cutoff = Date.now() - maxAgeMs;
     let kept = [];
     let protectedEntry;
-    for (const file of fs4.readdirSync(dir)) {
-      const full = path4.join(dir, file);
+    for (const file of fs.readdirSync(dir)) {
+      const full = path2.join(dir, file);
       let stat;
       try {
-        stat = fs4.statSync(full);
+        stat = fs.statSync(full);
       } catch {
         continue;
       }
@@ -3034,7 +1943,7 @@ function pruneBlobDir(dir, maxCount = DEFAULT_MAX_COUNT, maxAgeMs = DEFAULT_MAX_
       }
       if (stat.mtimeMs < cutoff) {
         try {
-          fs4.unlinkSync(full);
+          fs.unlinkSync(full);
           removed++;
         } catch {
           continue;
@@ -3050,7 +1959,7 @@ function pruneBlobDir(dir, maxCount = DEFAULT_MAX_COUNT, maxAgeMs = DEFAULT_MAX_
       kept = kept.slice(kept.length - countBudget);
       for (const [full] of excess) {
         try {
-          fs4.unlinkSync(full);
+          fs.unlinkSync(full);
           removed++;
         } catch {
           continue;
@@ -3065,7 +1974,7 @@ function pruneBlobDir(dir, maxCount = DEFAULT_MAX_COUNT, maxAgeMs = DEFAULT_MAX_
         if (!oldest) break;
         const [full, , size] = oldest;
         try {
-          fs4.unlinkSync(full);
+          fs.unlinkSync(full);
           removed++;
           total -= size;
         } catch {
@@ -3095,7 +2004,7 @@ function sweepCacheRoots(extraRoots = []) {
       try {
         const defaults = subdirCacheDefaults(subdir);
         removed += pruneBlobDir(
-          path4.join(root, subdir),
+          path2.join(root, subdir),
           countCapped ? defaults.maxCount : Number.POSITIVE_INFINITY,
           DEFAULT_MAX_AGE_MS,
           countCapped ? defaults.maxBytes : Number.POSITIVE_INFINITY
@@ -3108,22 +2017,6 @@ function sweepCacheRoots(extraRoots = []) {
 }
 
 export {
-  Database,
-  FILENAME_LANGUAGE,
-  TREE_SITTER_LANGUAGES,
-  languageHasFlag,
-  languageLabel,
-  fenceFor,
-  basenameImportsExtension,
-  partialRefsReason,
-  refineLanguageByContent,
-  detectLanguageOfFile,
-  detectLanguage,
-  nonTreeSitterLanguageCount,
-  unsupportedLanguageName,
-  isDotenvPath,
-  redactIfDotenv,
-  getDb,
   colorStdout,
   RESET,
   stripAnsiEscapes,