token-goat 2.9.12 → 2.9.14

package/dist/token-goat-chunk-T2IWWTHB.mjs

@@ -0,0 +1,3155 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  getHarnessName,
+  loadConfig
+} from "./token-goat-chunk-SAQ5PG4L.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";
+import {
+  growsExponentially,
+  hasNestedQuantifier
+} from "./token-goat-chunk-GMOUBOX4.mjs";
+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) {
+  if (process.env["NO_COLOR"]) return false;
+  return isatty;
+}
+function colorStdout() {
+  return _colorStream(process.stdout.isTTY === true);
+}
+var _E = "\x1B";
+var RESET = `${_E}[0m`;
+var _ANSI_ESCAPE_RE = /\x1B\[[0-?]*[ -/]*[@-~]|\x1B\].*?(?:\x07|\x1B\\|$)|\x1B[PX^_].*?\x1B\\|\x1B[@-_]/gs;
+var _PUA_RE = /[\u{E000}-\u{F8FF}\u{F0000}-\u{FFFFD}]/gu;
+function stripAnsiEscapes(s) {
+  if (!s.includes("\x1B")) {
+    return s;
+  }
+  return s.replace(_ANSI_ESCAPE_RE, "");
+}
+function stripAnsi(s) {
+  if (!s.includes("\x1B")) {
+    return s;
+  }
+  return stripAnsiEscapes(s).replace(_PUA_RE, "");
+}
+function fmtBytes(n) {
+  let value = n;
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  for (const unit of units) {
+    if (Math.abs(value) < 1024) {
+      return unit === "B" ? `${Math.trunc(value)}${unit}` : `${value.toFixed(1)}${unit}`;
+    }
+    value = value / 1024;
+  }
+  return `${value.toFixed(1)}PB`;
+}
+function fg(r, g, b) {
+  return `${_E}[38;2;${r};${g};${b}m`;
+}
+function vlen(s) {
+  return stripAnsi(s).length;
+}
+function padR(s, w) {
+  return s + " ".repeat(Math.max(0, w - vlen(s)));
+}
+function padL(s, w) {
+  return " ".repeat(Math.max(0, w - vlen(s))) + s;
+}
+function lerpRgb(a, b, t) {
+  return [
+    Math.round(a[0] + (b[0] - a[0]) * t),
+    Math.round(a[1] + (b[1] - a[1]) * t),
+    Math.round(a[2] + (b[2] - a[2]) * t)
+  ];
+}
+var C = {
+  TEXT_PRIMARY: [201, 209, 217],
+  TEXT_BRIGHT: [240, 246, 252],
+  TEXT_MUTED: [125, 133, 144],
+  TEXT_DIM: [72, 79, 88],
+  BG_TILE: [22, 27, 34],
+  TRACK: [28, 35, 41],
+  GREEN1: [31, 77, 44],
+  GREEN2: [46, 160, 67],
+  GREEN3: [63, 185, 80],
+  GREEN4: [86, 211, 100],
+  GREEN5: [126, 231, 135],
+  BLUE: [88, 166, 255],
+  PURPLE: [188, 140, 255],
+  TEAL: [138, 212, 255],
+  ORANGE: [235, 165, 80],
+  YELLOW: [240, 215, 80],
+  RED: [200, 60, 60]
+};
+
+// src/stats.ts
+init_define_import_meta_env();
+import * as path3 from "node:path";
+
+// src/render/stats_renderer.ts
+init_define_import_meta_env();
+var _STATS_MESSAGES_FALLBACK = {
+  bytesModeOnlyNote: "tracks bytes, not vision tokens",
+  sessionHintSplitNote: "session_hint shows realized savings; session_hint_overhead shows injected hint cost",
+  insights: {
+    biggestSaver: "Biggest saver  ",
+    mostActive: "Most active    ",
+    tokenLeader: "Token leader   "
+  }
+};
+var _STATS_MESSAGES = _STATS_MESSAGES_FALLBACK;
+var _TERM_W = process.stdout.columns || 100;
+var _CONTENT_W = Math.min(Math.max(_TERM_W, 80), 140);
+var _M = "  ";
+var _COL_NAME = 18;
+var _COL_DATA = 10;
+var _COL_TOKENS = 12;
+var _COL_SHARE = 6;
+var _COL_EVENTS = 6;
+var _COLS_FIXED = _COL_NAME + 1 + 2 + _COL_DATA + 2 + _COL_TOKENS + 2 + _COL_SHARE + 2 + _COL_EVENTS;
+var _BAR_W = Math.max(16, _CONTENT_W - _M.length * 2 - _COLS_FIXED);
+var _RULE = _M + fg(...C.TEXT_DIM) + "\u2500".repeat(_CONTENT_W - _M.length * 2) + RESET;
+var _BYTE_TIERS = [
+  { threshold: 1e15, divisor: 1e15, unit: "PB", color: C.PURPLE },
+  { threshold: 1e12, divisor: 1e12, unit: "TB", color: C.BLUE },
+  { threshold: 1e9, divisor: 1e9, unit: "GB", color: C.TEAL },
+  { threshold: 1e6, divisor: 1e6, unit: "MB", color: C.GREEN4 },
+  { threshold: 1e3, divisor: 1e3, unit: "KB", color: C.TEXT_MUTED },
+  { threshold: 0, divisor: 1, unit: "B", color: C.TEXT_DIM }
+];
+var _TOKEN_TIERS = [
+  { threshold: 1e12, divisor: 1e12, unit: "Tt", color: C.GREEN5 },
+  { threshold: 1e9, divisor: 1e9, unit: "Gt", color: C.TEAL },
+  { threshold: 1e6, divisor: 1e6, unit: "Mt", color: C.PURPLE },
+  { threshold: 1e3, divisor: 1e3, unit: "kt", color: C.BLUE },
+  { threshold: 0, divisor: 1, unit: "t", color: C.TEXT_DIM }
+];
+function _fmtMagnitude(n, tiers, zeroLabel) {
+  if (zeroLabel !== void 0 && n === 0) {
+    return `${fg(...C.TEXT_DIM)}${zeroLabel}${RESET}`;
+  }
+  if (n < 0) {
+    const a = -n;
+    const color = C.TEXT_DIM;
+    for (const tier of tiers) {
+      if (a >= tier.threshold && tier.threshold > 0) {
+        return `${fg(...color)}-${(a / tier.divisor).toLocaleString("en", { maximumFractionDigits: 1 })} ${tier.unit}${RESET}`;
+      }
+    }
+    const lastTier2 = tiers[tiers.length - 1];
+    if (lastTier2) {
+      return `${fg(...color)}-${a} ${lastTier2.unit}${RESET}`;
+    }
+    return `${fg(...color)}-${a}${RESET}`;
+  }
+  for (const tier of tiers) {
+    if (n >= tier.threshold && tier.threshold > 0) {
+      return `${fg(...tier.color)}${(n / tier.divisor).toLocaleString("en", { maximumFractionDigits: 1 })} ${tier.unit}${RESET}`;
+    }
+  }
+  const lastTier = tiers[tiers.length - 1];
+  if (lastTier) {
+    return `${fg(...lastTier.color)}${n} ${lastTier.unit}${RESET}`;
+  }
+  return `${n}${RESET}`;
+}
+function _fmtBytes(n) {
+  return _fmtMagnitude(n, _BYTE_TIERS);
+}
+function _fmtTokens(n) {
+  return _fmtMagnitude(n, _TOKEN_TIERS, "0 t");
+}
+function _fmtPct(fraction) {
+  return `${(fraction * 100).toFixed(1)}%`;
+}
+function _fmtDelta(delta) {
+  if (!delta && delta !== 0) {
+    return "";
+  }
+  const up = (delta ?? 0) >= 0;
+  const color = up ? C.GREEN5 : C.RED;
+  const arrow = up ? "\u2191" : "\u2193";
+  return ` ${fg(...color)}${arrow} ${Math.round(Math.abs(delta ?? 0))}%${RESET}`;
+}
+var _EIGHTHS = ["\u258F", "\u258E", "\u258D", "\u258C", "\u258B", "\u258A", "\u2589"];
+var _BLOCK = "\u2588";
+var _TRACK = "\u2591";
+var _GRADIENT = [C.GREEN1, C.GREEN2, C.GREEN3, C.GREEN4, C.GREEN5];
+function _distribute(total, n) {
+  if (total <= 0 || n <= 0) {
+    return Array(Math.max(0, n)).fill(0);
+  }
+  const base = Math.floor(total / n);
+  const rem = total % n;
+  return Array.from({ length: n }, (_, i) => base + (i >= n - rem ? 1 : 0));
+}
+function _renderBar(fraction, width = _BAR_W) {
+  const f = Math.max(0, Math.min(1, fraction));
+  const raw = f * width;
+  let nFull = Math.floor(raw);
+  const eighths = Math.round((raw - nFull) * 8);
+  if (eighths >= 8) {
+    nFull += 1;
+  }
+  const hasPartial = eighths > 0 && eighths < 8;
+  const nTrack = Math.max(0, width - nFull - (hasPartial ? 1 : 0));
+  const counts = _distribute(nFull, _GRADIENT.length);
+  let bar = counts.map((count, i) => count > 0 ? `${fg(_GRADIENT[i][0], _GRADIENT[i][1], _GRADIENT[i][2])}${_BLOCK.repeat(count)}` : "").join("");
+  if (hasPartial) {
+    const lastGrad = _GRADIENT[_GRADIENT.length - 1];
+    bar += `${fg(lastGrad[0], lastGrad[1], lastGrad[2])}${_EIGHTHS[eighths - 1]}`;
+  }
+  if (nTrack > 0) {
+    bar += `${fg(...C.TRACK)}${_TRACK.repeat(nTrack)}`;
+  }
+  return bar + RESET;
+}
+var _SPARK = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+function _resample(vals, length) {
+  if (vals.length === 0) {
+    return Array(length).fill(0);
+  }
+  if (vals.length === length) {
+    return [...vals];
+  }
+  const result = [];
+  for (let i = 0; i < length; i++) {
+    const src = i / (length - 1 || 1) * (vals.length - 1);
+    const lo = Math.floor(src);
+    const hi = Math.min(vals.length - 1, lo + 1);
+    const t = src - lo;
+    const loVal = vals[lo] ?? 0;
+    const hiVal = vals[hi] ?? 0;
+    result.push(loVal * (1 - t) + hiVal * t);
+  }
+  return result;
+}
+function _renderSparkline(values, width = 8) {
+  const pts = _resample(values, width);
+  const hi = pts.length > 0 ? Math.max(...pts) : 1;
+  const lo = pts.length > 0 ? Math.min(...pts) : 0;
+  const span = hi - lo || 1;
+  const chars = [];
+  for (let i = 0; i < pts.length; i++) {
+    const v = pts[i];
+    if (v === void 0) continue;
+    const idx = Math.min(7, Math.floor((v - lo) / span * 8));
+    const color = lerpRgb(C.GREEN1, C.GREEN5, i / (width - 1 || 1));
+    chars.push(`${fg(color[0], color[1], color[2])}${_SPARK[idx]}`);
+  }
+  return chars.join("") + RESET;
+}
+function _tokenOrByteShare(itemTokens, itemBytes, totalTokens, totalBytes) {
+  if (totalTokens > 0) {
+    return itemTokens / totalTokens;
+  }
+  if (totalBytes > 0) {
+    return itemBytes / totalBytes;
+  }
+  return 0;
+}
+function _barFraction(itemBytes, grossBytes) {
+  return itemBytes > 0 ? itemBytes / grossBytes : 0;
+}
+function _computeShareDenominators(items) {
+  let grossBytesSum = 0;
+  let shareByteSum = 0;
+  let shareTokensSum = 0;
+  for (const item of items) {
+    if (item.bytes > 0) {
+      grossBytesSum += item.bytes;
+    }
+    shareByteSum += Math.abs(item.bytes);
+    shareTokensSum += Math.abs(item.tokens);
+  }
+  return {
+    grossBytes: Math.max(grossBytesSum, 1),
+    shareBytesDenom: Math.max(shareByteSum, 1),
+    shareTokensDenom: shareTokensSum
+  };
+}
+function _absShare(itemBytes, itemTokens, shareBytesDenom, shareTokensDenom) {
+  if (shareTokensDenom === 0) {
+    return itemBytes / shareBytesDenom;
+  }
+  return itemTokens / shareTokensDenom;
+}
+function _sectionHeader(title, subtitle = "") {
+  const sub = subtitle ? `  ${fg(...C.TEXT_MUTED)}${subtitle}${RESET}` : "";
+  return [
+    "",
+    `${_M}${fg(...C.TEXT_BRIGHT)}${title}${RESET}${sub}`,
+    _RULE
+  ];
+}
+function _tableHeader(firstColLabel) {
+  return [
+    _M,
+    padR(`${fg(...C.TEXT_DIM)}${firstColLabel}${RESET}`, _COL_NAME),
+    " ",
+    padR(`${fg(...C.TEXT_DIM)}savings${RESET}`, _BAR_W),
+    "  ",
+    padL(`${fg(...C.TEXT_DIM)}data saved${RESET}`, _COL_DATA),
+    "  ",
+    padL(`${fg(...C.TEXT_DIM)}tokens saved${RESET}`, _COL_TOKENS),
+    "  ",
+    padL(`${fg(...C.TEXT_DIM)}share${RESET}`, _COL_SHARE),
+    "  ",
+    padL(`${fg(...C.TEXT_DIM)}events${RESET}`, _COL_EVENTS)
+  ].join("");
+}
+function _tableRow({
+  name,
+  fraction,
+  bytes,
+  tokens,
+  events,
+  share,
+  bytesModeOnly = false,
+  namePrefix = "",
+  nameColor = C.TEXT_PRIMARY
+}) {
+  const prefixW = vlen(namePrefix);
+  const maxName = _COL_NAME - prefixW;
+  const truncated = name.length > maxName ? name.slice(0, maxName - 1) + "\u2026" : name;
+  const nameStr = padR(`${namePrefix}${fg(...nameColor)}${truncated}${RESET}`, _COL_NAME);
+  const dataStr = padL(_fmtBytes(bytes), _COL_DATA);
+  const tokStr = bytesModeOnly ? padL(`${fg(...C.TEXT_DIM)}\u2014${RESET}`, _COL_TOKENS) : padL(_fmtTokens(tokens), _COL_TOKENS);
+  const sharePct = share * 100;
+  let shareColor;
+  if (sharePct < 0) {
+    shareColor = C.RED;
+  } else if (sharePct >= 50) {
+    shareColor = C.GREEN5;
+  } else if (sharePct >= 10) {
+    shareColor = C.TEXT_PRIMARY;
+  } else {
+    shareColor = C.TEXT_MUTED;
+  }
+  const shareStr = padL(`${fg(...shareColor)}${_fmtPct(share)}${RESET}`, _COL_SHARE);
+  const evStr = padL(`${fg(...C.TEXT_PRIMARY)}${events.toLocaleString()}${RESET}`, _COL_EVENTS);
+  return [_M, nameStr, " ", _renderBar(fraction), "  ", dataStr, "  ", tokStr, "  ", shareStr, "  ", evStr].join("");
+}
+function _renderKpiSection(stats) {
+  const totals = stats.totals;
+  const colW = Math.floor((_CONTENT_W - _M.length * 2) / 3);
+  function card(label, value, delta, spark2) {
+    return [
+      padR(`${fg(C.TEXT_MUTED[0], C.TEXT_MUTED[1], C.TEXT_MUTED[2])}${label}${RESET}`, colW),
+      padR(`${fg(C.TEXT_BRIGHT[0], C.TEXT_BRIGHT[1], C.TEXT_BRIGHT[2])}${value}${RESET}${delta}`, colW),
+      spark2 !== null ? padR(spark2, colW) : padR("", colW)
+    ];
+  }
+  const spark = totals.sparklines;
+  const c1 = card(
+    "events",
+    `${totals.events.toLocaleString()}`,
+    _fmtDelta(totals.events_delta ?? null),
+    spark ? _renderSparkline(spark.events) : null
+  );
+  const c2 = card(
+    "data saved",
+    _fmtBytes(totals.bytes),
+    _fmtDelta(totals.bytes_delta ?? null),
+    spark ? _renderSparkline(spark.bytes) : null
+  );
+  const c3 = card(
+    "tokens saved",
+    _fmtTokens(totals.tokens),
+    _fmtDelta(totals.tokens_delta ?? null),
+    spark ? _renderSparkline(spark.tokens) : null
+  );
+  const border = fg(C.TEXT_DIM[0], C.TEXT_DIM[1], C.TEXT_DIM[2]);
+  const frameBar = "\u2500".repeat(colW * 3 + 2);
+  function framed(content) {
+    return `${_M}${border}\u2502${RESET} ${content} ${border}\u2502${RESET}`;
+  }
+  const lines = [
+    "",
+    `${_M}${border}\u256D${frameBar}\u256E${RESET}`,
+    framed(c1[0] + c2[0] + c3[0]),
+    framed(c1[1] + c2[1] + c3[1])
+  ];
+  if (spark) {
+    lines.push(framed(c1[2] + c2[2] + c3[2]));
+  }
+  lines.push(`${_M}${border}\u2570${frameBar}\u256F${RESET}`);
+  return lines;
+}
+var _KIND_GROUPS = [
+  {
+    label: "Read savings",
+    members: /* @__PURE__ */ new Set([
+      "read_replacement",
+      "section_replacement",
+      "symbol_read",
+      "section_read",
+      "stub_view",
+      "outline",
+      "exports",
+      "imports",
+      "changed_lookup",
+      "dep_docs",
+      // Every other SOURCE_READ kind in stats.ts's KIND_TO_SOURCE: the surgical-read commands over documents, structured data and session/PR state. They were registered and produced but grouped nowhere, so `stats --full` printed the whole family under 'Other', away from the read-savings siblings they are measured against. image_meta/image_text sit here rather than under 'Images' because stats.ts files them as SOURCE_READ: they save read bytes, they do not shrink an image.
+      "brief_view",
+      "conflicts",
+      "coverage_report_gaps",
+      "csv_query",
+      "csv_profile",
+      "compact_doc",
+      "docx_outline",
+      "docx_tables",
+      "docx_text",
+      "gdrive_sections",
+      "image_meta",
+      "image_text",
+      "json_query",
+      "json_outline",
+      "note_read",
+      "note_list",
+      "openapi_op",
+      "openapi_outline",
+      "pdf_extract",
+      "pdf_locate",
+      "pdf_outline",
+      "pdf_meta",
+      "pptx_outline",
+      "pptx_slide",
+      "pptx_notes",
+      "pptx_text",
+      "pr_slice",
+      "session_outline",
+      "session_slice",
+      "sqlite_query",
+      "sqlite_schema",
+      "sqlite_tables",
+      "transcript",
+      "transcript_outline",
+      "video_chapters",
+      "xlsx_sheets",
+      "xlsx_head",
+      "xlsx_range",
+      "xlsx_query",
+      "xlsx_columns",
+      "xml_query",
+      "xml_outline",
+      "html_query",
+      "html_outline",
+      "yaml_query",
+      "yaml_outline",
+      "zip_list",
+      "zip_read"
+    ])
+  },
+  { label: "Lookups", members: /* @__PURE__ */ new Set(["symbol_lookup", "semantic_search", "map_lookup"]) },
+  {
+    label: "Images",
+    members: /* @__PURE__ */ new Set([
+      "image_shrink",
+      "gdrive_image",
+      "webfetch_image",
+      "image_shrink_skipped",
+      "image_shrink_cache_hit",
+      "image_ocr"
+    ])
+  },
+  {
+    label: "Hints",
+    members: /* @__PURE__ */ new Set([
+      "session_hint",
+      "session_hint_overhead",
+      "session_hint_suppressed",
+      "read_count_deny",
+      "read_served_deny",
+      "subagent_markdown_first_read_deny",
+      "grep_dedup_hint",
+      "glob_dedup_hint",
+      "diff_hint",
+      "predictive_prefetch_hit",
+      "structured_file_hint",
+      "write_rewrite_hint",
+      "websearch_dedup_hint",
+      "large_file_hint_followed",
+      "large_file_hint_ignored",
+      "evidence_cache_hit"
+    ])
+  },
+  // Empty for the same reason as MCP below: every live Bash kind arrives through _kindGroupLabel's `bash_compress:` prefix branch, not through a literal name. The fifteen literal names this set used to carry (bash_output_cached, bash_dedup_hint, env_probe_cache_hit and the rest) came over with the Python port and were never recorded or registered anywhere in this tree, so they grouped rows that could not exist.
+  { label: "Bash", members: /* @__PURE__ */ new Set() },
+  {
+    label: "Web",
+    members: /* @__PURE__ */ new Set([
+      "web_fetch",
+      "injection_detected"
+    ])
+  },
+  // Membership comes from _kindGroupLabel's `mcp:` prefix branch, not from this set, which is why
+  // it is empty. The entry still has to exist: _renderByKindSection iterates _KIND_GROUPS' labels
+  // (plus 'Other') to decide what to print, so a label _kindGroupLabel returns but that is missing
+  // here does not fall back to 'Other' -- its rows disappear from the table entirely.
+  { label: "MCP", members: /* @__PURE__ */ new Set() },
+  {
+    label: "Compact / Skills",
+    members: /* @__PURE__ */ new Set([
+      "skill_load",
+      "skill_oversized_first_load",
+      "skill_compact_inlined",
+      "skill_heading_tree_inlined"
+    ])
+  },
+  // SOURCE_CONTENT: real rewrites of tool output that remove real bytes (agent report compaction, Grep fold, browser tab dedup, bash/content compression and the handoff pair). The by-source table has shown a 'content' row since the source was added, but the by-kind table had no member set for it, so every one of these kinds printed under 'Other'. The taskoutput: prefix branch in _kindGroupLabel routes here too.
+  {
+    label: "Content",
+    members: /* @__PURE__ */ new Set([
+      "content_compress",
+      "content_retrieve",
+      "agent_report_compact",
+      "agent_report_compact_declined",
+      "browser_tab_dedup",
+      "grep:fold",
+      "read:served_elide",
+      "read:body_fold",
+      "read:markdown_outline",
+      "read:source_skeleton",
+      "handoff_create",
+      "handoff_resolve",
+      "plan_echo_collapse"
+    ])
+  }
+];
+function _kindGroupLabel(kind) {
+  if (kind.startsWith("bash_compress:") || kind.startsWith("bashoutput:")) {
+    return "Bash";
+  }
+  if (kind.startsWith("webfetch:") || kind.startsWith("gdrive:")) {
+    return "Web";
+  }
+  if (kind.startsWith("mcp:")) {
+    return "MCP";
+  }
+  if (kind.startsWith("skill_body:") || kind.startsWith("skill_compact:")) {
+    return "Compact / Skills";
+  }
+  if (kind.startsWith("taskoutput:")) {
+    return "Content";
+  }
+  for (const group of _KIND_GROUPS) {
+    if (group.members.has(kind)) {
+      return group.label;
+    }
+  }
+  return "Other";
+}
+function _groupSeparator(label) {
+  return `${_M}  ${fg(...C.TEXT_DIM)}${label}${RESET}`;
+}
+function _renderByKindSection(stats) {
+  if (stats.by_kind.length === 0) {
+    return [];
+  }
+  const lines = [..._sectionHeader("By kind"), _tableHeader("name")];
+  const { grossBytes, shareBytesDenom, shareTokensDenom } = _computeShareDenominators(stats.by_kind);
+  const kindNames = new Set(stats.by_kind.map((k) => k.kind));
+  const bytesModeKinds = stats.by_kind.filter((k) => k.bytes_mode_only).map((k) => k.kind);
+  function share(k) {
+    if (k.bytes_mode_only) {
+      return k.bytes / shareBytesDenom;
+    }
+    return _absShare(k.bytes, k.tokens, shareBytesDenom, shareTokensDenom);
+  }
+  const byGroup = /* @__PURE__ */ new Map();
+  for (const k of stats.by_kind) {
+    const grp = _kindGroupLabel(k.kind);
+    if (!byGroup.has(grp)) {
+      byGroup.set(grp, []);
+    }
+    byGroup.get(grp).push(k);
+  }
+  for (const grpKinds of byGroup.values()) {
+    grpKinds.sort((a, b) => share(b) - share(a));
+  }
+  const groupLabels = [..._KIND_GROUPS.map((g) => g.label), "Other"];
+  let firstGroup = true;
+  for (const label of groupLabels) {
+    const groupKinds = byGroup.get(label);
+    if (!groupKinds || groupKinds.length === 0) {
+      continue;
+    }
+    if (!firstGroup) {
+      lines.push("");
+    }
+    firstGroup = false;
+    lines.push(_groupSeparator(label));
+    for (const k of groupKinds) {
+      const s = share(k);
+      lines.push(
+        _tableRow({
+          name: k.kind,
+          fraction: _barFraction(k.bytes, grossBytes),
+          bytes: k.bytes,
+          tokens: k.tokens,
+          events: k.events,
+          share: s,
+          bytesModeOnly: k.bytes_mode_only ?? false
+        })
+      );
+    }
+  }
+  if (bytesModeKinds.length > 0) {
+    const names = bytesModeKinds.join(", ");
+    lines.push(`${_M}${fg(...C.TEXT_DIM)}i  ${names} ${_STATS_MESSAGES.bytesModeOnlyNote}${RESET}`);
+  }
+  if (kindNames.has("session_hint") && kindNames.has("session_hint_overhead")) {
+    lines.push(`${_M}${fg(...C.TEXT_DIM)}i  ${_STATS_MESSAGES.sessionHintSplitNote}${RESET}`);
+  }
+  return lines;
+}
+var _SOURCE_COLORS = {
+  image: C.PURPLE,
+  hint: C.BLUE,
+  read: C.GREEN4,
+  compact: C.TEAL,
+  bash: C.ORANGE,
+  web: C.YELLOW,
+  other: C.TEXT_MUTED
+};
+function _sourceColor(source) {
+  const color = _SOURCE_COLORS[source];
+  return color || C.TEXT_MUTED;
+}
+function _renderBySourceSection(stats) {
+  if (!stats.by_source || stats.by_source.length === 0) {
+    return [];
+  }
+  const lines = [..._sectionHeader("By source"), _tableHeader("source")];
+  const { grossBytes, shareBytesDenom, shareTokensDenom } = _computeShareDenominators(stats.by_source);
+  function share(s) {
+    return _absShare(s.bytes, s.tokens, shareBytesDenom, shareTokensDenom);
+  }
+  for (const s of [...stats.by_source].sort((a, b) => share(b) - share(a))) {
+    const s_val = share(s);
+    const color = _sourceColor(s.source);
+    lines.push(
+      _tableRow({
+        name: s.source,
+        fraction: _barFraction(s.bytes, grossBytes),
+        bytes: s.bytes,
+        tokens: s.tokens,
+        events: s.events,
+        share: s_val,
+        namePrefix: `${fg(...color)}\u25CF${RESET} `,
+        nameColor: C.TEXT_PRIMARY
+      })
+    );
+  }
+  return lines;
+}
+function _renderByCommandSection(stats) {
+  if (!stats.by_command || stats.by_command.length === 0) {
+    return [];
+  }
+  const lines = [..._sectionHeader("By command"), _tableHeader("command")];
+  const { grossBytes, shareBytesDenom, shareTokensDenom } = _computeShareDenominators(stats.by_command);
+  function share(c) {
+    return _absShare(c.bytes, c.tokens, shareBytesDenom, shareTokensDenom);
+  }
+  for (const c of [...stats.by_command].sort((a, b) => share(b) - share(a))) {
+    const s_val = share(c);
+    lines.push(
+      _tableRow({
+        name: c.command,
+        fraction: _barFraction(c.bytes, grossBytes),
+        bytes: c.bytes,
+        tokens: c.tokens,
+        events: c.events,
+        share: s_val,
+        nameColor: C.TEXT_PRIMARY
+      })
+    );
+  }
+  return lines;
+}
+function _renderByHarnessSection(stats) {
+  if (!stats.by_harness || stats.by_harness.length < 2) {
+    return [];
+  }
+  const lines = [..._sectionHeader("By harness"), _tableHeader("harness")];
+  const { grossBytes, shareBytesDenom, shareTokensDenom } = _computeShareDenominators(stats.by_harness);
+  function share(h) {
+    return _absShare(h.bytes, h.tokens, shareBytesDenom, shareTokensDenom);
+  }
+  for (const h of [...stats.by_harness].sort((a, b) => share(b) - share(a))) {
+    lines.push(
+      _tableRow({
+        name: h.harness,
+        fraction: _barFraction(h.bytes, grossBytes),
+        bytes: h.bytes,
+        tokens: h.tokens,
+        events: h.events,
+        share: share(h),
+        nameColor: C.TEXT_PRIMARY
+      })
+    );
+  }
+  return lines;
+}
+function _renderByDaySection(stats) {
+  if (stats.by_day.length === 0) {
+    return [];
+  }
+  const lines = [..._sectionHeader("By day"), _tableHeader("date")];
+  function share(d) {
+    return _tokenOrByteShare(d.tokens, d.bytes, stats.totals.tokens, stats.totals.bytes);
+  }
+  for (const d of [...stats.by_day].sort((a, b) => b.date < a.date ? -1 : b.date > a.date ? 1 : 0)) {
+    const s = share(d);
+    lines.push(
+      _tableRow({
+        name: d.date,
+        fraction: s,
+        bytes: d.bytes,
+        tokens: d.tokens,
+        events: d.events,
+        share: s
+      })
+    );
+  }
+  return lines;
+}
+var _PROJECT_COLORS = [C.PURPLE, C.TEAL, C.BLUE, C.GREEN4, C.TEXT_MUTED];
+function _hashColor(hashStr) {
+  let n = 0;
+  for (const c of hashStr) {
+    n += c.charCodeAt(0);
+  }
+  return _PROJECT_COLORS[n % _PROJECT_COLORS.length] ?? C.TEXT_MUTED;
+}
+function _renderByProjectSection(stats) {
+  if (stats.by_project.length === 0) {
+    return [];
+  }
+  const lines = [..._sectionHeader(`By project (top ${stats.by_project.length})`), _tableHeader("project")];
+  function share(p) {
+    return _tokenOrByteShare(p.tokens, p.bytes, stats.totals.tokens, stats.totals.bytes);
+  }
+  for (const p of [...stats.by_project].sort((a, b) => share(b) - share(a))) {
+    const s = share(p);
+    const color = _hashColor(p.hash);
+    lines.push(
+      _tableRow({
+        name: p.project,
+        fraction: s,
+        bytes: p.bytes,
+        tokens: p.tokens,
+        events: p.events,
+        share: s,
+        namePrefix: `${fg(...color)}\u25CF${RESET} `,
+        nameColor: C.TEXT_PRIMARY
+      })
+    );
+    lines.push(`${_M}  ${fg(...C.TEXT_DIM)}\u2514\u2500 ${p.hash}  ${displaySafeText(stripAnsi(p.path))}${RESET}`);
+  }
+  return lines;
+}
+function _renderInsightsSection(stats) {
+  const lines = [..._sectionHeader("Insights")];
+  const bullet = `${fg(...C.GREEN3)}\u25B8${RESET}`;
+  function dim(s) {
+    return `${fg(...C.TEXT_MUTED)}${s}${RESET}`;
+  }
+  const savingKinds = stats.by_kind.filter((k) => k.bytes > 0);
+  const topKind = savingKinds.reduce((max, k) => k.bytes > (max?.bytes || -Infinity) ? k : max, savingKinds[0]);
+  if (topKind) {
+    const share = stats.totals.bytes > 0 ? topKind.bytes / stats.totals.bytes : 0;
+    lines.push(
+      `${_M}${bullet} ${dim(_STATS_MESSAGES.insights.biggestSaver)}${fg(...C.TEXT_PRIMARY)}${topKind.kind}${RESET}${dim(" \u2014 ")}${fg(...C.GREEN5)}${_fmtPct(share)}${RESET}${dim(` of saved data across ${topKind.events.toLocaleString()} events`)}`
+    );
+  }
+  const topDay = stats.by_day.reduce((max, d) => d.events > (max?.events || -Infinity) ? d : max, stats.by_day[0]);
+  if (topDay) {
+    lines.push(
+      `${_M}${bullet} ${dim(_STATS_MESSAGES.insights.mostActive)}${fg(...C.TEXT_PRIMARY)}${topDay.date}${RESET}${dim(" \u2014 ")}${topDay.events.toLocaleString()} events, ${_fmtBytes(topDay.bytes)}${dim(" saved")}`
+    );
+  }
+  const tokenKinds = stats.by_kind.filter((k) => !k.bytes_mode_only && k.tokens > 0);
+  const topToken = tokenKinds.reduce((max, k) => k.tokens > (max?.tokens || -Infinity) ? k : max, tokenKinds[0]);
+  if (topToken) {
+    lines.push(
+      `${_M}${bullet} ${dim(_STATS_MESSAGES.insights.tokenLeader)}${fg(...C.TEXT_PRIMARY)}${topToken.kind}${RESET}${dim(" \u2014 ")}${_fmtTokens(topToken.tokens)}${dim(` saved in ${topToken.events.toLocaleString()} events`)}`
+    );
+  }
+  if ((stats.by_command?.length ?? 0) === 0) {
+    const hintSource = stats.by_source?.find((s) => s.source === "hint");
+    if (hintSource && hintSource.events > 0) {
+      lines.push(
+        `${_M}${fg(...C.YELLOW)}\u25B8${RESET} ${dim("0 direct commands   ")}${fg(...C.TEXT_PRIMARY)}${hintSource.events.toLocaleString()}${RESET}${dim(" hint(s) fired but not acted on \u2014 run symbol/read/section/semantic/outline/skeleton directly to capture these savings")}`
+      );
+    }
+  }
+  return lines;
+}
+function _renderHeader(stats) {
+  let line = `${_M}${fg(...C.TEXT_BRIGHT)}token-goat${RESET}`;
+  if (stats.version) {
+    line += `  ${fg(...C.TEXT_MUTED)}v${stats.version}${RESET}`;
+  }
+  if (stats.window_label) {
+    line += `  ${fg(...C.TEXT_DIM)}\xB7  ${stats.window_label}${RESET}`;
+  }
+  return [line];
+}
+function _renderShortHint() {
+  return [
+    "",
+    `${_M}${fg(...C.TEXT_MUTED)}Run 'token-goat stats --full' for the full breakdown (by source, by command, by day).${RESET}`
+  ];
+}
+function renderStats(stats, opts) {
+  if (opts?.short) {
+    const sections2 = [_renderHeader(stats), _renderKpiSection(stats), _renderShortHint(), [""]];
+    return sections2.flatMap((s) => s).join("\n");
+  }
+  const sections = [
+    _renderHeader(stats),
+    _renderKpiSection(stats),
+    _renderByKindSection(stats),
+    _renderBySourceSection(stats),
+    _renderByCommandSection(stats),
+    _renderByHarnessSection(stats),
+    _renderByDaySection(stats),
+    _renderByProjectSection(stats),
+    _renderInsightsSection(stats),
+    [""]
+  ];
+  return sections.flatMap((s) => s).join("\n");
+}
+
+// src/stats.ts
+var HARNESS_UNRECORDED = "unrecorded (pre-2.8.1)";
+var PRICING_VERSION_UNRECORDED = "unrecorded (pre-tg_version column)";
+function hasMixedPricingEras(summary) {
+  return Object.keys(summary.by_pricing_version).length > 1;
+}
+var SOURCE_IMAGE = "image";
+var SOURCE_HINT = "hint";
+var SOURCE_READ = "read";
+var SOURCE_BASH = "bash";
+var SOURCE_WEB = "web";
+var SOURCE_MCP = "mcp";
+var SOURCE_SKILL = "skill";
+var SOURCE_CONTENT = "content";
+var SOURCE_OTHER = "other";
+var _BYTES_MODE_ONLY_KINDS = /* @__PURE__ */ new Set(["webfetch_image", "gdrive_image"]);
+var COUNT_ONLY_KINDS = /* @__PURE__ */ new Set(["secret_redacted"]);
+function savedTokensFromBytes(bytes) {
+  return Math.round(Math.max(0, bytes) / 4);
+}
+var KIND_TO_SOURCE = {
+  image_shrink: SOURCE_IMAGE,
+  image_shrink_cache_hit: SOURCE_IMAGE,
+  image_shrink_skipped: SOURCE_IMAGE,
+  image_ocr: SOURCE_IMAGE,
+  webfetch_image: SOURCE_IMAGE,
+  gdrive_image: SOURCE_IMAGE,
+  session_hint: SOURCE_HINT,
+  session_hint_suppressed: SOURCE_HINT,
+  diff_hint: SOURCE_HINT,
+  evidence_cache_hit: SOURCE_HINT,
+  structured_file_hint: SOURCE_HINT,
+  predictive_prefetch_hit: SOURCE_HINT,
+  grep_dedup_hint: SOURCE_HINT,
+  glob_dedup_hint: SOURCE_HINT,
+  write_rewrite_hint: SOURCE_HINT,
+  websearch_dedup_hint: SOURCE_HINT,
+  large_file_hint_followed: SOURCE_HINT,
+  large_file_hint_ignored: SOURCE_HINT,
+  read_count_deny: SOURCE_HINT,
+  read_served_deny: SOURCE_HINT,
+  // hooks_read.ts's subagent first-read markdown deny (hints.subagent_markdown_first_read_deny, off by default). Always recorded at 0 bytes / 0 tokens: no first-read deny of this shape exists in the transcript corpus, so its abandoned/substituted/shell-read/retried rates are unknown and can only be borrowed from the re-read heading-tree census. Booking withheld bytes against borrowed rates would claim a saving this path cannot back up. The kind exists to make the intervention countable in session-audit, not to claim a win.
+  subagent_markdown_first_read_deny: SOURCE_HINT,
+  read_replacement: SOURCE_READ,
+  section_replacement: SOURCE_READ,
+  symbol_read: SOURCE_READ,
+  section_read: SOURCE_READ,
+  stub_view: SOURCE_READ,
+  symbol_lookup: SOURCE_READ,
+  semantic_search: SOURCE_READ,
+  map_lookup: SOURCE_READ,
+  changed_lookup: SOURCE_READ,
+  outline: SOURCE_READ,
+  exports: SOURCE_READ,
+  imports: SOURCE_READ,
+  dep_docs: SOURCE_READ,
+  csv_query: SOURCE_READ,
+  csv_profile: SOURCE_READ,
+  pdf_extract: SOURCE_READ,
+  pdf_locate: SOURCE_READ,
+  pdf_outline: SOURCE_READ,
+  pdf_meta: SOURCE_READ,
+  xlsx_sheets: SOURCE_READ,
+  xlsx_head: SOURCE_READ,
+  xlsx_range: SOURCE_READ,
+  xlsx_query: SOURCE_READ,
+  xlsx_columns: SOURCE_READ,
+  pptx_outline: SOURCE_READ,
+  pptx_slide: SOURCE_READ,
+  pptx_notes: SOURCE_READ,
+  pptx_text: SOURCE_READ,
+  docx_outline: SOURCE_READ,
+  docx_tables: SOURCE_READ,
+  docx_text: SOURCE_READ,
+  transcript_outline: SOURCE_READ,
+  transcript: SOURCE_READ,
+  video_chapters: SOURCE_READ,
+  image_meta: SOURCE_READ,
+  image_text: SOURCE_READ,
+  coverage_report_gaps: SOURCE_READ,
+  json_query: SOURCE_READ,
+  json_outline: SOURCE_READ,
+  yaml_query: SOURCE_READ,
+  yaml_outline: SOURCE_READ,
+  xml_query: SOURCE_READ,
+  xml_outline: SOURCE_READ,
+  html_query: SOURCE_READ,
+  html_outline: SOURCE_READ,
+  openapi_op: SOURCE_READ,
+  openapi_outline: SOURCE_READ,
+  zip_list: SOURCE_READ,
+  zip_read: SOURCE_READ,
+  sqlite_query: SOURCE_READ,
+  sqlite_schema: SOURCE_READ,
+  sqlite_tables: SOURCE_READ,
+  conflicts: SOURCE_READ,
+  brief_view: SOURCE_READ,
+  session_outline: SOURCE_READ,
+  session_slice: SOURCE_READ,
+  gdrive_sections: SOURCE_READ,
+  pr_slice: SOURCE_READ,
+  compact_doc: SOURCE_READ,
+  note_read: SOURCE_READ,
+  note_list: SOURCE_READ,
+  // note-add is a write (like insert-section/replace, which record no stat at all -- neither
+  // has a "full source it replaces" savings concept). It still gets an event-only entry here
+  // (no bytesSaved/tokensSaved argument, same as skill_load) purely so `token-goat note-add`
+  // usage is visible in `token-goat stats --full` at all -- SOURCE_OTHER, not SOURCE_READ,
+  // since it is not a token-savings substitute for a read.
+  note_write: SOURCE_OTHER,
+  web_fetch: SOURCE_WEB,
+  injection_detected: SOURCE_WEB,
+  skill_load: SOURCE_SKILL,
+  skill_oversized_first_load: SOURCE_SKILL,
+  // Cold first load of an oversized skill where preSkillHandler inlined the compact slice in its reply instead of pointing at `skill-body --compact`. Unlike its skill_oversized_first_load sibling (event-only, 0 bytes -- the pointer deny saves nothing by itself, the follow-up command does) this one records real savings: the full body never landed, the slice did, so bytesSaved is body minus slice.
+  skill_compact_inlined: SOURCE_SKILL,
+  // Cold first load of an oversized skill with no compact marker at all, where preSkillHandler inlined a heading tree in its reply instead of letting the whole body fall through. Same shape as skill_compact_inlined: real savings, bytesSaved is body minus the rendered tree.
+  skill_heading_tree_inlined: SOURCE_SKILL,
+  secret_redacted: SOURCE_OTHER,
+  // Fail-soft diagnostic counters from hooks_edit.ts: they record that a side task threw, never a byte saving, so "other" is the right home. Listed explicitly rather than left to kindToSource()'s fallback so the registration guard can tell a deliberate placement from an unregistered kind.
+  dirty_queue_append_failed: SOURCE_OTHER,
+  worker_healthcheck_failed: SOURCE_OTHER,
+  known_root_record_failed: SOURCE_OTHER,
+  // Measurement of what a compaction produced (hooks_compact.ts postCompactHandler): summary size and how many manifest paths survived into it. SOURCE_OTHER and always recorded at (0, 0) -- the summary was written whether or not token-goat was watching, so there is no counterfactual in which those bytes were saved. Filing it anywhere with a savings total would credit token-goat for the whole summary, which is the accounting mistake this registry exists to prevent.
+  compact_summary: SOURCE_OTHER,
+  // Envelope compaction of an oversized subagent report (hooks_agent_spawn.ts). SOURCE_CONTENT, not SOURCE_HINT: the handler's sibling session_hint entry is advisory (it only appends a recall pointer and genuinely saves nothing), whereas this kind records a real rewrite with real bytes removed, so filing it under the advisory bucket would understate the compaction and repeat the zero-savings desync this registry keeps getting bitten by.
+  agent_report_compact: SOURCE_CONTENT,
+  // Decline counterpart to agent_report_compact: the fence-collapse net-benefit gate ran and found at least one over-long fence, but declined to rewrite because net savings did not clear the notice cost. Always recorded at (0, 0) -- see the recordStat call site -- so it never contributes to any savings total; it exists purely to make gate hit-rate and near-misses visible instead of the decline being invisible.
+  agent_report_compact_declined: SOURCE_CONTENT,
+  content_compress: SOURCE_CONTENT,
+  // Verbatim-repeat collapse of a browser tool's "Tab Context:" text block (hooks_browser_image.ts postBrowserImageHandler). SOURCE_CONTENT for the same reason as agent_report_compact above: it is a real rewrite with real bytes removed, not an advisory nudge. Deliberately not SOURCE_IMAGE -- it shares a handler with image_shrink but collapses text, and folding text bytes into the image ledger is the two-units-under-one-label mistake this file's image_shrink entry was just fixed for.
+  browser_tab_dedup: SOURCE_CONTENT,
+  // Collapse of the plan echo in an approved ExitPlanMode result (hooks_exitplanmode.ts). SOURCE_CONTENT for the same reason as agent_report_compact: real bytes removed from a tool result, not an advisory nudge. The handler shipped for releases emitting this rewrite and recording nothing at all, so the mechanism was invisible in `stats` and its net benefit could not be checked against the gate that admits it.
+  plan_echo_collapse: SOURCE_CONTENT,
+  // Lossless re-layout of Grep content-mode output (hooks_grep.ts foldGrepContentHandler). SOURCE_CONTENT, not SOURCE_HINT, for the same reason as agent_report_compact above: its sibling grep_dedup_hint is advisory and saves nothing directly, whereas this is a real rewrite with real bytes removed. Filing it under the advisory bucket would silently add non-hint savings to hint_stats.ts's savedBytes (which reads by_source[SOURCE_HINT] wholesale) and overstate the hint ledger's net benefit.
+  "grep:fold": SOURCE_CONTENT,
+  // Withholding of already-served stretches from a completed Read (hooks_read.ts
+  // elideAlreadyServedLines). SOURCE_CONTENT, not SOURCE_HINT, for the same reason as
+  // grep:fold above: its siblings read_count_deny and read_served_deny are decisions about
+  // whether a read happens at all, whereas this is a rewrite of a result that did happen,
+  // with real bytes removed from it. Filing it under the advisory bucket would add non-hint
+  // savings to hint_stats.ts's savedBytes, which reads by_source[SOURCE_HINT] wholesale.
+  "read:served_elide": SOURCE_CONTENT,
+  // Same bucket and same reasoning as read:served_elide directly above: a rewrite of a Read that did happen, with real bytes removed, not an advisory about whether to read at all.
+  "read:body_fold": SOURCE_CONTENT,
+  // Same bucket and same reasoning as read:body_fold directly above: a coarser sibling rewrite of a large untargeted markdown Read (hooks_read.ts foldMarkdownOutline) that replaces the body with a heading tree plus preamble, with real bytes removed, not an advisory about whether to read at all.
+  "read:markdown_outline": SOURCE_CONTENT,
+  // Same bucket and same reasoning as read:markdown_outline directly above, on source instead of prose: the structural-skeleton replacement of a large untargeted source Read (hooks_read.ts foldSourceSkeleton), with real bytes removed, not an advisory about whether to read at all.
+  "read:source_skeleton": SOURCE_CONTENT,
+  content_retrieve: SOURCE_CONTENT,
+  handoff_create: SOURCE_CONTENT,
+  handoff_resolve: SOURCE_CONTENT
+};
+var KIND_PREFIX_TO_SOURCE = [
+  ["bash_compress:", SOURCE_BASH],
+  ["webfetch:", SOURCE_WEB],
+  ["gdrive:", SOURCE_WEB],
+  ["mcp:", SOURCE_MCP],
+  ["skill_body:", SOURCE_SKILL],
+  ["skill_compact:", SOURCE_SKILL],
+  ["bashoutput:", SOURCE_BASH],
+  ["taskoutput:", SOURCE_CONTENT]
+];
+var COMMAND_KINDS = {
+  symbol: /* @__PURE__ */ new Set(["symbol_lookup"]),
+  read: /* @__PURE__ */ new Set(["read_replacement"]),
+  section: /* @__PURE__ */ new Set(["section_replacement", "section_read"]),
+  semantic: /* @__PURE__ */ new Set(["semantic_search"]),
+  outline: /* @__PURE__ */ new Set(["outline"]),
+  exports: /* @__PURE__ */ new Set(["exports"]),
+  imports: /* @__PURE__ */ new Set(["imports"]),
+  skeleton: /* @__PURE__ */ new Set(["stub_view"]),
+  refs: /* @__PURE__ */ new Set(["symbol_read"]),
+  map: /* @__PURE__ */ new Set(["map_lookup"]),
+  changed: /* @__PURE__ */ new Set(["changed_lookup"]),
+  "dep-docs": /* @__PURE__ */ new Set(["dep_docs"]),
+  "csv-query": /* @__PURE__ */ new Set(["csv_query"]),
+  "csv-profile": /* @__PURE__ */ new Set(["csv_profile"]),
+  "pdf-extract": /* @__PURE__ */ new Set(["pdf_extract"]),
+  "pdf-locate": /* @__PURE__ */ new Set(["pdf_locate"]),
+  "pdf-outline": /* @__PURE__ */ new Set(["pdf_outline"]),
+  "pdf-meta": /* @__PURE__ */ new Set(["pdf_meta"]),
+  "xlsx-sheets": /* @__PURE__ */ new Set(["xlsx_sheets"]),
+  "xlsx-head": /* @__PURE__ */ new Set(["xlsx_head"]),
+  "xlsx-range": /* @__PURE__ */ new Set(["xlsx_range"]),
+  "xlsx-query": /* @__PURE__ */ new Set(["xlsx_query"]),
+  "xlsx-columns": /* @__PURE__ */ new Set(["xlsx_columns"]),
+  "pptx-outline": /* @__PURE__ */ new Set(["pptx_outline"]),
+  "pptx-slide": /* @__PURE__ */ new Set(["pptx_slide"]),
+  "pptx-notes": /* @__PURE__ */ new Set(["pptx_notes"]),
+  "pptx-text": /* @__PURE__ */ new Set(["pptx_text"]),
+  "docx-outline": /* @__PURE__ */ new Set(["docx_outline"]),
+  "docx-tables": /* @__PURE__ */ new Set(["docx_tables"]),
+  "docx-text": /* @__PURE__ */ new Set(["docx_text"]),
+  "transcript-outline": /* @__PURE__ */ new Set(["transcript_outline"]),
+  transcript: /* @__PURE__ */ new Set(["transcript"]),
+  "video-chapters": /* @__PURE__ */ new Set(["video_chapters"]),
+  "image-meta": /* @__PURE__ */ new Set(["image_meta"]),
+  "image-text": /* @__PURE__ */ new Set(["image_text"]),
+  "coverage-report-gaps": /* @__PURE__ */ new Set(["coverage_report_gaps"]),
+  "json-query": /* @__PURE__ */ new Set(["json_query"]),
+  "json-outline": /* @__PURE__ */ new Set(["json_outline"]),
+  "yaml-query": /* @__PURE__ */ new Set(["yaml_query"]),
+  "yaml-outline": /* @__PURE__ */ new Set(["yaml_outline"]),
+  "xml-query": /* @__PURE__ */ new Set(["xml_query"]),
+  "xml-outline": /* @__PURE__ */ new Set(["xml_outline"]),
+  "html-query": /* @__PURE__ */ new Set(["html_query"]),
+  "html-outline": /* @__PURE__ */ new Set(["html_outline"]),
+  "openapi-op": /* @__PURE__ */ new Set(["openapi_op"]),
+  "openapi-outline": /* @__PURE__ */ new Set(["openapi_outline"]),
+  "zip-list": /* @__PURE__ */ new Set(["zip_list"]),
+  "zip-read": /* @__PURE__ */ new Set(["zip_read"]),
+  "sqlite-query": /* @__PURE__ */ new Set(["sqlite_query"]),
+  "sqlite-schema": /* @__PURE__ */ new Set(["sqlite_schema"]),
+  "sqlite-tables": /* @__PURE__ */ new Set(["sqlite_tables"]),
+  conflicts: /* @__PURE__ */ new Set(["conflicts"]),
+  brief: /* @__PURE__ */ new Set(["brief_view"]),
+  "session-outline": /* @__PURE__ */ new Set(["session_outline"]),
+  "session-slice": /* @__PURE__ */ new Set(["session_slice"]),
+  "gdrive-sections": /* @__PURE__ */ new Set(["gdrive_sections"]),
+  "pr-slice": /* @__PURE__ */ new Set(["pr_slice"]),
+  "compact-doc": /* @__PURE__ */ new Set(["compact_doc"]),
+  "note-add": /* @__PURE__ */ new Set(["note_write"]),
+  "note-get": /* @__PURE__ */ new Set(["note_read"]),
+  "note-list": /* @__PURE__ */ new Set(["note_list"]),
+  "compress-text": /* @__PURE__ */ new Set(["content_compress"]),
+  retrieve: /* @__PURE__ */ new Set(["content_retrieve"]),
+  "handoff-create": /* @__PURE__ */ new Set(["handoff_create"]),
+  "handoff-resolve": /* @__PURE__ */ new Set(["handoff_resolve"]),
+  npm: /* @__PURE__ */ new Set([
+    "bash_compress:npm_install",
+    "bash_compress:npm_ci",
+    "bash_compress:npm_audit",
+    "bash_compress:npm_ls",
+    "bash_compress:npm_outdated",
+    "bash_compress:npx"
+  ])
+};
+var OVERHEAD_SUFFIX = "_overhead";
+function kindToSource(kind) {
+  const src = KIND_TO_SOURCE[kind];
+  if (src !== void 0) return src;
+  if (kind.endsWith(OVERHEAD_SUFFIX)) {
+    const base = kind.slice(0, -OVERHEAD_SUFFIX.length);
+    const baseSrc = KIND_TO_SOURCE[base];
+    if (baseSrc !== void 0) return baseSrc;
+  }
+  for (const [prefix, prefixSrc] of KIND_PREFIX_TO_SOURCE) {
+    if (kind.startsWith(prefix)) return prefixSrc;
+  }
+  return SOURCE_OTHER;
+}
+function toLocalDateKey(d) {
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function formatLocalTimestamp(d) {
+  const hours = String(d.getHours()).padStart(2, "0");
+  const minutes = String(d.getMinutes()).padStart(2, "0");
+  const seconds = String(d.getSeconds()).padStart(2, "0");
+  return `${toLocalDateKey(d)}T${hours}:${minutes}:${seconds}`;
+}
+function zeroBucket() {
+  return { events: 0, bytes_saved: 0, tokens_saved: 0 };
+}
+function incBucket(bucket, bytesSaved, tokensSaved) {
+  bucket.events += 1;
+  bucket.bytes_saved += bytesSaved;
+  bucket.tokens_saved += tokensSaved;
+}
+var GLOBAL_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS stats (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  ts INTEGER NOT NULL,
+  kind TEXT NOT NULL,
+  tokens_saved INTEGER NOT NULL DEFAULT 0,
+  bytes_saved INTEGER NOT NULL DEFAULT 0,
+  detail TEXT,
+  harness TEXT,
+  traceparent TEXT,
+  tg_version TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_stats_ts ON stats(ts);
+CREATE INDEX IF NOT EXISTS idx_stats_kind ON stats(kind);
+-- Day-granularity rollup of stats rows older than STATS_RETENTION_DAYS -- see
+-- rollupAndPruneStats's doc comment for why raw rows are pruned instead of kept forever, and
+-- summarize()'s rollup merge for how a --window-days report spanning pruned days still gets a
+-- correct total. Deliberately day+kind+harness+tg_version, not day+kind alone: those are exactly
+-- the dimensions summarize() breaks totals out by, and collapsing any of them here would make an
+-- old --window-days report under-report a breakdown a recent one still shows in full.
+CREATE TABLE IF NOT EXISTS stats_daily_rollup (
+  day TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  harness TEXT NOT NULL DEFAULT '',
+  tg_version TEXT NOT NULL DEFAULT '',
+  events INTEGER NOT NULL DEFAULT 0,
+  bytes_saved INTEGER NOT NULL DEFAULT 0,
+  tokens_saved INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (day, kind, harness, tg_version)
+);
+CREATE INDEX IF NOT EXISTS idx_stats_daily_rollup_day ON stats_daily_rollup(day);
+-- Single-row (id=1, same pattern as embedding_provenance in db.ts) throttle so the rollup+prune
+-- pass -- an aggregate scan over the whole stats table -- runs at most once per
+-- STATS_ROLLUP_INTERVAL_MS regardless of how often recordStat() itself is called (many times a
+-- minute during active use).
+CREATE TABLE IF NOT EXISTS stats_maintenance (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  last_rollup_ts INTEGER NOT NULL DEFAULT 0
+);
+CREATE TABLE IF NOT EXISTS unmapped_tools (
+  harness TEXT NOT NULL,
+  tool_name TEXT NOT NULL,
+  event_name TEXT NOT NULL,
+  near_miss TEXT,
+  first_seen INTEGER NOT NULL,
+  last_seen INTEGER NOT NULL,
+  hits INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (harness, tool_name, event_name)
+);
+`;
+var _globalSchemaApplied = /* @__PURE__ */ new Set();
+registerReset(() => _globalSchemaApplied.clear());
+function migrateGlobalSchema(db) {
+  try {
+    db.exec("ALTER TABLE stats ADD COLUMN harness TEXT");
+  } catch (err) {
+    if (!(err instanceof Error) || !/duplicate column/i.test(err.message)) throw err;
+  }
+  try {
+    db.exec("ALTER TABLE stats ADD COLUMN traceparent TEXT");
+  } catch (err) {
+    if (!(err instanceof Error) || !/duplicate column/i.test(err.message)) throw err;
+  }
+  try {
+    db.exec("ALTER TABLE stats ADD COLUMN tg_version TEXT");
+  } catch (err) {
+    if (!(err instanceof Error) || !/duplicate column/i.test(err.message)) throw err;
+  }
+}
+var _harnessColumnByDb = /* @__PURE__ */ new WeakMap();
+function statsHasHarnessColumn(db) {
+  const cached = _harnessColumnByDb.get(db);
+  if (cached !== void 0) return cached;
+  let present;
+  try {
+    present = db.prepare("PRAGMA table_info(stats)").all().some(
+      (c) => c.name === "harness"
+    );
+  } catch {
+    present = false;
+  }
+  _harnessColumnByDb.set(db, present);
+  return present;
+}
+var _traceparentColumnByDb = /* @__PURE__ */ new WeakMap();
+function statsHasTraceparentColumn(db) {
+  const cached = _traceparentColumnByDb.get(db);
+  if (cached !== void 0) return cached;
+  let present;
+  try {
+    present = db.prepare("PRAGMA table_info(stats)").all().some(
+      (c) => c.name === "traceparent"
+    );
+  } catch {
+    present = false;
+  }
+  _traceparentColumnByDb.set(db, present);
+  return present;
+}
+var _versionColumnByDb = /* @__PURE__ */ new WeakMap();
+function statsHasVersionColumn(db) {
+  const cached = _versionColumnByDb.get(db);
+  if (cached !== void 0) return cached;
+  let present;
+  try {
+    present = db.prepare("PRAGMA table_info(stats)").all().some(
+      (c) => c.name === "tg_version"
+    );
+  } catch {
+    present = false;
+  }
+  _versionColumnByDb.set(db, present);
+  return present;
+}
+function getGlobalDb(homeDir) {
+  const basePath = homeDir ? dataDirForHome(homeDir) : dataDir();
+  const dbPath = path3.join(basePath, "global.db");
+  const db = getDb(dbPath);
+  if (!_globalSchemaApplied.has(dbPath)) {
+    db.exec(GLOBAL_SCHEMA_SQL);
+    migrateGlobalSchema(db);
+    _globalSchemaApplied.add(dbPath);
+  }
+  return db;
+}
+var STATS_RETENTION_DAYS = 180;
+var STATS_ROLLUP_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+function rollupAndPruneStats(db, retentionDays = STATS_RETENTION_DAYS) {
+  try {
+    const cutoffTs = Math.floor(Date.now() / 1e3) - retentionDays * 86400;
+    const run = db.transaction((cutoff) => {
+      db.prepare(
+        `INSERT INTO stats_daily_rollup (day, kind, harness, tg_version, events, bytes_saved, tokens_saved)
+         SELECT strftime('%Y-%m-%d', ts, 'unixepoch', 'localtime') AS day,
+                kind,
+                COALESCE(harness, '') AS harness,
+                COALESCE(tg_version, '') AS tg_version,
+                COUNT(*), SUM(bytes_saved), SUM(tokens_saved)
+         FROM stats
+         WHERE ts < ?
+         GROUP BY day, kind, harness, tg_version
+         ON CONFLICT(day, kind, harness, tg_version) DO UPDATE SET
+           events = events + excluded.events,
+           bytes_saved = bytes_saved + excluded.bytes_saved,
+           tokens_saved = tokens_saved + excluded.tokens_saved`
+      ).run(cutoff);
+      db.prepare(`DELETE FROM stats WHERE ts < ?`).run(cutoff);
+    });
+    run(cutoffTs);
+  } catch {
+  }
+}
+function maybeRunStatsMaintenance(db) {
+  try {
+    const now = Date.now();
+    const row = db.prepare(`SELECT last_rollup_ts FROM stats_maintenance WHERE id = 1`).get();
+    const last = row?.last_rollup_ts ?? 0;
+    if (now - last < STATS_ROLLUP_INTERVAL_MS) return;
+    db.prepare(
+      `INSERT INTO stats_maintenance (id, last_rollup_ts) VALUES (1, ?)
+       ON CONFLICT(id) DO UPDATE SET last_rollup_ts = excluded.last_rollup_ts`
+    ).run(now);
+    rollupAndPruneStats(db);
+  } catch {
+  }
+}
+function noStatsMessage(windowDays, homeDir) {
+  if (windowDays <= 0) return "No stats recorded yet.";
+  const db = getGlobalDb(homeDir);
+  let total = db.prepare("SELECT COUNT(*) as c FROM stats").get().c;
+  try {
+    const rollupTable = db.prepare(`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'stats_daily_rollup'`).get();
+    if (rollupTable !== void 0) {
+      const rolledUp = db.prepare("SELECT COALESCE(SUM(events), 0) as c FROM stats_daily_rollup").get().c;
+      total += rolledUp;
+    }
+  } catch {
+  }
+  if (total === 0) return "No stats recorded yet.";
+  return `No stats in the last ${countNoun(windowDays, "day")} (${total} recorded outside this window; use --window-days 0 for all time).`;
+}
+function recordStat(kind, bytesSaved = 0, tokensSaved = 0, _testDb, detail, traceparent) {
+  try {
+    const db = _testDb ?? getGlobalDb();
+    const ts = Math.floor(Date.now() / 1e3);
+    const tp = traceparent ?? process.env["TRACEPARENT"] ?? process.env["traceparent"] ?? null;
+    const cols = ["ts", "kind", "bytes_saved", "tokens_saved", "detail"];
+    const vals = [ts, kind, bytesSaved, tokensSaved, detail ?? null];
+    if (statsHasHarnessColumn(db)) {
+      cols.push("harness");
+      vals.push(getHarnessName());
+    }
+    if (statsHasTraceparentColumn(db)) {
+      cols.push("traceparent");
+      vals.push(tp);
+    }
+    if (statsHasVersionColumn(db)) {
+      cols.push("tg_version");
+      vals.push(VERSION);
+    }
+    db.prepare(
+      `INSERT INTO stats (${cols.join(", ")}) VALUES (${cols.map(() => "?").join(", ")})`
+    ).run(...vals);
+    maybeRunStatsMaintenance(db);
+  } catch {
+  }
+}
+var MAX_TOOL_NAME_CHARS = 200;
+function recordUnmappedTool(toolName, eventName, nearMiss, _testDb) {
+  try {
+    if (!toolName) return;
+    const db = _testDb ?? getGlobalDb();
+    const now = Math.floor(Date.now() / 1e3);
+    db.prepare(
+      `INSERT INTO unmapped_tools (harness, tool_name, event_name, near_miss, first_seen, last_seen, hits)
+       VALUES (?, ?, ?, ?, ?, ?, 1)
+       ON CONFLICT(harness, tool_name, event_name) DO UPDATE SET
+         hits = hits + 1,
+         last_seen = excluded.last_seen,
+         near_miss = excluded.near_miss`
+    ).run(getHarnessName(), toolName.slice(0, MAX_TOOL_NAME_CHARS), eventName, nearMiss, now, now);
+  } catch {
+  }
+}
+function readUnmappedTools(dbPath, homeDir) {
+  try {
+    const db = dbPath ? getDb(dbPath) : getGlobalDb(homeDir);
+    return db.prepare(
+      "SELECT harness, tool_name, event_name, near_miss, hits, last_seen FROM unmapped_tools ORDER BY hits DESC, tool_name ASC"
+    ).all();
+  } catch {
+    return [];
+  }
+}
+function summarize(windowDays = 30, testDb, homeDir) {
+  const t0 = Date.now();
+  const sinceTs = windowDays > 0 ? Math.floor((Date.now() - windowDays * 24 * 60 * 60 * 1e3) / 1e3) : null;
+  const byKind = {};
+  const byDay = {};
+  const byHarness = {};
+  const byPricingVersion = {};
+  let totalEvents = 0;
+  let totalBytes = 0;
+  let totalTokens = 0;
+  const db = testDb ?? getGlobalDb(homeDir);
+  const hasHarness = statsHasHarnessColumn(db);
+  const hasVersion = statsHasVersionColumn(db);
+  const cols = [
+    "ts",
+    "kind",
+    "bytes_saved",
+    "tokens_saved",
+    ...hasHarness ? ["harness"] : [],
+    ...hasVersion ? ["tg_version"] : []
+  ].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 tsToDateCache = {};
+  const counts = {};
+  for (const row of rows2) {
+    const bytesSaved = row.bytes_saved ?? 0;
+    const recorded = row.tokens_saved ?? 0;
+    const kind = row.kind;
+    const isCount = COUNT_ONLY_KINDS.has(kind);
+    if (isCount) counts[kind] = (counts[kind] ?? 0) + recorded;
+    const tokensSaved = isCount ? 0 : recorded;
+    const tsRaw = row.ts;
+    if (tsRaw === void 0) continue;
+    const ts = tsRaw;
+    totalEvents += 1;
+    totalBytes += bytesSaved;
+    totalTokens += tokensSaved;
+    if (!byKind[kind]) {
+      byKind[kind] = zeroBucket();
+    }
+    incBucket(byKind[kind], bytesSaved, tokensSaved);
+    const dateKey = tsToDateCache[ts] || toLocalDateKey(new Date(ts * 1e3));
+    tsToDateCache[ts] = dateKey;
+    if (!byDay[dateKey]) {
+      byDay[dateKey] = zeroBucket();
+    }
+    incBucket(byDay[dateKey], bytesSaved, tokensSaved);
+    const harness = row.harness || HARNESS_UNRECORDED;
+    if (!byHarness[harness]) {
+      byHarness[harness] = zeroBucket();
+    }
+    incBucket(byHarness[harness], bytesSaved, tokensSaved);
+    const pricingVersion = row.tg_version || PRICING_VERSION_UNRECORDED;
+    if (!byPricingVersion[pricingVersion]) {
+      byPricingVersion[pricingVersion] = zeroBucket();
+    }
+    incBucket(byPricingVersion[pricingVersion], bytesSaved, tokensSaved);
+  }
+  try {
+    const rollupTable = db.prepare(`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'stats_daily_rollup'`).get();
+    if (rollupTable !== void 0) {
+      const sinceDayKey = sinceTs !== null ? toLocalDateKey(new Date(sinceTs * 1e3)) : null;
+      const rollupRows = sinceDayKey !== null ? db.prepare(`SELECT day, kind, harness, tg_version, events, bytes_saved, tokens_saved FROM stats_daily_rollup WHERE day >= ?`).all(sinceDayKey) : db.prepare(`SELECT day, kind, harness, tg_version, events, bytes_saved, tokens_saved FROM stats_daily_rollup`).all();
+      const addBucket = (bucket, events, bytesSaved, tokensSaved) => {
+        bucket.events += events;
+        bucket.bytes_saved += bytesSaved;
+        bucket.tokens_saved += tokensSaved;
+      };
+      for (const r of rollupRows) {
+        const isCount = COUNT_ONLY_KINDS.has(r.kind);
+        if (isCount) counts[r.kind] = (counts[r.kind] ?? 0) + r.tokens_saved;
+        const tokensSaved = isCount ? 0 : r.tokens_saved;
+        const bytesSaved = r.bytes_saved;
+        totalEvents += r.events;
+        totalBytes += bytesSaved;
+        totalTokens += tokensSaved;
+        if (!byKind[r.kind]) byKind[r.kind] = zeroBucket();
+        addBucket(byKind[r.kind], r.events, bytesSaved, tokensSaved);
+        if (!byDay[r.day]) byDay[r.day] = zeroBucket();
+        addBucket(byDay[r.day], r.events, bytesSaved, tokensSaved);
+        const harness = r.harness || HARNESS_UNRECORDED;
+        if (!byHarness[harness]) byHarness[harness] = zeroBucket();
+        addBucket(byHarness[harness], r.events, bytesSaved, tokensSaved);
+        const pricingVersion = r.tg_version || PRICING_VERSION_UNRECORDED;
+        if (!byPricingVersion[pricingVersion]) byPricingVersion[pricingVersion] = zeroBucket();
+        addBucket(byPricingVersion[pricingVersion], r.events, bytesSaved, tokensSaved);
+      }
+    }
+  } catch {
+  }
+  const bySourceDict = {};
+  for (const [kind, bucket] of Object.entries(byKind)) {
+    const source = kindToSource(kind);
+    if (!bySourceDict[source]) {
+      bySourceDict[source] = zeroBucket();
+    }
+    bySourceDict[source].events += bucket.events;
+    bySourceDict[source].bytes_saved += bucket.bytes_saved;
+    bySourceDict[source].tokens_saved += bucket.tokens_saved;
+  }
+  const byCommandDict = {};
+  for (const [cmd, kinds] of Object.entries(COMMAND_KINDS)) {
+    byCommandDict[cmd] = zeroBucket();
+    for (const kind of kinds) {
+      if (byKind[kind]) {
+        byCommandDict[cmd].events += byKind[kind].events;
+        byCommandDict[cmd].bytes_saved += byKind[kind].bytes_saved;
+        byCommandDict[cmd].tokens_saved += byKind[kind].tokens_saved;
+      }
+    }
+  }
+  const byDayList = Object.entries(byDay).map(([date, bucket]) => ({ ...bucket, date })).sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
+  const byProjectList = [];
+  const t1 = Date.now();
+  if (t1 - t0 > 1e3) {
+    console.warn(`summarize took ${t1 - t0}ms (window=${windowDays}d, total=${totalEvents} rows)`);
+  }
+  return {
+    total_events: totalEvents,
+    total_bytes_saved: totalBytes,
+    total_tokens_saved: totalTokens,
+    by_kind: byKind,
+    by_day: byDayList,
+    by_project: byProjectList,
+    by_source: bySourceDict,
+    by_harness: byHarness,
+    by_pricing_version: byPricingVersion,
+    counts,
+    by_command: Object.entries(byCommandDict).map(([command, bucket]) => ({ ...bucket, command })).filter((r) => r.events > 0),
+    window_days: windowDays
+  };
+}
+function _totalsLines(summary) {
+  return [
+    "# token-goat stats",
+    `Total events:   ${summary.total_events}`,
+    `Bytes saved:    ${fmtBytes(summary.total_bytes_saved)}`,
+    `Tokens saved:   ${summary.total_tokens_saved}`,
+    // Disclosure, not a correction: `total_tokens_saved` above sums rows written under whichever
+    // pricing formula was live when each was recorded, and `tg_version` cannot be read back into
+    // "which formula" for a row from before this disclosure existed (PRICING_VERSION_UNRECORDED is
+    // the overwhelming majority of all-time rows). Excluding those rows from the headline would
+    // discard nearly the whole figure rather than fix it, so the honest move is to keep the sum and
+    // say plainly that it spans more than one era, not to quietly present a mixed total as single-formula.
+    ...hasMixedPricingEras(summary) ? [
+      `Pricing note:   totals mix ${countNoun(Object.keys(summary.by_pricing_version).length, "tg_version era")} (${countNoun(summary.by_pricing_version[PRICING_VERSION_UNRECORDED]?.events ?? 0, "row")} unrecorded); see 'token-goat stats --json' -> by_pricing_version for the breakdown`
+    ] : [],
+    // Printed on its own line, below the token total and never inside it, because it counts
+    // placeholders rather than tokens. Omitted entirely when nothing was redacted, so the line is
+    // information rather than a permanent zero. See COUNT_ONLY_KINDS.
+    ...summary.counts["secret_redacted"] ? [`Secrets hidden: ${summary.counts["secret_redacted"]} (a count, not tokens)`] : [],
+    `Window:         ${summary.window_days} days`
+  ];
+}
+function _useRichStats() {
+  if (process.env["NO_COLOR"]) return false;
+  if (process.stdout.isTTY === true) return true;
+  return process.stdout.isTTY === void 0 && !process.env["CI"];
+}
+function _renderShortTotals(summary) {
+  const lines = [
+    ..._totalsLines(summary),
+    "",
+    "Run 'token-goat stats --full' for the full breakdown (by source, by command, by day)."
+  ];
+  console.log(lines.join("\n"));
+}
+function _plainTextStats(summary) {
+  const lines = _totalsLines(summary);
+  if (Object.keys(summary.by_source).length > 0) {
+    lines.push("", "## By Source");
+    const sources = Object.entries(summary.by_source).filter(([, b]) => b.events > 0).sort((a, b) => b[1].tokens_saved - a[1].tokens_saved);
+    for (const [source, bucket] of sources) {
+      lines.push(
+        `  ${source.padEnd(8)} ${bucket.events.toString().padStart(6)} events  ${fmtBytes(bucket.bytes_saved).padStart(8)}  ${bucket.tokens_saved.toString().padStart(8)} tokens`
+      );
+    }
+  }
+  const harnesses = Object.entries(summary.by_harness).filter(([, b]) => b.events > 0).sort((a, b) => b[1].tokens_saved - a[1].tokens_saved);
+  if (harnesses.length > 1) {
+    lines.push("", "## By Harness");
+    for (const [harness, bucket] of harnesses) {
+      lines.push(
+        `  ${harness.padEnd(22)} ${bucket.events.toString().padStart(6)} events  ${fmtBytes(bucket.bytes_saved).padStart(8)}  ${bucket.tokens_saved.toString().padStart(8)} tokens`
+      );
+    }
+  }
+  if (summary.by_command.length > 0) {
+    lines.push("", "## By Command");
+    for (const row of summary.by_command) {
+      lines.push(
+        `  ${row.command.padEnd(12)} ${row.events.toString().padStart(6)} events  ${fmtBytes(row.bytes_saved).padStart(8)}  ${row.tokens_saved.toString().padStart(8)} tokens`
+      );
+    }
+  } else {
+    const hintBucket = summary.by_source[SOURCE_HINT];
+    if (hintBucket && hintBucket.events > 0) {
+      lines.push(
+        "",
+        "## By Command",
+        `  0 direct command invocations this window -- ${hintBucket.events} hint(s) fired but not acted on.`,
+        "  Run token-goat symbol/read/section/semantic/outline/skeleton directly to capture these savings."
+      );
+    }
+  }
+  if (summary.by_day.length > 0) {
+    lines.push("", "## Last 7 Days");
+    for (const row of summary.by_day.slice(0, 7)) {
+      lines.push(
+        `  ${row.date} ${row.events.toString().padStart(6)} events  ${fmtBytes(row.bytes_saved).padStart(8)}  ${row.tokens_saved.toString().padStart(8)} tokens`
+      );
+    }
+  }
+  console.log(lines.join("\n"));
+}
+function _buildStatsData(summary, windowDays) {
+  const now = /* @__PURE__ */ new Date();
+  const periodStart = windowDays > 0 ? new Date(now.getTime() - windowDays * 24 * 60 * 60 * 1e3) : /* @__PURE__ */ new Date(0);
+  const sparkDays = [...summary.by_day].reverse().slice(-30);
+  const sparklines = sparkDays.length > 1 ? {
+    events: sparkDays.map((d) => d.events),
+    bytes: sparkDays.map((d) => d.bytes_saved),
+    tokens: sparkDays.map((d) => d.tokens_saved)
+  } : null;
+  return {
+    period_start: periodStart,
+    period_end: now,
+    version: VERSION,
+    window_label: windowDays > 0 ? `last ${countNoun(windowDays, "day")}` : "all time",
+    totals: {
+      events: summary.total_events,
+      bytes: summary.total_bytes_saved,
+      tokens: summary.total_tokens_saved,
+      sparklines
+    },
+    by_kind: Object.entries(summary.by_kind).map(([kind, bucket]) => ({
+      kind,
+      bytes: bucket.bytes_saved,
+      tokens: bucket.tokens_saved,
+      events: bucket.events,
+      bytes_mode_only: _BYTES_MODE_ONLY_KINDS.has(kind)
+    })).sort((a, b) => b.bytes - a.bytes),
+    by_day: summary.by_day.map((d) => ({
+      date: d.date,
+      bytes: d.bytes_saved,
+      tokens: d.tokens_saved,
+      events: d.events
+    })),
+    by_project: [],
+    by_source: Object.entries(summary.by_source).filter(([, b]) => b.events > 0).map(([source, bucket]) => ({
+      source,
+      bytes: bucket.bytes_saved,
+      tokens: bucket.tokens_saved,
+      events: bucket.events
+    })).sort((a, b) => b.bytes - a.bytes),
+    by_command: summary.by_command.map((c) => ({
+      command: c.command,
+      bytes: c.bytes_saved,
+      tokens: c.tokens_saved,
+      events: c.events
+    })),
+    by_harness: Object.entries(summary.by_harness).filter(([, b]) => b.events > 0).map(([harness, bucket]) => ({
+      harness,
+      bytes: bucket.bytes_saved,
+      tokens: bucket.tokens_saved,
+      events: bucket.events
+    })).sort((a, b) => b.bytes - a.bytes)
+  };
+}
+function renderShortStats(opts) {
+  const windowDays = opts?.windowDays ?? 30;
+  const summary = summarize(windowDays, void 0, opts?.homeDir);
+  if (summary.total_events === 0) {
+    console.log(noStatsMessage(windowDays, opts?.homeDir));
+    return;
+  }
+  const useTty = process.env["NO_COLOR"] ? false : opts?.force === true ? true : _useRichStats();
+  if (!useTty) {
+    _renderShortTotals(summary);
+    return;
+  }
+  const statsData = _buildStatsData(summary, windowDays);
+  process.stdout.write(renderStats(statsData, { short: true }) + "\n");
+}
+function renderStats2(opts) {
+  const windowDays = opts?.windowDays ?? 30;
+  const summary = summarize(windowDays, void 0, opts?.homeDir);
+  if (summary.total_events === 0) {
+    console.log(noStatsMessage(windowDays, opts?.homeDir));
+    return;
+  }
+  const useTty = _useRichStats();
+  if (!useTty) {
+    _plainTextStats(summary);
+    return;
+  }
+  const statsData = _buildStatsData(summary, windowDays);
+  process.stdout.write(renderStats(statsData) + "\n");
+}
+
+// src/secret_redact.ts
+init_define_import_meta_env();
+var SECRET_PATTERNS = [
+  // Anthropic keys share OpenAI's "sk-" prefix but are more specific ("sk-ant-"), so they're matched first — the generic OpenAI pattern's negative lookahead below is defense in depth, not the sole guard.
+  ["anthropic_api_key", /sk-ant-[A-Za-z0-9_-]{20,}/g],
+  // Modern (post-2024, now the default) OpenAI project keys: "sk-proj-" followed by a long base64url-ish body that legitimately contains '-' and '_' -- the generic pattern below deliberately excludes those characters (hyphenated prose would false-fire), so this needs its own entry with the more specific prefix matched first, like sk-ant- above.
+  ["openai_project_key", /sk-proj-[A-Za-z0-9_-]{20,}/g],
+  ["openai_api_key", /sk-(?!ant-|proj-)[A-Za-z0-9]{20,}/g],
+  ["aws_access_key", /AKIA[0-9A-Z]{16}/g],
+  // Fine-grained PATs ("github_pat_...") are matched before the classic gh[oprsu]_ pattern so the full token is always consumed as one match -- a fine-grained token's own body can contain '_' and could otherwise partially match the classic pattern.
+  ["github_token", /github_pat_[A-Za-z0-9_]{22,}/g],
+  ["github_token", /gh[oprsu]_[A-Za-z0-9]{36,}/g],
+  // xapp- is Slack's app-level token (Socket Mode), a bearer credential in its own right that the xox[baprs]- prefix does not cover. It gets its own entry rather than joining the alternation above because it needs the full segmented shape (xapp-<ver>-<app id>-<digits>- <hex>) to be safe: a bare /xapp-[A-Za-z0-9-]+/ redacted ordinary identifiers like "xapp-config" and the css class "xapp-container", mangling normal source. The xox* prefixes are distinctive enough on their own; "xapp-" is not.
+  ["slack_token", /xox[baprs]-[A-Za-z0-9-]+/g],
+  ["slack_token", /xapp-\d-[A-Za-z0-9]{6,}-\d{8,}-[A-Za-z0-9]{16,}/g],
+  // Matches the full block (BEGIN marker through its matching END marker), not just the header -- the actual secret material is the base64 body between them, so redacting only the header line would leave the key bytes themselves fully readable in the cached blob. The body is lazy and additionally refuses to cross a following BEGIN marker. Both halves matter. The laziness bounds a successful match at the very next END marker; the negative lookahead bounds a *failing* one, because a BEGIN with no END of its own would otherwise scan to end-of-input, and a blob full of such markers made the pass quadratic -- 6 ms, 20 ms and 78 ms for 2000, 4000 and 8000 of them, four times the work for twice the input, the same shape as the lookbehind incident described above. Private key blocks do not nest, so refusing to cross a BEGIN costs nothing in correctness. The algorithm and ` BLOCK` groups are backreferenced in the END marker rather than repeated, so a BEGIN only ever pairs with its own END spelling. Written as two independent optional groups, `BEGIN PGP PRIVATE KEY` would happily close on a distant `END RSA PRIVATE KEY BLOCK` and redact everything in between. A non-participating group backreferences as the empty string in JS, which is exactly what the unprefixed `BEGIN PRIVATE KEY` form needs. The algorithm list covers every armored private-key header openssl, ssh-keygen and gpg actually emit, not just the ones a first draft happened to think of. ENCRYPTED is the PKCS#8 passphrase-protected form (`openssl genpkey -aes256`, `ssh-keygen -m PKCS8`) and is the most common shape of all; DSA is legacy but still written verbatim; PGP carries the ` BLOCK` suffix, which is why that suffix is optional here. All three used to fall through to disk in full. An encrypted key is still key material: the passphrase can be attacked offline once the bytes are cached, so it is redacted like any other. PuTTY `.ppk` files are deliberately not matched. They have no END marker -- the private section is a `Private-Lines: N` count followed by exactly N base64 lines -- so bounding a match would take a stateful parse rather than a regex, on a path that runs over every command output. A regex guess at where the body ends is exactly the over-eager match this module's header warns against.
+  ["private_key_block", /-----BEGIN (RSA |DSA |EC |OPENSSH |ENCRYPTED |PGP )?PRIVATE KEY( BLOCK)?-----(?:(?!-----BEGIN )[\s\S])*?-----END \1PRIVATE KEY\2-----/g],
+  // Redacts only the token itself, not the "Authorization: Bearer " prefix -- the lookbehind anchors on the header name and scheme so the surrounding request-log line stays readable, matching how AWS_ACCESS_KEY_ID=... above keeps its own prefix intact. The optional quotes on either side of the colon are what let this see a header carried in JSON rather than in raw wire format. Without them the lookbehind demanded the colon sit directly against the header name and the scheme directly against the space, so a body like {"Authorization": "Bearer <token>"} -- the shape any logged fetch or MCP result arrives in -- matched nothing and the token was cached verbatim. `token` is the second scheme spelling in wide use -- it is what curl and gh examples pass for GitHub and many other APIs -- and an opaque value behind it carries exactly the same authority as one behind `Bearer`. The trailing gap is `{1,8}` rather than a single space for the same reason every other gap in this lookbehind already is: a hand-aligned or reformatted header ("Authorization: Bearer <token>") is ordinary, and demanding exactly one space there made this the one position in the pattern that a second space defeated.
+  ["auth_bearer_token", /(?<=Authorization["']?[ \t]{0,8}:[ \t]{0,8}["']?[ \t]{0,8}(?:Bearer|token)[ \t]{1,8})[A-Za-z0-9\-._~+/]{10,}=*/gi],
+  ["auth_basic_token", /(?<=Authorization["']?[ \t]{0,8}:[ \t]{0,8}["']?[ \t]{0,8}Basic[ \t])[A-Za-z0-9+/]{6,}=*/gi],
+  // JWTs have no distinctive prefix of their own, but the base64url encoding of the smallest realistic header ('{"alg":' or similar) always starts with "eyJ", so that's the practical anchor here -- each of the three dot-separated segments requires a minimum length to avoid matching a short, coincidentally dotted token.
+  //
+  // The trailing `={0,2}` on each segment is what makes a padded token match. Base64url as the JWT spec defines it drops the `=` padding, but producers that reach for a plain base64 encoder emit it anyway, and a `=` in the header or payload segment used to defeat the match outright: not a partial redaction, but none at all, so the entire token was printed. `=` cannot appear anywhere except the end of a segment, since it is not one of the characters the segment body allows, so accepting it here cannot widen the match onto anything else.
+  ["jwt", /eyJ[A-Za-z0-9_-]{10,}={0,2}\.[A-Za-z0-9_-]{10,}={0,2}\.[A-Za-z0-9_-]{10,}={0,2}/g],
+  ["npm_token", /npm_[A-Za-z0-9]{36}/g],
+  // rk_live_ (restricted keys) share the sk_live_/sk_test_ secret-key shape and risk level, so one pattern covers all three rather than adding a near-duplicate entry.
+  ["stripe_key", /(?:sk_live_|sk_test_|rk_live_)[A-Za-z0-9]{20,}/g],
+  ["google_api_key", /AIza[A-Za-z0-9_-]{35}/g],
+  // Presigned-url signatures: AWS SigV4 (X-Amz-Signature), Google Cloud Storage (X-Goog-Signature), and Azure blob SAS (sig). These are bearer credentials in query-string clothing -- anyone holding the whole url can read or write the object until it expires, and none of the prefix-anchored patterns above match them because the signature is a bare hex or base64 blob with no distinctive prefix of its own. The '[?&]' anchor and the 16-char floor are what make the short, generic 'sig' name safe to key on: a prose or code mention of "sig" never sits directly after a query separator followed by that much opaque token.
+  ["presigned_signature", /(?<=[?&](?:X-Amz-Signature|X-Goog-Signature|sig)=)[A-Za-z0-9%+/=_-]{16,}/gi],
+  // A password inside a connection url. `postgres://user:hunter2@db.internal` carries the credential in the authority section, where there is no `key=value` separator for the generic pattern below to anchor on, so a DATABASE_URL echoed by a failing migration or a psql error went through untouched. The anchors are what keep this narrow: a scheme's `://`, a userinfo segment, the colon, and a following `@`. `http://host:8080/path` has no `@` and is left alone; so is any url without credentials.
+  ["url_credentials", /(?<=:\/\/[^\s:@/]{1,64}:)[^\s:@/]{1,256}(?=@)/g],
+  // Azure storage account connection strings (`DefaultEndpointsProtocol=https;AccountName=...; AccountKey=<base64>==;EndpointSuffix=core.windows.net`) carry a full read/write key to the account in the AccountKey field, and none of the generic patterns above catch it: generic_secret_assignment's keyword list (password|passwd|secret|api[_-]?key| access[_-]?token|refresh[_-]?token|id[_-]?token) has nothing that matches "AccountKey", and an unanchored base64-shape pattern was deliberately rejected -- this module's header already warns that a bare high-entropy-blob heuristic false-fires on ordinary code, JSON and log output, and an 88-char base64 value is exactly the shape a hash, a compiled asset digest or a generated id can also take. Anchoring on the literal `AccountKey=` field name instead keeps the match specific to this one connection-string field. The value class is base64 proper (letters, digits, `+`, `/`, trailing `=` padding) and none of those characters include `;`, so the match terminates on its own at the `;` that starts the next `Name=` field -- unlike generic_secret_assignment's separator characters (`& ; # , :`), which double as ordinary credential characters and need a lookahead to tell the two roles apart, `;` is never valid base64 and needs no such lookahead here. The lookbehind keeps `AccountKey=` itself in the output, matching auth_bearer_token and presigned_signature above, so `;EndpointSuffix=core.windows.net` after it stays fully readable too. `SharedAccessKey` is the same credential one Azure service over: Service Bus, Event Hubs and Relay spell it that way (`Endpoint=sb://ns.servicebus.windows.net/;SharedAccessKeyName=Root; SharedAccessKey=<base64>`) and it carries the same authority over that namespace that AccountKey does over a storage account. `SharedAccessKeyName` is a plain identifier rather than a secret, and never matches: the separator in the lookbehind sits directly against the key name, so the `Name` in between stops it dead. The separator is spelled the way auth_bearer_token above spells its own, for the same reasons that comment records having learned the hard way. Optional quotes on either side of it, so the JSON and YAML forms a logged MCP result or api response actually arrives in are matched rather than stopped dead at the opening quote. A bounded gap rather than exactly one space, so a hand-aligned or reformatted `AccountKey = ...` in an appsettings file is not the single variant that defeats the whole pattern. Case-insensitive for the same reason presigned_signature is. The leading word boundary is what keeps the widened name from reaching into the middle of a longer identifier such as `myaccountkey=`.
+  ["azure_storage_key", /(?<=\b(?:AccountKey|SharedAccessKey)["']?[ \t]{0,8}[:=][ \t]{0,8}["']?)[A-Za-z0-9+/]{40,}=*/gi],
+  // Generic key=value assignments in .env-file and connection-string/query-string shape. The lookbehind again redacts only the value, and the value's character class deliberately excludes whitespace, '&', ';', '#', quote characters, and '[' ']' ':' -- that exclusion is what stops this from swallowing the rest of the line (a trailing comment or the next key=value pair) or the remainder of a query string past the matched parameter, which is exactly the kind of over-eager match this module's own design note above warns broad heuristics produce. The '[' ']' ':' exclusion also matters because this pattern runs last: an earlier pattern's own "OPENAI_API_KEY=[REDACTED:openai_project_key]" replacement text contains "API_KEY=" too, and without excluding those characters this pattern would re-match and double-redact its own placeholder. The length has a lower bound only (no upper bound): capping it at 64 used to leave the tail of any longer secret unredacted in plain text, which is worse than no redaction because it looks handled. A single negated-class quantifier like this cannot backtrack catastrophically -- there is no nested or overlapping quantifier for the engine to explore multiple ways of matching, so removing the upper bound does not introduce a ReDoS risk. Quotes are permitted around the separator, but never inside the value class. A quoted value is the ordinary way secrets are written -- .env files, JSON, YAML, TOML all quote by default -- and the lookbehind used to stop dead at the opening quote, so `API_KEY="..."` passed through in full while the bare `API_KEY=...` was caught. The closing quote of the key name blocked it from the other side too, which is what kept every JSON body unredacted. Keeping quotes out of the value class is still what stops the match running past the closing quote. The keyword may be a prefix of a longer key name rather than the whole of it, so the trailing identifier class below is load-bearing: without it the lookbehind required the keyword to sit immediately before the separator, and AWS_SECRET_ACCESS_KEY=, SECRET_KEY=, and DB_PASSWORD_HASH= all passed through in full. That class matches identifier characters only, so prose that merely mentions a keyword still never reaches a separator and stays unredacted. api[_-]?key covers the apikey and api-key spellings too. `& ; # , :` play two incompatible roles. They separate one field from the next (a query string, a cookie header, an inline env list), and they are also perfectly ordinary credential characters. Rejecting them outright got the first role right and the second badly wrong: the match stopped at the first one and left everything after it in plain text, so `password=corr&horse&battery` redacted four characters and printed the rest, and `DB_PASSWORD=Aa1:xyz` matched nothing at all because the run before the `:` was under the four-character floor. A tail left sitting in the open is the outcome this module's header calls worse than no redaction, because it reads as handled.
+  //
+  // So the separator role is decided by what follows rather than assumed: one of these characters ends the value only when the next thing along is another `name=` / `name:` pair, which is what an actual field separator is always followed by. `,OTHER=public` and `; other=1` still end it; the `&` in the middle of a passphrase does not. Whitespace, quotes and brackets are unchanged -- they end a value unconditionally, which is also what keeps this pattern from re-matching the `[REDACTED:...]` placeholder it just wrote.
+  ["generic_secret_assignment", /(?<=(?:password|passwd|secret|api[_-]?key|access[_-]?token|refresh[_-]?token|id[_-]?token)[a-z0-9_-]{0,64}["']?[ \t]{0,8}[:=][ \t]{0,8}["']?)(?:\\[^\n]|[^\s\\&;#,:'"[\]{}]|[&;#,:](?![ \t]*[A-Za-z_][A-Za-z0-9_.-]*[ \t]*[:=])){4,}/gi]
+];
+function countRedactionPlaceholders(text) {
+  return text.match(/\[REDACTED:[a-z0-9_]+\]/g)?.length ?? 0;
+}
+var MAX_CUSTOM_PATTERNS = 64;
+var MAX_CUSTOM_PATTERN_LENGTH = 512;
+var customCache = null;
+function compileCustomPatterns(sources) {
+  const key = JSON.stringify(sources);
+  if (customCache !== null && customCache.key === key) {
+    return { patterns: customCache.patterns, problems: customCache.problems };
+  }
+  const patterns = [];
+  const problems = [];
+  const written = sources.map((raw) => raw.trim()).filter((source) => source.length > 0);
+  for (const source of written.slice(0, MAX_CUSTOM_PATTERNS)) {
+    if (source.length > MAX_CUSTOM_PATTERN_LENGTH) {
+      problems.push({ pattern: source.slice(0, 60), reason: `longer than ${MAX_CUSTOM_PATTERN_LENGTH} characters` });
+      continue;
+    }
+    if (hasNestedQuantifier(source)) {
+      problems.push({
+        pattern: source,
+        reason: "repeats a group that already repeats, which can take exponential time to match"
+      });
+      continue;
+    }
+    let compiled;
+    try {
+      compiled = new RegExp(source, "g");
+    } catch (e) {
+      problems.push({ pattern: source, reason: e instanceof Error ? e.message : "is not a valid regular expression" });
+      continue;
+    }
+    if (new RegExp(source).test("")) {
+      problems.push({
+        pattern: source,
+        reason: "matches the empty string, so it would replace every position in the text"
+      });
+      continue;
+    }
+    if (growsExponentially(compiled)) {
+      problems.push({
+        pattern: source,
+        reason: "its running time doubles as the text grows, which can stall the process on a short input"
+      });
+      continue;
+    }
+    patterns.push(compiled);
+  }
+  if (written.length > MAX_CUSTOM_PATTERNS) {
+    problems.push({
+      pattern: `(${written.length} entries)`,
+      reason: `only the first ${MAX_CUSTOM_PATTERNS} custom patterns are used`
+    });
+  }
+  customCache = { key, patterns, problems };
+  return { patterns, problems };
+}
+var STRICT_CANDIDATE = /[A-Za-z0-9+/_-]{24,}={0,2}/g;
+function entropyBitsPerChar(s) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const ch of s) counts.set(ch, (counts.get(ch) ?? 0) + 1);
+  let bits = 0;
+  for (const n of counts.values()) {
+    const p = n / s.length;
+    bits -= p * Math.log2(p);
+  }
+  return bits;
+}
+function characterClasses(s) {
+  let n = 0;
+  if (/[a-z]/.test(s)) n++;
+  if (/[A-Z]/.test(s)) n++;
+  if (/[0-9]/.test(s)) n++;
+  if (/[+/=_-]/.test(s)) n++;
+  return n;
+}
+function looksLikeCredential(s) {
+  return characterClasses(s) >= 3 && entropyBitsPerChar(s) >= 3.5;
+}
+function redactSecrets(text, config = loadConfig()) {
+  let count = 0;
+  let out = text;
+  for (const [kind, pattern] of SECRET_PATTERNS) {
+    out = out.replace(pattern, () => {
+      count++;
+      return `[REDACTED:${kind}]`;
+    });
+  }
+  for (const pattern of compileCustomPatterns(config.redaction.custom_patterns).patterns) {
+    out = out.replace(pattern, () => {
+      count++;
+      return "[REDACTED:custom]";
+    });
+  }
+  if (config.redaction.strict) {
+    out = out.replace(STRICT_CANDIDATE, (candidate) => {
+      if (!looksLikeCredential(candidate)) return candidate;
+      count++;
+      return "[REDACTED:high_entropy]";
+    });
+  }
+  return { text: out, count };
+}
+
+// src/disk_cache.ts
+init_define_import_meta_env();
+import * as fs4 from "node:fs";
+import * as path4 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);
+}
+function blobPath(subdir, id) {
+  const safe = sanitizeId(id);
+  if (!safe) return null;
+  const dir = blobDir(subdir);
+  const candidate = path4.join(dir, `${safe}.json`);
+  try {
+    const rel = path4.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 stat = fs4.statSync(p);
+    return Date.now() - stat.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 = path4.dirname(p);
+    if (!fs4.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 (!fs4.existsSync(p)) return null;
+    return JSON.parse(fs4.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function listBlobs(subdir) {
+  const dir = blobDir(subdir);
+  const out = [];
+  try {
+    if (!fs4.existsSync(dir)) return out;
+    for (const file of fs4.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;
+      } 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 (!fs4.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);
+      let stat;
+      try {
+        stat = fs4.statSync(full);
+      } catch {
+        continue;
+      }
+      if (!stat.isFile()) continue;
+      if (protectedPath !== void 0 && full === protectedPath) {
+        protectedEntry = [full, stat.mtimeMs, stat.size];
+        continue;
+      }
+      if (stat.mtimeMs < cutoff) {
+        try {
+          fs4.unlinkSync(full);
+          removed++;
+        } catch {
+          continue;
+        }
+      } else if (file.endsWith(".json")) {
+        kept.push([full, stat.mtimeMs, stat.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 {
+          fs4.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 {
+          fs4.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(
+          path4.join(root, subdir),
+          countCapped ? defaults.maxCount : Number.POSITIVE_INFINITY,
+          DEFAULT_MAX_AGE_MS,
+          countCapped ? defaults.maxBytes : Number.POSITIVE_INFINITY
+        );
+      } catch {
+      }
+    }
+  }
+  return removed;
+}
+
+export {
+  Database,
+  FILENAME_LANGUAGE,
+  TREE_SITTER_LANGUAGES,
+  languageHasFlag,
+  languageLabel,
+  fenceFor,
+  basenameImportsExtension,
+  partialRefsReason,
+  refineLanguageByContent,
+  detectLanguageOfFile,
+  detectLanguage,
+  nonTreeSitterLanguageCount,
+  unsupportedLanguageName,
+  isDotenvPath,
+  redactIfDotenv,
+  getDb,
+  colorStdout,
+  RESET,
+  stripAnsiEscapes,
+  stripAnsi,
+  fg,
+  C,
+  SOURCE_HINT,
+  savedTokensFromBytes,
+  formatLocalTimestamp,
+  recordStat,
+  recordUnmappedTool,
+  readUnmappedTools,
+  summarize,
+  _useRichStats,
+  renderShortStats,
+  renderStats2 as renderStats,
+  countRedactionPlaceholders,
+  compileCustomPatterns,
+  redactSecrets,
+  DEFAULT_MAX_COUNT,
+  DEFAULT_MAX_AGE_MS,
+  blobPath,
+  isBlobStale,
+  storeBlob,
+  loadBlob,
+  listBlobs,
+  pruneBlobs,
+  sweepCacheRoots
+};