token-goat 2.6.36 → 2.8.1

package/dist/{token-goat-chunk-V465YKOR.mjs → token-goat-chunk-ELDJRLHZ.mjs}

@@ -8,7 +8,7 @@ import {
 import { createRequire } from "node:module";
 function resolveVersion() {
   if (true) {
-    return "2.6.36";
+    return "2.8.1";
   }
   const require2 = createRequire(import.meta.url);
   const pkg = require2("../package.json");
@@ -418,14 +418,14 @@ function ensureDirSync(dir) {
 }
 function withRetryOnLock(fn) {
   let lastErr;
-  for (let attempt = 1; attempt <= 5; attempt++) {
+  for (let attempt2 = 1; attempt2 <= 5; attempt2++) {
     try {
       fn();
       return;
     } catch (err) {
       lastErr = err;
-      if (!isRetryable(err) || attempt === 5) throw err;
-      sleepSync(50 * attempt);
+      if (!isRetryable(err) || attempt2 === 5) throw err;
+      sleepSync(50 * attempt2);
     }
   }
   throw lastErr;
@@ -559,7 +559,7 @@ function withFileLock(lockPath, fn, opts = {}) {
   const staleMs = opts.staleMs ?? LOCK_STALE_MS;
   const token = `${process.pid}:${process.hrtime.bigint().toString()}`;
   const deadline = Date.now() + waitMs;
-  let attempt = 0;
+  let attempt2 = 0;
   for (; ; ) {
     try {
       writeFileSync(lockPath, token, { flag: "wx" });
@@ -582,7 +582,7 @@ function withFileLock(lockPath, fn, opts = {}) {
       continue;
     }
     if (Date.now() >= deadline) return void 0;
-    sleepSync(Math.min(20 * ++attempt, 200));
+    sleepSync(Math.min(20 * ++attempt2, 200));
   }
   const heartbeat = startHeartbeat(lockPath, token, staleMs);
   try {
@@ -3700,17 +3700,21 @@ function isInsideStringLiteral(line, index, from = 0) {
   }
   return openQuote !== null;
 }
+function nextBlockCommentOpen(line, from) {
+  const lineCommentIdx = lineCommentStartIndex(line, ["//"], from);
+  let open = line.indexOf("/*", from);
+  while (open !== -1 && (isInsideStringLiteral(line, open, from) || lineCommentIdx !== -1 && open >= lineCommentIdx)) {
+    open = line.indexOf("/*", open + 1);
+  }
+  return open;
+}
 function stripBlockCommentSpan(line, inComment) {
   let code = "";
   let j = 0;
   let comment = inComment;
   while (j < line.length) {
     if (!comment) {
-      const lineCommentIdx = lineCommentStartIndex(line, ["//"], j);
-      let open = line.indexOf("/*", j);
-      while (open !== -1 && (isInsideStringLiteral(line, open, j) || lineCommentIdx !== -1 && open >= lineCommentIdx)) {
-        open = line.indexOf("/*", open + 1);
-      }
+      const open = nextBlockCommentOpen(line, j);
       if (open === -1) {
         code += line.slice(j);
         break;
@@ -3744,11 +3748,7 @@ function stripNestedBlockCommentSpan(line, depth) {
   let d = depth;
   while (j < line.length) {
     if (d === 0) {
-      const lineCommentIdx = lineCommentStartIndex(line, ["//"], j);
-      let open = line.indexOf("/*", j);
-      while (open !== -1 && (isInsideStringLiteral(line, open, j) || lineCommentIdx !== -1 && open >= lineCommentIdx)) {
-        open = line.indexOf("/*", open + 1);
-      }
+      const open = nextBlockCommentOpen(line, j);
       if (open === -1) {
         code += line.slice(j);
         break;
@@ -4454,11 +4454,328 @@ function redactIfDotenv(filePath, text) {
 }
 
 // src/db.ts
+import * as fs7 from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import * as path7 from "node:path";
+
+// src/sqlite_driver.ts
 import * as fs6 from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import * as path7 from "node:path";
-import Database from "better-sqlite3";
 var _require = createRequire2(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 rows = attempt(() => this.#stmt.all(...params));
+    return this.#pluck ? rows.map((r) => this.#shape(r)) : rows;
+  }
+  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 rows = attempt(() => this.#stmt.iterate(...params))[Symbol.iterator]();
+    for (; ; ) {
+      const next = attempt(() => rows.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:" && !fs6.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 rows = attempt(() => this.#db.prepare(`PRAGMA ${source}`).all());
+    if (options.simple !== true) return rows;
+    const first = rows[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 = createRequire3(import.meta.url);
 var _connections = /* @__PURE__ */ new Map();
 var SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS files (
@@ -4658,6 +4975,26 @@ CREATE TABLE IF NOT EXISTS skill_version_snapshots (
   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_SQL = `
 CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(
@@ -4708,7 +5045,7 @@ CREATE TRIGGER IF NOT EXISTS cache_recall_au AFTER UPDATE ON cache_recall BEGIN
   VALUES (new.row_id, new.label, new.content);
 END;
 `;
-var SCHEMA_VERSION = 11;
+var SCHEMA_VERSION = 12;
 function alterTableIdempotent(conn, sql) {
   try {
     conn.exec(sql);
@@ -4802,7 +5139,7 @@ function initConnection(conn) {
   } catch {
   }
   try {
-    const sqliteVec = _require("sqlite-vec");
+    const sqliteVec = _require2("sqlite-vec");
     sqliteVec.load(conn);
     conn.exec(
       `CREATE VIRTUAL TABLE IF NOT EXISTS chunk_vectors USING vec0(
@@ -4833,7 +5170,7 @@ function getDb(dbPath) {
   try {
     ensureDirSync(dir);
   } catch (e) {
-    if (e.code !== "EEXIST" || !fs6.existsSync(dir)) throw e;
+    if (e.code !== "EEXIST" || !fs7.existsSync(dir)) throw e;
   }
   const conn = new Database(resolved);
   try {
@@ -5464,6 +5801,30 @@ function _renderByCommandSection(stats) {
   }
   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 [];
@@ -5528,7 +5889,8 @@ function _renderInsightsSection(stats) {
   function dim(s) {
     return `${fg(...C.TEXT_MUTED)}${s}${RESET}`;
   }
-  const topKind = stats.by_kind.reduce((max, k) => k.bytes > (max?.bytes || -Infinity) ? k : max, stats.by_kind[0]);
+  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(
@@ -5541,7 +5903,7 @@ function _renderInsightsSection(stats) {
       `${_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);
+  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(
@@ -5585,6 +5947,7 @@ function renderStats(stats, opts) {
     _renderByKindSection(stats),
     _renderBySourceSection(stats),
     _renderByCommandSection(stats),
+    _renderByHarnessSection(stats),
     _renderByDaySection(stats),
     _renderByProjectSection(stats),
     _renderInsightsSection(stats),
@@ -5594,6 +5957,7 @@ function renderStats(stats, opts) {
 }
 
 // src/stats.ts
+var HARNESS_UNRECORDED = "unrecorded (pre-2.8.1)";
 var SOURCE_IMAGE = "image";
 var SOURCE_HINT = "hint";
 var SOURCE_READ = "read";
@@ -5640,6 +6004,7 @@ var KIND_TO_SOURCE = {
   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,
@@ -5692,6 +6057,8 @@ var KIND_TO_SOURCE = {
   // 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,
   secret_redacted: 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.
@@ -5727,6 +6094,7 @@ var COMMAND_KINDS = {
   "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"]),
@@ -5821,19 +6189,53 @@ CREATE TABLE IF NOT EXISTS stats (
   kind TEXT NOT NULL,
   tokens_saved INTEGER NOT NULL DEFAULT 0,
   bytes_saved INTEGER NOT NULL DEFAULT 0,
-  detail TEXT
+  detail TEXT,
+  harness TEXT
 );
 CREATE INDEX IF NOT EXISTS idx_stats_ts ON stats(ts);
 CREATE INDEX IF NOT EXISTS idx_stats_kind ON stats(kind);
+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;
+  }
+}
+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;
+}
 function getGlobalDb(homeDir) {
   const basePath = homeDir ? dataDirForHome(homeDir) : dataDir();
   const dbPath = path8.join(basePath, "global.db");
   const db = getDb(dbPath);
   if (!_globalSchemaApplied.has(dbPath)) {
     db.exec(GLOBAL_SCHEMA_SQL);
+    migrateGlobalSchema(db);
     _globalSchemaApplied.add(dbPath);
   }
   return db;
@@ -5848,22 +6250,59 @@ function noStatsMessage(windowDays, homeDir) {
 function recordStat(kind, bytesSaved = 0, tokensSaved = 0, _testDb, detail) {
   try {
     const db = _testDb ?? getGlobalDb();
+    const ts = Math.floor(Date.now() / 1e3);
+    if (statsHasHarnessColumn(db)) {
+      db.prepare(
+        "INSERT INTO stats (ts, kind, bytes_saved, tokens_saved, detail, harness) VALUES (?, ?, ?, ?, ?, ?)"
+      ).run(ts, kind, bytesSaved, tokensSaved, detail ?? null, getHarnessName());
+    } else {
+      db.prepare(
+        "INSERT INTO stats (ts, kind, bytes_saved, tokens_saved, detail) VALUES (?, ?, ?, ?, ?)"
+      ).run(ts, kind, bytesSaved, tokensSaved, detail ?? null);
+    }
+  } 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 stats (ts, kind, bytes_saved, tokens_saved, detail) VALUES (?, ?, ?, ?, ?)"
-    ).run(Math.floor(Date.now() / 1e3), kind, bytesSaved, tokensSaved, detail ?? null);
+      `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 = {};
   let totalEvents = 0;
   let totalBytes = 0;
   let totalTokens = 0;
   const db = testDb ?? getGlobalDb(homeDir);
-  const query = sinceTs !== null ? "SELECT ts, kind, bytes_saved, tokens_saved FROM stats WHERE ts >= ? ORDER BY ts DESC" : "SELECT ts, kind, bytes_saved, tokens_saved FROM stats ORDER BY ts DESC";
+  const hasHarness = statsHasHarnessColumn(db);
+  const cols = hasHarness ? "ts, kind, bytes_saved, tokens_saved, harness" : "ts, kind, bytes_saved, tokens_saved";
+  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 rows = sinceTs !== null ? stmt.all(sinceTs) : stmt.all();
   const tsToDateCache = {};
@@ -5887,6 +6326,11 @@ function summarize(windowDays = 30, testDb, homeDir) {
       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 bySourceDict = {};
   for (const [kind, bucket] of Object.entries(byKind)) {
@@ -5923,6 +6367,7 @@ function summarize(windowDays = 30, testDb, homeDir) {
     by_day: byDayList,
     by_project: byProjectList,
     by_source: bySourceDict,
+    by_harness: byHarness,
     by_command: Object.entries(byCommandDict).map(([command, bucket]) => ({ ...bucket, command })).filter((r) => r.events > 0),
     window_days: windowDays
   };
@@ -5960,6 +6405,15 @@ function _plainTextStats(summary) {
       );
     }
   }
+  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) {
@@ -6033,7 +6487,13 @@ function _buildStatsData(summary, windowDays) {
       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) {
@@ -6293,6 +6753,7 @@ function stripAnsiCodes(text) {
 export {
   VERSION,
   dataDir,
+  ensureDataDirPrivate,
   globalDbPath,
   configPath,
   ENV_KEYS,
@@ -6388,6 +6849,7 @@ export {
   loadPersistedConfig,
   CONFIG_KEY_ENV_OVERRIDES,
   saveConfig,
+  Database,
   precedingDocComment,
   buildLineIndex,
   offsetToLine,
@@ -6428,6 +6890,8 @@ export {
   SOURCE_HINT,
   formatLocalTimestamp,
   recordStat,
+  recordUnmappedTool,
+  readUnmappedTools,
   summarize,
   _useRichStats,
   renderShortStats,