token-goat 2.9.2 → 2.9.4

package/dist/{token-goat-chunk-KKIB7O3Z.mjs → token-goat-chunk-6MU6FHE3.mjs}

@@ -86,7 +86,7 @@ import {
   runZipRead,
   symbolNamesInFile,
   upsertNote
-} from "./token-goat-chunk-FXAPKVRG.mjs";
+} from "./token-goat-chunk-US57I7GN.mjs";
 import {
   DEFAULT_RECONCILE_BUDGET_MS,
   GEMINI_TOOL_NAME_MAP,
@@ -108,7 +108,7 @@ import {
   runReconcile,
   storeWebOutput,
   summarizeResidentContext
-} from "./token-goat-chunk-VCNW7BGU.mjs";
+} from "./token-goat-chunk-FSC44QOH.mjs";
 import {
   AGENT_SALT_MARKER,
   BASH_OUTPUT_SUBDIR,
@@ -175,6 +175,7 @@ import {
   getFileEntry,
   getHintStatsSummary,
   getHintStatsTotals,
+  getParserFreshness,
   getProjectIndexCounts,
   getSessionFiles,
   getSessionId,
@@ -193,6 +194,7 @@ import {
   isHintCategory,
   isParseSkipEligible,
   isRecallCacheType,
+  isSuppressionCategory,
   isWorkerRunning,
   listBlobs,
   listOutputs,
@@ -238,10 +240,11 @@ import {
   visionTokensSavedByText,
   walkProject,
   writeCompact
-} from "./token-goat-chunk-LJ3CHCTT.mjs";
+} from "./token-goat-chunk-CBO45DYZ.mjs";
 import {
   C,
   CONFIG_KEY_ENV_OVERRIDES,
+  CompressedOutput,
   ENV_KEYS,
   FILTERS,
   LOCK_WAIT_MS_HARDENED,
@@ -249,6 +252,8 @@ import {
   PROJECT_LOCKED_KEYS,
   PROJECT_LOCKED_SECTIONS,
   RESET,
+  TOOL_FILTERS,
+  ToolFilter,
   VERSION,
   _useRichStats,
   anchoredMarkerPattern,
@@ -257,6 +262,7 @@ import {
   canonicalize,
   cappedSourceBytesSaved,
   colorStdout,
+  combineStreams,
   compileCustomPatterns,
   configPath,
   copilotCliConfigPath,
@@ -267,6 +273,8 @@ import {
   dataDir,
   decodeSource,
   defaultConfig,
+  deliverCompressed,
+  detectFromCommand,
   detectLanguage,
   detectSourceEncoding,
   encodeSource,
@@ -358,15 +366,24 @@ import {
   withFileLock,
   withRetryOnLock,
   writeJsonSettings
-} from "./token-goat-chunk-UZ2NFOOZ.mjs";
+} from "./token-goat-chunk-3ZR4NLB3.mjs";
 import {
-  __export
-} from "./token-goat-chunk-AEX54RUZ.mjs";
+  __export,
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
 
 // src/cli.ts
+init_define_import_meta_env();
 import { randomBytes } from "node:crypto";
 
+// node_modules/commander/index.js
+init_define_import_meta_env();
+
+// node_modules/commander/lib/argument.js
+init_define_import_meta_env();
+
 // node_modules/commander/lib/error.js
+init_define_import_meta_env();
 var CommanderError = class extends Error {
   /**
    * Constructs the CommanderError class
@@ -517,6 +534,7 @@ function humanReadableArgName(arg) {
 }
 
 // node_modules/commander/lib/command.js
+init_define_import_meta_env();
 import { EventEmitter } from "node:events";
 import childProcess from "node:child_process";
 import path from "node:path";
@@ -525,6 +543,7 @@ import process2 from "node:process";
 import { stripVTControlCharacters as stripVTControlCharacters2 } from "node:util";
 
 // node_modules/commander/lib/help.js
+init_define_import_meta_env();
 import { stripVTControlCharacters } from "node:util";
 var Help = class {
   constructor() {
@@ -1117,6 +1136,7 @@ ${itemIndentStr}`);
 };
 
 // node_modules/commander/lib/option.js
+init_define_import_meta_env();
 var Option = class {
   /**
    * Initialize a new `Option` with the given `flags` and `description`.
@@ -1423,6 +1443,7 @@ function splitOptionFlags(flags) {
 }
 
 // node_modules/commander/lib/suggestSimilar.js
+init_define_import_meta_env();
 var maxDistance = 3;
 function editDistance(a, b) {
   if (Math.abs(a.length - b.length) > maxDistance)
@@ -3477,9 +3498,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [path]
    * @return {(string|null|Command)}
    */
-  executableDir(path30) {
-    if (path30 === void 0) return this._executableDir;
-    this._executableDir = path30;
+  executableDir(path31) {
+    if (path31 === void 0) return this._executableDir;
+    this._executableDir = path31;
     return this;
   }
   /**
@@ -3735,6 +3756,7 @@ function useColor() {
 var program = new Command();
 
 // src/command_intent.ts
+init_define_import_meta_env();
 var INTENT_SUGGESTIONS = [
   [
     ["search", "lookup", "query"],
@@ -3778,11 +3800,12 @@ function attemptedCommandName(argv) {
 }
 
 // src/cli.ts
-import * as fs28 from "fs";
-import * as path29 from "path";
+import * as fs29 from "fs";
+import * as path30 from "path";
 import { homedir as homedir13 } from "os";
 
 // src/walk_index.ts
+init_define_import_meta_env();
 import * as fs2 from "node:fs";
 import * as os from "node:os";
 import * as path2 from "node:path";
@@ -3831,6 +3854,7 @@ function collectWalkIndexFiles(root, opts = {}) {
 }
 
 // src/bridges/gemini_install.ts
+init_define_import_meta_env();
 import * as fs3 from "node:fs";
 import * as os2 from "node:os";
 import * as path3 from "node:path";
@@ -3974,6 +3998,7 @@ function isGeminiInstalled() {
 }
 
 // src/bridges/qwen_install.ts
+init_define_import_meta_env();
 import * as fs4 from "node:fs";
 import * as os3 from "node:os";
 import * as path4 from "node:path";
@@ -4098,11 +4123,13 @@ function isQwenInstalled() {
 }
 
 // src/bridges/pi_install.ts
+init_define_import_meta_env();
 import * as fs5 from "node:fs";
 import * as os4 from "node:os";
 import * as path5 from "node:path";
 
 // src/bridges/pi.ts
+init_define_import_meta_env();
 var PI_EXTENSION_SCRIPT = `// token-goat bridge extension for pi (pi-coding-agent)
 // Bridges pi's extension events to token-goat's subprocess hook protocol.
 // https://github.com/DFKHelper/token-goat
@@ -4493,11 +4520,16 @@ function isPiInstalled(opts = {}) {
 }
 
 // src/bridges/opencode_install.ts
+init_define_import_meta_env();
 import * as fs6 from "node:fs";
 import * as os5 from "node:os";
 import * as path6 from "node:path";
 
+// src/bridges/opencode.ts
+init_define_import_meta_env();
+
 // src/bridges/relay_block.ts
+init_define_import_meta_env();
 var BRIDGE_RELAY_JS = `// resolveEntryPath reads a sidecar JSON file (token-goat-entry.json, written by
 // the install step next to this plugin file) containing the absolute path to
 // the token-goat CLI entry that was running at install time. Unlike
@@ -4787,11 +4819,13 @@ function isOpencodeInstalled() {
 }
 
 // src/bridges/openclaw_install.ts
+init_define_import_meta_env();
 import * as fs7 from "node:fs";
 import * as os6 from "node:os";
 import * as path7 from "node:path";
 
 // src/bridges/openclaw.ts
+init_define_import_meta_env();
 var OPENCLAW_PLUGIN_SCRIPT = `// token-goat bridge plugin for OpenClaw
 // Bridges OpenClaw's tool-call and session hooks to token-goat's subprocess
 // hook protocol. https://github.com/DFKHelper/token-goat
@@ -5098,6 +5132,7 @@ function isOpenclawInstalled() {
 }
 
 // src/bridges_status.ts
+init_define_import_meta_env();
 var NO_SERVER_HANDLER_REASON = "token-goat has no registered server-side handler for this event (zero registerHook('notification'|'stop', ...) call sites in src/) -- wiring it client-side would currently be a no-op";
 var NO_POST_COMPACT_EVENT_REASON = "post_compact is a Claude Code event (hook_event_name PostCompact, carrying compact_summary); no equivalent has been confirmed for this harness, so it is left unwired rather than guessed at";
 var NO_SEPARATE_FAILURE_EVENT_REASON = "post_tool_use_failure exists because Copilot CLI routes a failed tool result to a separate postToolUseFailure event instead of postToolUse. No separate failure event is wired for this harness, so a failed tool call either arrives on post_tool_use like any other result or is not seen; which of the two has not been checked here";
@@ -5401,6 +5436,7 @@ function installVerificationNotice(harness) {
 }
 
 // src/sharepoint_resolve.ts
+init_define_import_meta_env();
 import * as fs8 from "node:fs";
 import * as os7 from "node:os";
 import * as path8 from "node:path";
@@ -5508,6 +5544,7 @@ function resolveLocalPath(parsed, env = process.env, home = os7.homedir()) {
 }
 
 // src/video_chapters.ts
+init_define_import_meta_env();
 import { spawnSync } from "node:child_process";
 var _ffprobeAvailable;
 function isFfprobeAvailable() {
@@ -5555,6 +5592,7 @@ function extractVideoChapters(file) {
 }
 
 // src/transcript_extract.ts
+init_define_import_meta_env();
 import * as fs9 from "node:fs";
 var TIMESTAMP_RE = /(\d{1,2}:)?(\d{2}):(\d{2})[.,](\d{1,3})/;
 var CUE_LINE_RE = new RegExp(`^\\s*${TIMESTAMP_RE.source}\\s*-->\\s*${TIMESTAMP_RE.source}`);
@@ -5668,6 +5706,7 @@ function formatCues(cues) {
 }
 
 // src/affected.ts
+init_define_import_meta_env();
 import * as path9 from "node:path";
 var DEFAULT_AFFECTED_DEPTH = 5;
 function emit(text) {
@@ -5769,6 +5808,7 @@ function runAffected(opts) {
 }
 
 // src/purge.ts
+init_define_import_meta_env();
 import * as fs10 from "node:fs";
 import * as path10 from "node:path";
 function directorySize(root) {
@@ -5822,6 +5862,7 @@ function formatBytes2(bytes) {
 }
 
 // src/cli_stats.ts
+init_define_import_meta_env();
 import * as fs11 from "node:fs";
 import * as path11 from "node:path";
 function writeRaw(text) {
@@ -5944,6 +5985,7 @@ function runStats(opts = {}) {
 }
 
 // src/cli_doctor.ts
+init_define_import_meta_env();
 import * as fs12 from "fs";
 import * as os8 from "os";
 import * as path12 from "path";
@@ -6157,19 +6199,19 @@ function checkEmbeddingCoverage(dbPath, rootDir) {
     if (indexedFiles === 0) {
       return { name: "Embedding coverage", status: "ok", message: "no indexed files yet" };
     }
-    const pct2 = Math.round(embeddedFiles / indexedFiles * 100);
+    const pct3 = Math.round(embeddedFiles / indexedFiles * 100);
     const sizeKb = cfg.indexing.large_file_symbol_only_kb;
     if (embeddedFiles / indexedFiles < EMBED_COVERAGE_WARN_FRACTION) {
       return {
         name: "Embedding coverage",
         status: "warn",
-        message: `only ${embeddedFiles} of ${indexedFiles} indexed file(s) (${pct2}%) have embeddings \u2014 'semantic' searches those files only, and reports finding nothing in the same words it uses after searching everything. Files over indexing.large_file_symbol_only_kb (currently ${sizeKb} KB) are indexed for symbols only and are the usual reason; raise it with 'token-goat config set indexing.large_file_symbol_only_kb <KB>' and re-embed with 'token-goat index --force' to widen coverage. Exact symbol lookups are unaffected`
+        message: `only ${embeddedFiles} of ${indexedFiles} indexed file(s) (${pct3}%) have embeddings \u2014 'semantic' searches those files only, and reports finding nothing in the same words it uses after searching everything. Files over indexing.large_file_symbol_only_kb (currently ${sizeKb} KB) are indexed for symbols only and are the usual reason; raise it with 'token-goat config set indexing.large_file_symbol_only_kb <KB>' and re-embed with 'token-goat index --force' to widen coverage. Exact symbol lookups are unaffected`
       };
     }
     return {
       name: "Embedding coverage",
       status: "ok",
-      message: `${embeddedFiles} of ${indexedFiles} indexed file(s) (${pct2}%) have embeddings`
+      message: `${embeddedFiles} of ${indexedFiles} indexed file(s) (${pct3}%) have embeddings`
     };
   } catch (err2) {
     return {
@@ -6179,6 +6221,38 @@ function checkEmbeddingCoverage(dbPath, rootDir) {
     };
   }
 }
+var PARSER_FRESHNESS_WARN_FRACTION = 0.25;
+function checkParserFreshness(dbPath, rootDir) {
+  if (!fs12.existsSync(dbPath)) {
+    return { name: "Parser freshness", status: "ok", message: "no database yet" };
+  }
+  try {
+    const { indexedFiles, currentFiles } = getParserFreshness(dbPath, PARSER_FINGERPRINT, rootDir);
+    if (indexedFiles === 0) {
+      return { name: "Parser freshness", status: "ok", message: "no indexed files yet" };
+    }
+    const stale = indexedFiles - currentFiles;
+    const pct3 = Math.round(stale / indexedFiles * 100);
+    if (currentFiles / indexedFiles < 1 - PARSER_FRESHNESS_WARN_FRACTION) {
+      return {
+        name: "Parser freshness",
+        status: "warn",
+        message: `${stale} of ${indexedFiles} indexed file(s) (${pct3}%) were parsed by a different build of the extraction logic, so their symbols are whatever that build extracted \u2014 'symbol', 'read', 'outline' and 'skeleton' answer from those rows, and the read-hook body fold declines on them. Run 'token-goat index' in this project to reparse them; --force is not needed, a parser mismatch reindexes on its own`
+      };
+    }
+    return {
+      name: "Parser freshness",
+      status: "ok",
+      message: `${currentFiles} of ${indexedFiles} indexed file(s) match the running parser`
+    };
+  } catch (err2) {
+    return {
+      name: "Parser freshness",
+      status: "warn",
+      message: `could not query parser freshness: ${extractErrorMessage(err2)}`
+    };
+  }
+}
 var DIRTY_QUEUE_BACKLOG_WARN_THRESHOLD = 500;
 function checkDirtyQueueHealth(dataDir2) {
   let pendingCount = 0;
@@ -6414,6 +6488,7 @@ var LOCKED_BOOLEAN_SAFE_VALUE = {
   "screenshot.block_private_targets": true,
   "network.offline": true,
   "indexing.cross_project_symbols": false,
+  "hints.fold_code_bodies": false,
   "webfetch.compress_bodies": true
 };
 function lockedEnvOverridableKeys() {
@@ -6616,6 +6691,7 @@ function runDoctor(dataDir2, configPath2, rootDir, processes) {
   results.push(checkConfigValid(actualConfigPath));
   results.push(checkEmbeddings(loadConfig(rootDir)));
   results.push(checkEmbeddingCoverage(path12.join(actualDataDir, "global.db"), rootDir));
+  results.push(checkParserFreshness(path12.join(actualDataDir, "global.db"), rootDir));
   for (const result of checkSecurityPosture(loadConfig(rootDir), actualDataDir)) results.push(result);
   results.push(checkDiskSpace(actualDataDir));
   const copilotResult = checkCopilotCli(copilotCliConfigPath(), copilotCliScriptPath());
@@ -6689,6 +6765,7 @@ async function runDoctorAndExit(opts) {
 }
 
 // src/capabilities.ts
+init_define_import_meta_env();
 function collectCapabilities(config = loadConfig()) {
   const online = !config.network.offline;
   return [
@@ -6772,7 +6849,11 @@ function renderCapabilities(caps) {
   return lines.join("\n");
 }
 
+// src/gdrive.ts
+init_define_import_meta_env();
+
 // src/webfetch.ts
+init_define_import_meta_env();
 import { existsSync as existsSync7, readdirSync as readdirSync5, statSync as statSync4, unlinkSync as unlinkSync2 } from "fs";
 import * as http from "http";
 import * as https from "https";
@@ -7231,6 +7312,7 @@ async function getSectionContent(fileId, heading, opts = {}) {
 }
 
 // src/pack.ts
+init_define_import_meta_env();
 import * as fs13 from "node:fs";
 import * as path14 from "node:path";
 
@@ -7250,8 +7332,13 @@ __export(esm_exports, {
   sep: () => sep2,
   unescape: () => unescape
 });
+init_define_import_meta_env();
+
+// node_modules/brace-expansion/dist/esm/index.js
+init_define_import_meta_env();
 
 // node_modules/balanced-match/dist/esm/index.js
+init_define_import_meta_env();
 var balanced = (a, b, str) => {
   const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
   const mb2 = b instanceof RegExp ? maybeMatch(b, str) : b;
@@ -7518,6 +7605,7 @@ function expand_(str, max, maxLength, isTop) {
 }
 
 // node_modules/minimatch/dist/esm/assert-valid-pattern.js
+init_define_import_meta_env();
 var MAX_PATTERN_LENGTH = 1024 * 64;
 var assertValidPattern = (pattern) => {
   if (typeof pattern !== "string") {
@@ -7528,7 +7616,11 @@ var assertValidPattern = (pattern) => {
   }
 };
 
+// node_modules/minimatch/dist/esm/ast.js
+init_define_import_meta_env();
+
 // node_modules/minimatch/dist/esm/brace-expressions.js
+init_define_import_meta_env();
 var posixClasses = {
   "[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
   "[:alpha:]": ["\\p{L}\\p{Nl}", true],
@@ -7638,6 +7730,7 @@ var parseClass = (glob, position) => {
 };
 
 // node_modules/minimatch/dist/esm/unescape.js
+init_define_import_meta_env();
 var unescape = (s, { windowsPathsNoEscape = false, magicalBraces = true } = {}) => {
   if (magicalBraces) {
     return windowsPathsNoEscape ? s.replace(/\[([^/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^/\\])\]/g, "$1$2").replace(/\\([^/])/g, "$1");
@@ -8290,6 +8383,7 @@ var AST = class {
 _a = AST;
 
 // node_modules/minimatch/dist/esm/escape.js
+init_define_import_meta_env();
 var escape = (s, { windowsPathsNoEscape = false, magicalBraces = false } = {}) => {
   if (magicalBraces) {
     return windowsPathsNoEscape ? s.replace(/[?*()[\]{}]/g, "[$&]") : s.replace(/[?*()[\]\\{}]/g, "\\$&");
@@ -9565,12 +9659,12 @@ function formatBudgetText(result, contextK) {
     lines.push(`  ${e.rel_path.padEnd(colW, " ")}  ${String(e.lines).padStart(6, " ")}  ${String(e.tokens).padStart(8, " ")}`);
   }
   lines.push(`  ${"-".repeat(colW)}  ${"-".repeat(6)}  ${"-".repeat(8)}`);
-  let pct2 = "";
+  let pct3 = "";
   if (contextK) {
-    pct2 = `  (${Math.round(result.total_tokens / (contextK * 1e3) * 100)}% of ${contextK}K)`;
+    pct3 = `  (${Math.round(result.total_tokens / (contextK * 1e3) * 100)}% of ${contextK}K)`;
   }
   lines.push(
-    `  ${"Total".padEnd(colW, " ")}  ${String(result.total_lines).padStart(6, " ")}  ${String(result.total_tokens).padStart(8, " ")}${pct2}`
+    `  ${"Total".padEnd(colW, " ")}  ${String(result.total_lines).padStart(6, " ")}  ${String(result.total_tokens).padStart(8, " ")}${pct3}`
   );
   if (result.skipped.length > 0) {
     const skipped = result.skipped.slice(0, 5).join(", ");
@@ -9582,6 +9676,7 @@ function formatBudgetText(result, contextK) {
 }
 
 // src/failures.ts
+init_define_import_meta_env();
 function getFailureCount(result) {
   return result.blocks.length || result.summaryLines.length;
 }
@@ -10006,6 +10101,7 @@ function formatFailureDeltaJson(delta, runner) {
 }
 
 // src/failures_state.ts
+init_define_import_meta_env();
 import * as fs14 from "node:fs";
 import * as path15 from "node:path";
 var KEY_RE = /^[A-Za-z0-9_-]{1,80}$/;
@@ -10051,10 +10147,12 @@ function saveFailureSnapshot(projectHash, key, snapshot) {
 }
 
 // src/text_commands.ts
+init_define_import_meta_env();
 import * as fs16 from "fs";
 import * as path17 from "path";
 
 // src/project_memory.ts
+init_define_import_meta_env();
 import * as fs15 from "node:fs";
 import * as path16 from "node:path";
 var MAX_ENTRIES = 30;
@@ -11278,6 +11376,7 @@ function countPackIgnorePatterns(root) {
 }
 
 // src/dep_docs.ts
+init_define_import_meta_env();
 import { createRequire } from "node:module";
 import * as fs17 from "node:fs";
 import * as path18 from "node:path";
@@ -11565,7 +11664,11 @@ function runDepDocs(opts) {
   return { text, code: 0 };
 }
 
+// src/cache_session_commands.ts
+init_define_import_meta_env();
+
 // src/resume.ts
+init_define_import_meta_env();
 import { readFile } from "node:fs/promises";
 var MAX_RESUME_TOKENS = 2e3;
 var MAX_RESUME_CHARS = MAX_RESUME_TOKENS * 4;
@@ -11905,15 +12008,15 @@ function cmdCompactHint(opts) {
   const pressure = getContextPressure(cache ?? void 0);
   const [manifest, eventCount] = sessionId !== null ? buildManifestWithCount(sessionId) : ["", 0];
   const manifestTokens = estimateTokens(manifest);
-  const pct2 = (pressure.fillFraction * 100).toFixed(1);
+  const pct3 = (pressure.fillFraction * 100).toFixed(1);
   if (opts.json === true) {
-    const out2 = { tier: pressure.tier, fillFraction: pressure.fillFraction, pct: Number(pct2), manifestTokens, eventCount };
+    const out2 = { tier: pressure.tier, fillFraction: pressure.fillFraction, pct: Number(pct3), manifestTokens, eventCount };
     if (sessionId !== null) out2["sessionId"] = sessionId;
     if (opts.trigger !== void 0) out2["trigger"] = opts.trigger;
     process.stdout.write(JSON.stringify(out2, null, 2) + "\n");
     return;
   }
-  process.stdout.write(`Compact hint \u2014 context: ${pressure.tier} (${pct2}% full)
+  process.stdout.write(`Compact hint \u2014 context: ${pressure.tier} (${pct3}% full)
 `);
   if (sessionId !== null) process.stdout.write(`Session: ${sessionId}
 `);
@@ -12000,6 +12103,7 @@ function cmdBaseline(opts) {
 }
 
 // src/index_reclaim.ts
+init_define_import_meta_env();
 import * as fs18 from "node:fs";
 import * as path19 from "node:path";
 var DERIVED_TABLES = ["chunk_vectors", "chunks", "refs", "symbols", "files"];
@@ -12126,6 +12230,7 @@ function cmdReclaimIndex(opts) {
 }
 
 // src/config_commands.ts
+init_define_import_meta_env();
 import * as fs19 from "node:fs";
 import * as os9 from "node:os";
 import * as path20 from "node:path";
@@ -12795,6 +12900,7 @@ function cmdHistory(opts) {
 }
 
 // src/cli_bootstrap_audit.ts
+init_define_import_meta_env();
 import * as fs20 from "node:fs";
 import * as os10 from "node:os";
 import * as path21 from "node:path";
@@ -13011,6 +13117,7 @@ async function runBootstrapAudit(opts = {}) {
 }
 
 // src/cli_memory.ts
+init_define_import_meta_env();
 import * as fs21 from "node:fs";
 import * as path22 from "node:path";
 function removeExactDupLines(text, report) {
@@ -13130,10 +13237,12 @@ async function runMemoryCommand(opts = {}) {
 }
 
 // src/cli_waste.ts
+init_define_import_meta_env();
 import * as fs24 from "node:fs";
 import * as path25 from "node:path";
 
 // src/waste.ts
+init_define_import_meta_env();
 import * as fs22 from "node:fs";
 import * as os11 from "node:os";
 import * as path23 from "node:path";
@@ -13381,6 +13490,7 @@ async function buildWasteReport(transcriptPath, opts = {}) {
 }
 
 // src/copilot_waste.ts
+init_define_import_meta_env();
 import * as fs23 from "node:fs";
 import * as path24 from "node:path";
 var HOOK_RECORD_TYPES = /* @__PURE__ */ new Set(["hook.start", "hook.end"]);
@@ -13535,10 +13645,10 @@ function printCopilotReport(report) {
     w(`  Conversation:      ${conversationTokens.toLocaleString()} tok
 `);
     if (total > 0) {
-      const pct2 = (fixed / total * 100).toFixed(1);
+      const pct3 = (fixed / total * 100).toFixed(1);
       w(`  ${fixed.toLocaleString()} tok of system prompt and tool definitions ships with every
 `);
-      w(`  request; at shutdown that was ${pct2}% of the context. No hook can reach it: Copilot
+      w(`  request; at shutdown that was ${pct3}% of the context. No hook can reach it: Copilot
 `);
       w("  assembles both natively, with nothing between assembly and send. The levers are all\n");
       w("  config: fewer MCP servers and custom tools, and --excluded-tools / --available-tools /\n");
@@ -13598,9 +13708,9 @@ function printCopilotReport(report) {
 `);
   } else {
     for (const block of report.blocks) {
-      const pct2 = block.bytes > 0 ? (block.repeatBytes / block.bytes * 100).toFixed(1) : "0.0";
+      const pct3 = block.bytes > 0 ? (block.repeatBytes / block.bytes * 100).toFixed(1) : "0.0";
       w(`  ${block.kind}: ${countNoun(block.count, "injection")}, ${formatBytes(block.bytes)}`);
-      w(block.repeatBytes > 0 ? `, ${formatBytes(block.repeatBytes)} re-sent verbatim (${pct2}%)
+      w(block.repeatBytes > 0 ? `, ${formatBytes(block.repeatBytes)} re-sent verbatim (${pct3}%)
 ` : "\n");
     }
   }
@@ -13765,6 +13875,7 @@ async function runWasteCommand(opts = {}) {
 }
 
 // src/session_read.ts
+init_define_import_meta_env();
 import * as fs25 from "node:fs";
 import * as path26 from "node:path";
 import * as readline2 from "node:readline";
@@ -13931,6 +14042,7 @@ function formatSessionSlice(turns) {
 }
 
 // src/session_audit.ts
+init_define_import_meta_env();
 import * as fs26 from "node:fs";
 import * as os12 from "node:os";
 import * as path27 from "node:path";
@@ -14288,13 +14400,13 @@ async function auditOneFile(filePath, s, toolMap, attachmentMap, hookMap, laneOb
             s.readInterception.readResults += 1;
             const denyTemplate = DENY_TEMPLATES.find((t) => t.re.test(text));
             if (denyTemplate !== void 0) {
-              const path30 = readPathById.get(id) ?? "";
-              const lastSlash = path30.lastIndexOf("/");
+              const path31 = readPathById.get(id) ?? "";
+              const lastSlash = path31.lastIndexOf("/");
               openDenies.push({
                 kind: denyTemplate.kind,
                 withheldBytes: parseWithheldBytes(denyTemplate.kind, text),
-                path: path30,
-                basename: lastSlash === -1 ? path30 : path30.slice(lastSlash + 1),
+                path: path31,
+                basename: lastSlash === -1 ? path31 : path31.slice(lastSlash + 1),
                 callIndexAtDeny: perCall.length,
                 compactEpochAtOpen: compactEpoch,
                 compactEpochAtWindow: null,
@@ -14762,6 +14874,7 @@ function formatSessionAudit(s) {
 }
 
 // src/cli_mcp_audit.ts
+init_define_import_meta_env();
 import * as fs27 from "node:fs";
 import * as os13 from "node:os";
 import * as path28 from "node:path";
@@ -14915,6 +15028,7 @@ async function runMcpAuditCommand(opts = {}) {
 }
 
 // src/cli_recall.ts
+init_define_import_meta_env();
 var RECALL_COMMAND = {
   bash: "bash-output",
   web: "web-output",
@@ -14974,7 +15088,231 @@ function runRecallCommand(query, opts = {}) {
   printHits(browse ? void 0 : query, hits);
 }
 
+// src/cli_bench.ts
+init_define_import_meta_env();
+import * as fs28 from "node:fs";
+import * as path29 from "node:path";
+var ControlFilter = class extends ToolFilter {
+  constructor(name, transform) {
+    super();
+    this.name = name;
+    this.transform = transform;
+  }
+  name;
+  transform;
+  apply(stdout, stderr, exitCode) {
+    const originalBytes = Buffer.byteLength(stdout, "utf8") + Buffer.byteLength(stderr, "utf8");
+    const text = this.transform(combineStreams(stdout, stderr));
+    return new CompressedOutput(text, originalBytes, Buffer.byteLength(text, "utf8"), this.name, exitCode);
+  }
+};
+var CONTROL_FILTERS = {
+  identity: new ControlFilter("control:identity", (s) => s),
+  destroy: new ControlFilter("control:destroy", () => "")
+};
+var MAX_BENCH_FILE_BYTES = 5 * 1024 * 1024;
+function readCaseFile(id, filePath, what) {
+  const bytes = fs28.statSync(filePath).size;
+  if (bytes > MAX_BENCH_FILE_BYTES) {
+    throw new Error(
+      `bench case ${id}: ${what} is ${bytes} bytes, over the ${MAX_BENCH_FILE_BYTES}-byte limit for a corpus file (${filePath})`
+    );
+  }
+  return fs28.readFileSync(filePath, "utf8");
+}
+function parseCase(id, metaPath, outputPath) {
+  const metaText = readCaseFile(id, metaPath, "metadata");
+  let raw;
+  try {
+    raw = JSON.parse(metaText);
+  } catch (e) {
+    throw new Error(`bench case ${id}: ${metaPath} is not valid JSON (${e instanceof Error ? e.message : String(e)})`, { cause: e });
+  }
+  if (typeof raw !== "object" || raw === null) throw new Error(`bench case ${id}: expected a JSON object`);
+  const meta = raw;
+  const str = (key) => {
+    const v = meta[key];
+    if (typeof v !== "string" || v.trim() === "") throw new Error(`bench case ${id}: "${key}" must be a non-empty string`);
+    return v;
+  };
+  const mustKeep = meta["mustKeep"];
+  if (!Array.isArray(mustKeep) || mustKeep.some((s) => typeof s !== "string" || s === "")) {
+    throw new Error(`bench case ${id}: "mustKeep" must be an array of non-empty strings`);
+  }
+  const exitCode = meta["exitCode"];
+  if (exitCode !== void 0 && typeof exitCode !== "number") throw new Error(`bench case ${id}: "exitCode" must be a number`);
+  return {
+    id,
+    provenance: str("provenance"),
+    command: str("command"),
+    exitCode: typeof exitCode === "number" ? exitCode : 0,
+    mustKeep,
+    output: readCaseFile(id, outputPath, "output")
+  };
+}
+function loadCorpus(dir) {
+  let entries;
+  try {
+    entries = fs28.readdirSync(dir);
+  } catch {
+    throw new Error(`bench corpus not found: ${dir}`);
+  }
+  const cases = [];
+  for (const entry of entries.sort()) {
+    if (!entry.endsWith(".json")) continue;
+    const id = entry.slice(0, -".json".length);
+    const outputPath = path29.join(dir, `${id}.txt`);
+    if (!fs28.existsSync(outputPath)) throw new Error(`bench case ${id}: missing output file ${outputPath}`);
+    cases.push(parseCase(id, path29.join(dir, entry), outputPath));
+  }
+  if (cases.length === 0) throw new Error(`bench corpus is empty: ${dir}`);
+  return cases;
+}
+function runCase(c, control = "none") {
+  const detected = detectFromCommand(c.command);
+  const filter2 = control === "none" ? detected?.filter : CONTROL_FILTERS[control];
+  const argv = detected?.argv ?? [];
+  const delivery = filter2 ? deliverCompressed(filter2, c.output, "", c.exitCode, argv) : null;
+  const body = delivery ? delivery.text + delivery.marker : c.output;
+  const originalBytes = Buffer.byteLength(c.output, "utf8");
+  const deliveredBytes = Buffer.byteLength(body, "utf8");
+  const missing = c.mustKeep.filter((needle) => !body.includes(needle));
+  return {
+    id: c.id,
+    command: c.command,
+    filter: filter2?.name ?? null,
+    applied: delivery?.applied ?? false,
+    originalBytes,
+    deliveredBytes,
+    savedPercent: originalBytes > 0 ? 100 * Math.max(0, originalBytes - deliveredBytes) / originalBytes : 0,
+    kept: c.mustKeep.length - missing.length,
+    mustKeepTotal: c.mustKeep.length,
+    missing
+  };
+}
+function runCorpus(cases, control = "none") {
+  const results = cases.map((c) => runCase(c, control));
+  const sum = (pick) => results.reduce((n, r) => n + pick(r), 0);
+  const originalBytes = sum((r) => r.originalBytes);
+  const deliveredBytes = sum((r) => r.deliveredBytes);
+  const kept = sum((r) => r.kept);
+  const mustKeepTotal = sum((r) => r.mustKeepTotal);
+  return {
+    cases: results,
+    originalBytes,
+    deliveredBytes,
+    ratioPercent: originalBytes > 0 ? 100 * Math.max(0, originalBytes - deliveredBytes) / originalBytes : 0,
+    kept,
+    mustKeepTotal,
+    appliedCases: results.filter((r) => r.applied).length,
+    coveredFilters: new Set(results.map((r) => r.filter).filter((n) => n !== null)).size,
+    registeredFilters: TOOL_FILTERS.length,
+    fidelityIntact: kept === mustKeepTotal
+  };
+}
+var pct2 = (n) => `${n.toFixed(1)}%`;
+function renderTable(report, floorPercent) {
+  const rows = [...report.cases].sort((a, b) => b.originalBytes - a.originalBytes);
+  const idWidth = Math.max(4, ...rows.map((r) => r.id.length));
+  const filterWidth = Math.max(6, ...rows.map((r) => (r.filter ?? "-").length));
+  const lines = [];
+  const header = `${"case".padEnd(idWidth)}  ${"filter".padEnd(filterWidth)}  ${"in".padStart(9)}  ${"out".padStart(9)}  ${"saved".padStart(7)}  fidelity`;
+  lines.push(header, "-".repeat(header.length));
+  for (const r of rows) {
+    const saved = r.applied ? pct2(r.savedPercent) : "-";
+    const fidelity = `${r.kept}/${r.mustKeepTotal}${r.missing.length ? " FAIL" : ""}`;
+    lines.push(
+      `${r.id.padEnd(idWidth)}  ${(r.filter ?? "-").padEnd(filterWidth)}  ${String(r.originalBytes).padStart(9)}  ${String(r.deliveredBytes).padStart(9)}  ${saved.padStart(7)}  ${fidelity}`
+    );
+  }
+  lines.push("-".repeat(header.length));
+  lines.push(
+    `${"TOTAL".padEnd(idWidth)}  ${"".padEnd(filterWidth)}  ${String(report.originalBytes).padStart(9)}  ${String(report.deliveredBytes).padStart(9)}  ${pct2(report.ratioPercent).padStart(7)}  ${report.kept}/${report.mustKeepTotal}`
+  );
+  lines.push("");
+  lines.push(`ratio    ${pct2(report.ratioPercent)} saved  (PRIMARY -- must improve; measured floor ${pct2(floorPercent)}, headroom ${pct2(100 - report.ratioPercent)})`);
+  lines.push(`fidelity ${report.kept}/${report.mustKeepTotal} kept   (GUARD -- must not regress; any miss exits 1)`);
+  lines.push(`coverage ${report.coveredFilters}/${report.registeredFilters} filters exercised, ${report.appliedCases}/${report.cases.length} cases compressed`);
+  for (const r of report.cases) {
+    for (const needle of r.missing) lines.push(`  DROPPED  ${r.id}: ${JSON.stringify(needle)}`);
+  }
+  return lines.join("\n");
+}
+function renderValidation(cases) {
+  const identity = runCorpus(cases, "identity");
+  const destroy = runCorpus(cases, "destroy");
+  const checks = [
+    {
+      // Not "scores exactly 0%": the unapplied path delivers the streams recombined, which can
+      // differ from the captured bytes by a trailing newline. That is a real property of delivery,
+      // so the floor is measured and reported rather than assumed -- what must hold is that the
+      // net-benefit gate REFUSED every no-op rewrite, which is what makes the floor a floor.
+      label: "floor: the net-benefit gate refuses a no-op filter on every case",
+      ok: identity.appliedCases === 0,
+      detail: `identity control applied to ${identity.appliedCases}/${identity.cases.length} cases, measured floor ${pct2(identity.ratioPercent)}`
+    },
+    {
+      label: "floor: a no-op filter keeps every must-keep line",
+      ok: identity.fidelityIntact,
+      detail: `identity control kept ${identity.kept}/${identity.mustKeepTotal}`
+    },
+    {
+      label: "guard: deleting everything is caught",
+      ok: !destroy.fidelityIntact,
+      detail: `destroy control kept ${destroy.kept}/${destroy.mustKeepTotal} at ${pct2(destroy.ratioPercent)} saved`
+    }
+  ];
+  const failed = checks.filter((c) => !c.ok);
+  const lines = checks.map((c) => `${c.ok ? "ok  " : "FAIL"}  ${c.label} -- ${c.detail}`);
+  lines.push("");
+  lines.push(
+    failed.length === 0 ? "The corpus discriminates: a ratio measured against it cannot be raised by deleting content." : `${failed.length} control check(s) failed. Do not optimise against this corpus until they pass.`
+  );
+  return { text: lines.join("\n"), code: failed.length === 0 ? 0 : 1 };
+}
+var TSV_HEADER = "timestamp	commit	cases	original_bytes	delivered_bytes	ratio_percent	fidelity_kept	fidelity_total	covered_filters\n";
+function appendTsv(file, report, commit) {
+  const row = [
+    (/* @__PURE__ */ new Date()).toISOString(),
+    commit,
+    report.cases.length,
+    report.originalBytes,
+    report.deliveredBytes,
+    report.ratioPercent.toFixed(2),
+    report.kept,
+    report.mustKeepTotal,
+    report.coveredFilters
+  ].join("	");
+  const dir = path29.dirname(path29.resolve(file));
+  fs28.mkdirSync(dir, { recursive: true });
+  const header = fs28.existsSync(file) ? "" : TSV_HEADER;
+  fs28.appendFileSync(file, header + row + "\n", "utf8");
+}
+function currentCommit(cwd) {
+  const opts = cwd === void 0 ? {} : { cwd };
+  try {
+    const r = runGit(["rev-parse", "--short", "HEAD"], opts);
+    const sha = r.stdout.trim();
+    if (r.exitCode !== 0 || sha === "") return "unknown";
+    const st = runGit(["status", "--porcelain"], opts);
+    return st.exitCode === 0 && st.stdout.trim() !== "" ? `${sha}-dirty` : sha;
+  } catch {
+    return "unknown";
+  }
+}
+function runBenchCommand(opts) {
+  const cases = loadCorpus(opts.corpus);
+  if (opts.validate === true) return renderValidation(cases);
+  const report = runCorpus(cases);
+  if (opts.tsv !== void 0) appendTsv(opts.tsv, report, currentCommit());
+  const code = report.fidelityIntact ? 0 : 1;
+  const floorPercent = runCorpus(cases, "identity").ratioPercent;
+  if (opts.json === true) return { text: JSON.stringify({ ...report, floorPercent }, null, 2), code };
+  return { text: renderTable(report, floorPercent), code };
+}
+
 // src/cli_hint_stats.ts
+init_define_import_meta_env();
 function formatSpentCell(row) {
   if (row.emitted === 0) return "n/a";
   if (row.bytesEmitted === null) return "n/a (legacy)";
@@ -14984,15 +15322,18 @@ function suppressedCell(row) {
   if (!row.suppressed) return "no";
   return row.suppressionPermanent ? "yes (permanent)" : "yes";
 }
+function efficacyCell(row) {
+  const pct3 = row.efficacyPct === null ? "n/a" : `${row.efficacyPct}%`;
+  return isSuppressionCategory(row.category) ? `${pct3} *` : pct3;
+}
 function printSummary(rows) {
   const w = (text) => {
     process.stdout.write(text);
   };
-  w(pad("category", 22) + pad("emitted", 9) + pad("acted-on", 10) + pad("efficacy", 10) + pad("suppressed", 17) + pad("manual+", 9) + pad("manual-", 9) + "spent\n");
+  w(pad("category", 22) + pad("emitted", 9) + pad("acted-on", 10) + pad("efficacy", 12) + pad("suppressed", 17) + pad("manual+", 9) + pad("manual-", 9) + "spent\n");
   for (const row of rows) {
-    const pct2 = row.efficacyPct === null ? "n/a" : `${row.efficacyPct}%`;
     w(
-      pad(row.category, 22) + pad(String(row.emitted), 9) + pad(String(row.actedOn), 10) + pad(pct2, 10) + pad(suppressedCell(row), 17) + pad(String(row.manualEffective), 9) + pad(String(row.manualIneffective), 9) + formatSpentCell(row) + "\n"
+      pad(row.category, 22) + pad(String(row.emitted), 9) + pad(String(row.actedOn), 10) + pad(efficacyCell(row), 12) + pad(suppressedCell(row), 17) + pad(String(row.manualEffective), 9) + pad(String(row.manualIneffective), 9) + formatSpentCell(row) + "\n"
     );
   }
 }
@@ -15033,6 +15374,11 @@ function runHintStatsCommand(opts = {}) {
     process.stdout.write("No hint emissions recorded yet \u2014 the zeros below are absence of data, not measured ineffectiveness.\n");
   }
   printSummary(rows);
+  if (rows.some((r) => isSuppressionCategory(r.category) && r.emitted > 0)) {
+    process.stdout.write(
+      '\n* Scored on an absence: these hints ask the agent NOT to do something, so a window that expires with no re-read counts as compliance. Their percentage is not comparable with the unmarked rows, which only count when the agent runs the command the hint named. A high starred figure means "the warned-against read was not seen", not "this hint persuaded anyone".\n'
+    );
+  }
   const permanent = rows.filter((r) => r.suppressionPermanent);
   if (permanent.length > 0) {
     const names = permanent.map((r) => r.category).join(", ");
@@ -15044,6 +15390,7 @@ hints.backoff_thresholds is empty, so suppression here is permanent rather than
 }
 
 // src/cli_statusline.ts
+init_define_import_meta_env();
 var STDIN_TIMEOUT_MS = 1500;
 function isPlainObject(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
@@ -15137,10 +15484,10 @@ function readBoundedText(text, file) {
   if (text === void 0 && file === void 0) throw new CliError("provide text or --file");
   let value;
   if (file !== void 0) {
-    if (fs28.statSync(file).size > CONTENT_MAX_INPUT_CHARS) {
+    if (fs29.statSync(file).size > CONTENT_MAX_INPUT_CHARS) {
       throw new CliError(`file exceeds the ${CONTENT_MAX_INPUT_CHARS}-byte safety limit`);
     }
-    value = fs28.readFileSync(file, "utf8");
+    value = fs29.readFileSync(file, "utf8");
   } else {
     if (text === void 0) throw new CliError("provide text or --file");
     value = text;
@@ -15278,7 +15625,7 @@ async function cmdIndex(pathArg, opts = {}) {
       continue;
     }
     const sha = fingerprintFile(key);
-    if (sha === null && !fs28.existsSync(key)) continue;
+    if (sha === null && !fs29.existsSync(key)) continue;
     const entry = sha !== null ? getFileEntry(key, dbPath) : null;
     const spellingStale = entry !== null && indexedPathSpellingIsStale(entry.filePath, key);
     const parseUnchanged = !force && !spellingStale && sha !== null && entry?.sha === sha && entry.parserSha === PARSER_FINGERPRINT;
@@ -15304,7 +15651,7 @@ async function cmdIndex(pathArg, opts = {}) {
         }
         continue;
       }
-      if (!fs28.existsSync(key)) continue;
+      if (!fs29.existsSync(key)) continue;
     }
     if (!embedUnchanged) {
       paintProgress("embedding");
@@ -15364,8 +15711,8 @@ async function cmdMcpServe() {
   let StdioServerTransport;
   try {
     ;
-    ({ createMcpServer } = await import("./token-goat-chunk-LEBYARO3.mjs"));
-    ({ StdioServerTransport } = await import("./token-goat-chunk-324QOJYZ.mjs"));
+    ({ createMcpServer } = await import("./token-goat-chunk-OZAEJQ7L.mjs"));
+    ({ StdioServerTransport } = await import("./token-goat-chunk-EVC4TOLE.mjs"));
   } catch (err2) {
     process.stderr.write(
       `token-goat: mcp-server unavailable (could not load the MCP server modules): ${String(err2)}
@@ -15377,8 +15724,8 @@ async function cmdMcpServe() {
   const server = await createMcpServer();
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  await new Promise((resolve14) => {
-    server.onclose = resolve14;
+  await new Promise((resolve15) => {
+    server.onclose = resolve15;
   });
 }
 function printBridgeVerificationNotice(harness) {
@@ -15389,7 +15736,7 @@ async function cmdHook(event, opts) {
   if (typeof opts.harness === "string" && opts.harness.length > 0) {
     process.env[ENV_KEYS.HARNESS_OVERRIDE] = opts.harness;
   }
-  const { relay } = await import("./token-goat-chunk-ZVN5WHTO.mjs");
+  const { relay } = await import("./token-goat-chunk-EQKNR7CN.mjs");
   await relay(event);
 }
 async function cmdInstall(opts) {
@@ -15502,16 +15849,16 @@ async function cmdInstall(opts) {
     );
   }
   try {
-    const skillDir = path29.join(homedir13(), ".claude", "skills");
-    if (fs28.existsSync(skillDir)) {
-      const entries = fs28.readdirSync(skillDir, { withFileTypes: true });
+    const skillDir = path30.join(homedir13(), ".claude", "skills");
+    if (fs29.existsSync(skillDir)) {
+      const entries = fs29.readdirSync(skillDir, { withFileTypes: true });
       const skillNames = [];
       const sessionId = getSessionId();
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const skillFile = path29.join(skillDir, entry.name, "SKILL.md");
-        if (fs28.existsSync(skillFile)) {
-          const body = fs28.readFileSync(skillFile, "utf-8");
+        const skillFile = path30.join(skillDir, entry.name, "SKILL.md");
+        if (fs29.existsSync(skillFile)) {
+          const body = fs29.readFileSync(skillFile, "utf-8");
           const compact = extractCompactFromMarker(body);
           if (compact === null) continue;
           const sourceSha = contentHash(body);
@@ -15521,10 +15868,10 @@ async function cmdInstall(opts) {
       }
       if (skillNames.length > 0) {
         const dir = skillOutputsDir();
-        await fs28.promises.mkdir(dir, { recursive: true });
-        const pregenPath = path29.join(dir, "pregen.json");
+        await fs29.promises.mkdir(dir, { recursive: true });
+        const pregenPath = path30.join(dir, "pregen.json");
         const pregenData = { ts: Date.now(), names: skillNames };
-        await fs28.promises.writeFile(pregenPath, JSON.stringify(pregenData, null, 2));
+        await fs29.promises.writeFile(pregenPath, JSON.stringify(pregenData, null, 2));
         out(`Pre-generated ${skillNames.length} skill compacts.`);
       }
     }
@@ -15728,7 +16075,7 @@ ${formatSessionOutline(turns)}`;
 }
 function sessionTranscriptSize(transcriptPath) {
   try {
-    return fs28.statSync(transcriptPath).size;
+    return fs29.statSync(transcriptPath).size;
   } catch {
     return 0;
   }
@@ -15858,7 +16205,7 @@ function fenceFileFieldIfMatched(text) {
 }
 function fileSizeOrZero(filePath) {
   try {
-    return fs28.statSync(filePath).size;
+    return fs29.statSync(filePath).size;
   } catch {
     return 0;
   }
@@ -15873,11 +16220,11 @@ function cmdBashOutput(id, opts) {
     }
     let content;
     try {
-      const st = fs28.statSync(opts.file);
+      const st = fs29.statSync(opts.file);
       if (st.isFIFO() || st.isSocket()) {
         throw new CliError(`--file '${opts.file}' is a special file (FIFO or socket) \u2014 only regular files are supported`);
       }
-      content = redactIfDotenv(opts.file, decodeSource(fs28.readFileSync(opts.file)));
+      content = redactIfDotenv(opts.file, decodeSource(fs29.readFileSync(opts.file)));
     } catch (e) {
       if (e instanceof CliError) throw e;
       throw new CliError(`cannot read file: ${opts.file}`);
@@ -15986,9 +16333,9 @@ async function cmdPdfMeta(file, opts = {}) {
 }
 async function cmdImageMeta(file, opts = {}) {
   const meta = await runImageMeta(file);
-  if (!meta.sharpAvailable) {
-    const msg = "image-meta unavailable (install sharp to use this feature)";
-    const text2 = opts.json === true ? JSON.stringify({ bytes: meta.bytes, sharpAvailable: false, error: msg }, null, 2) : `Size: ${meta.bytes} bytes
+  if (!meta.decodable) {
+    const msg = "image-meta unavailable (not a format token-goat can read)";
+    const text2 = opts.json === true ? JSON.stringify({ bytes: meta.bytes, decodable: false, error: msg }, null, 2) : `Size: ${meta.bytes} bytes
 ${msg}`;
     out(text2);
     return;
@@ -16287,7 +16634,7 @@ function readStdinPaths() {
   }
   let raw;
   try {
-    raw = fs28.readFileSync(0, "utf8");
+    raw = fs29.readFileSync(0, "utf8");
   } catch (e) {
     throw new CliError(`could not read the file list from stdin: ${extractErrorMessage(e)}`);
   }
@@ -16323,7 +16670,7 @@ function emitExtraFileArgsNote(command, first, extras, opts = {}) {
 }
 async function cmdCompress(opts) {
   try {
-    const bashRunner = await import("./token-goat-chunk-NY4HYRSK.mjs");
+    const bashRunner = await import("./token-goat-chunk-5BHXZEOI.mjs");
     if (opts.compress === false) {
       process.exitCode = bashRunner.runRaw(opts.cmd, parseTimeout(opts.timeout, bashRunner.DEFAULT_TIMEOUT_SECONDS));
       return;
@@ -16349,7 +16696,7 @@ async function cmdSkillBody(name, opts) {
   if (filePath === null) {
     throw new CliError(`skill '${name}' not found`);
   }
-  const body = decodeSource(fs28.readFileSync(filePath));
+  const body = decodeSource(fs29.readFileSync(filePath));
   if (opts.compact === true) {
     const emitted = extractCompactFromMarker(body) ?? body;
     out(emitted);
@@ -16376,7 +16723,7 @@ async function cmdSkillCompact(name, opts) {
       }
       let body2;
       try {
-        body2 = decodeSource(fs28.readFileSync(filePath));
+        body2 = decodeSource(fs29.readFileSync(filePath));
       } catch {
         unresolvable++;
         continue;
@@ -16410,19 +16757,19 @@ async function cmdSkillCompact(name, opts) {
     if (!opts.path.trim()) {
       throw new CliError("--path cannot be empty");
     }
-    if (!fs28.existsSync(opts.path)) {
+    if (!fs29.existsSync(opts.path)) {
       throw new CliError(`skill file not found: ${opts.path}`);
     }
     try {
-      body = fs28.readFileSync(opts.path, "utf-8");
+      body = fs29.readFileSync(opts.path, "utf-8");
     } catch (e) {
       if (e.code === "ENOENT") {
         throw new CliError(`skill file not found: ${opts.path}`);
       }
       throw new CliError(`failed to read skill file '${opts.path}': ${extractErrorMessage(e)}`);
     }
-    cacheName = name ?? path29.basename(path29.dirname(path29.resolve(opts.path)));
-    sourcePath = path29.resolve(opts.path);
+    cacheName = name ?? path30.basename(path30.dirname(path30.resolve(opts.path)));
+    sourcePath = path30.resolve(opts.path);
   } else {
     if (name === void 0 || !name.trim()) {
       throw new CliError("skill-compact requires a <name> or --path <file>");
@@ -16431,7 +16778,7 @@ async function cmdSkillCompact(name, opts) {
     if (filePath === null) {
       throw new CliError(`skill '${name}' not found`);
     }
-    body = fs28.readFileSync(filePath, "utf-8");
+    body = fs29.readFileSync(filePath, "utf-8");
     cacheName = name;
     sourcePath = filePath;
   }
@@ -16563,8 +16910,8 @@ async function cmdSkillDiff(name) {
   }
   const newer = versions[0];
   const older = versions[1];
-  const newerBody = await fs28.promises.readFile(path29.resolve(dir, `${newer.outputId}.txt`), "utf-8").catch(() => null);
-  const olderBody = await fs28.promises.readFile(path29.resolve(dir, `${older.outputId}.txt`), "utf-8").catch(() => null);
+  const newerBody = await fs29.promises.readFile(path30.resolve(dir, `${newer.outputId}.txt`), "utf-8").catch(() => null);
+  const olderBody = await fs29.promises.readFile(path30.resolve(dir, `${older.outputId}.txt`), "utf-8").catch(() => null);
   if (newerBody === null || olderBody === null) {
     out(`a cached version of '${name}' was evicted while diffing -- try again`);
     return;
@@ -16593,7 +16940,7 @@ async function cmdSkillSection(nameHeading, headingArg) {
   if (!filePath) {
     throw new CliError(`skill '${skillName}' not found`);
   }
-  const body = decodeSource(fs28.readFileSync(filePath));
+  const body = decodeSource(fs29.readFileSync(filePath));
   const extracted = extractNamedSection(body, heading);
   if (!extracted) {
     const messages = [`Section '${heading}' not found in skill '${skillName}'`];
@@ -16608,7 +16955,7 @@ async function cmdSkillSection(nameHeading, headingArg) {
 }
 function atomicWriteBuffer(dest, data) {
   try {
-    if (fs28.statSync(dest).isDirectory()) {
+    if (fs29.statSync(dest).isDirectory()) {
       const e = Object.assign(new Error(`EISDIR: illegal operation on a directory, open '${dest}'`), { code: "EISDIR", path: dest });
       throw e;
     }
@@ -16616,23 +16963,23 @@ function atomicWriteBuffer(dest, data) {
     if (e.code !== "ENOENT") throw e;
   }
   const rnd = randomBytes(4).toString("hex");
-  const tmp = path29.join(path29.dirname(path29.resolve(dest)), `.tmp.${process.pid}.${rnd}`);
+  const tmp = path30.join(path30.dirname(path30.resolve(dest)), `.tmp.${process.pid}.${rnd}`);
   try {
-    fs28.writeFileSync(tmp, data, { mode: 384 });
+    fs29.writeFileSync(tmp, data, { mode: 384 });
     try {
-      const destMode = fs28.statSync(dest).mode;
-      fs28.chmodSync(tmp, destMode);
+      const destMode = fs29.statSync(dest).mode;
+      fs29.chmodSync(tmp, destMode);
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
     }
     withRetryOnLock(() => {
       try {
-        fs28.renameSync(tmp, dest);
+        fs29.renameSync(tmp, dest);
       } catch (e) {
         if (e.code === "EXDEV") {
-          fs28.copyFileSync(tmp, dest);
+          fs29.copyFileSync(tmp, dest);
           try {
-            fs28.unlinkSync(tmp);
+            fs29.unlinkSync(tmp);
           } catch (ue) {
             process.stderr.write(`token-goat write-file: warning: could not remove temp file ${tmp}: ${ue.message}
 `);
@@ -16644,7 +16991,7 @@ function atomicWriteBuffer(dest, data) {
     });
   } catch (e) {
     try {
-      fs28.unlinkSync(tmp);
+      fs29.unlinkSync(tmp);
     } catch {
     }
     throw e;
@@ -16654,9 +17001,9 @@ function mapFsError(e, src, dest, srcLabel = "source") {
   const fe = e;
   if (fe.code === "ENOENT") {
     const errPath = fe.path ?? "";
-    const isSource = src !== void 0 && path29.resolve(errPath) === path29.resolve(src);
+    const isSource = src !== void 0 && path30.resolve(errPath) === path30.resolve(src);
     if (isSource) throw new CliError(`${/\bfile$/i.test(srcLabel) ? srcLabel : `${srcLabel} file`} not found: ${src}`);
-    const destDir = dest ? path29.dirname(path29.resolve(dest)) : path29.dirname(path29.resolve(errPath || "."));
+    const destDir = dest ? path30.dirname(path30.resolve(dest)) : path30.dirname(path30.resolve(errPath || "."));
     throw new CliError(`destination directory does not exist: ${destDir}`);
   }
   if (fe.code === "ENOTDIR") {
@@ -16667,7 +17014,7 @@ function mapFsError(e, src, dest, srcLabel = "source") {
   }
   if (fe.code === "EISDIR") {
     const errPath = fe.path ?? "";
-    const isSource = src !== void 0 && (errPath === "" || path29.resolve(errPath) === path29.resolve(src));
+    const isSource = src !== void 0 && (errPath === "" || path30.resolve(errPath) === path30.resolve(src));
     if (isSource) throw new CliError(`source is a directory, not a file: ${src}`);
     throw new CliError(`destination is a directory, not a file: ${dest ?? (errPath || "(unknown)")}`);
   }
@@ -16736,7 +17083,7 @@ function validateWritablePath(dest, label) {
     throw new CliError(`${label} path contains a null byte`);
   }
   if (isWindows()) {
-    const base = path29.basename(dest);
+    const base = path30.basename(dest);
     const stem = base.replace(/\.[^.]*$/, "").toUpperCase();
     if (WIN_RESERVED.has(stem)) {
       throw new CliError(`${label} '${base}' is a reserved Windows device name`);
@@ -16766,7 +17113,7 @@ function readFileBoundedRaw(filePath, label, allowStdIn = false) {
     throw new CliError(`${label} ${filePath} requires piped input; use ${altLabel} for interactive use`);
   }
   try {
-    const st = fs28.statSync(filePath);
+    const st = fs29.statSync(filePath);
     if (st.isFIFO() || st.isSocket()) {
       throw new CliError(`${label} '${filePath}' is a special file (FIFO or socket) \u2014 only regular files are supported`);
     }
@@ -16774,7 +17121,7 @@ function readFileBoundedRaw(filePath, label, allowStdIn = false) {
     if (st.size > maxBytes) {
       throw new CliError(`${label} '${filePath}' exceeds size limit (${Math.round(st.size / 1024 / 1024)} MB); set TOKEN_GOAT_MAX_STDIN_MB to override`);
     }
-    return fs28.readFileSync(filePath);
+    return fs29.readFileSync(filePath);
   } catch (e) {
     if (e instanceof CliError) throw e;
     mapFsError(e, filePath, void 0, label);
@@ -16818,7 +17165,7 @@ function cmdNoteAdd(file, opts) {
     throw new CliError("note content must be valid UTF-8 text");
   }
   const resolvedPath = resolveIndexPath(file);
-  if (!fs28.existsSync(resolvedPath)) {
+  if (!fs29.existsSync(resolvedPath)) {
     throw new CliError(`File not found: '${resolvedPath}'`);
   }
   healStaleIndex(resolvedPath);
@@ -16877,7 +17224,7 @@ function cmdWriteFile(dest, opts) {
     throw new CliError(`TOKEN_GOAT_MAX_STDIN_MB must be a positive integer; got '${process.env["TOKEN_GOAT_MAX_STDIN_MB"] ?? ""}'`);
   }
   const maxBytes = maxMB * 1024 * 1024;
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve15, reject) => {
     const chunks = [];
     let totalBytes = 0;
     let settled = false;
@@ -16901,7 +17248,7 @@ function cmdWriteFile(dest, opts) {
       try {
         atomicWriteBuffer(dest, Buffer.concat(chunks));
         enqueueDirtyPathSafe(dest);
-        resolve14();
+        resolve15();
       } catch (e) {
         try {
           mapFsError(e, void 0, dest);
@@ -17032,14 +17379,14 @@ function writeReplacedBuffer(file, replacedBuf, preWriteStat) {
       const until = process.env["TOKEN_GOAT_TEST_REPLACE_DELAY_UNTIL"];
       const deadline = Date.now() + testDelayMs;
       if (until !== void 0 && until !== "") {
-        while (Date.now() < deadline && !fs28.existsSync(until)) sleepSync(5);
+        while (Date.now() < deadline && !fs29.existsSync(until)) sleepSync(5);
       } else {
         sleepSync(testDelayMs);
       }
     }
     let preRenameStat;
     try {
-      preRenameStat = fs28.statSync(file);
+      preRenameStat = fs29.statSync(file);
     } catch {
     }
     if (preRenameStat !== void 0 && (preRenameStat.mtimeMs !== preWriteStat.mtimeMs || preRenameStat.size !== preWriteStat.size)) {
@@ -17080,7 +17427,7 @@ function cmdReplace(file, opts) {
   const targetBuf = readFileBoundedRaw(file, "target file", true);
   let preWriteStat;
   try {
-    preWriteStat = fs28.statSync(file);
+    preWriteStat = fs29.statSync(file);
   } catch {
   }
   const usingFrom = opts.oldFrom !== void 0 || opts.newFrom !== void 0;
@@ -17174,7 +17521,7 @@ function cmdInsertSection(file, opts) {
   }
   let preWriteStat;
   try {
-    preWriteStat = fs28.statSync(file);
+    preWriteStat = fs29.statSync(file);
   } catch {
   }
   const result = readSection(file, opts.after);
@@ -17200,7 +17547,7 @@ function cmdInsertSection(file, opts) {
   }
   let rawBytes;
   try {
-    rawBytes = fs28.readFileSync(file);
+    rawBytes = fs29.readFileSync(file);
   } catch (e) {
     mapFsError(e, void 0, file);
   }
@@ -17216,7 +17563,7 @@ function cmdInsertSection(file, opts) {
   if (preWriteStat !== void 0) {
     let preRenameStat;
     try {
-      preRenameStat = fs28.statSync(file);
+      preRenameStat = fs29.statSync(file);
     } catch {
     }
     if (preRenameStat !== void 0 && (preRenameStat.mtimeMs !== preWriteStat.mtimeMs || preRenameStat.size !== preWriteStat.size)) {
@@ -17258,25 +17605,25 @@ ${content}`;
 }
 function expandGlobs(root, patterns, globFnOverride) {
   const out2 = [];
-  const globFn = globFnOverride ?? fs28["globSync"];
+  const globFn = globFnOverride ?? fs29["globSync"];
   for (const p of patterns) {
     if (globFn !== void 0 && (p.includes("*") || p.includes("?") || p.includes("{"))) {
       try {
         const hits = globFn(p, { cwd: root });
-        for (const h of hits) out2.push(path29.isAbsolute(h) ? h : path29.join(root, h));
+        for (const h of hits) out2.push(path30.isAbsolute(h) ? h : path30.join(root, h));
         continue;
       } catch {
       }
     }
-    out2.push(path29.isAbsolute(p) ? p : path29.join(root, p));
+    out2.push(path30.isAbsolute(p) ? p : path30.join(root, p));
   }
   return out2;
 }
 function readIgnoreFile(root) {
-  const ignorePath = path29.join(root, ".tokengoatignore");
+  const ignorePath = path30.join(root, ".tokengoatignore");
   let raw;
   try {
-    raw = fs28.readFileSync(ignorePath, "utf8");
+    raw = fs29.readFileSync(ignorePath, "utf8");
   } catch {
     return void 0;
   }
@@ -17317,14 +17664,14 @@ function cmdPack(patterns, opts) {
   }
   let instruction;
   if (opts.instructionFile !== void 0) {
-    instruction = fs28.readFileSync(opts.instructionFile, "utf8");
+    instruction = fs29.readFileSync(opts.instructionFile, "utf8");
   }
   const formatted = formatPack(result, style, {
     ...opts.lineNumbers === true ? { line_numbers: true } : {},
     ...instruction !== void 0 ? { instruction } : {}
   });
   if (opts.output !== void 0) {
-    fs28.writeFileSync(opts.output, formatted, "utf8");
+    fs29.writeFileSync(opts.output, formatted, "utf8");
   } else {
     out(formatted);
   }
@@ -17344,17 +17691,17 @@ function cmdTokens(patterns, opts) {
   if (opts.tree === true) {
     const dirs = /* @__PURE__ */ new Map();
     for (const e of entries) {
-      const dir = path29.dirname(e.rel_path);
+      const dir = path30.dirname(e.rel_path);
       if (!dirs.has(dir)) dirs.set(dir, []);
       dirs.get(dir).push(e);
     }
     const lines2 = [];
     for (const [dir, dirEntries] of dirs) {
       const dirTokens = dirEntries.reduce((s, e) => s + e.tokens, 0);
-      const pct2 = result.total_tokens > 0 ? Math.round(dirTokens / result.total_tokens * 100) : 0;
-      lines2.push(`${dir}/ (${dirTokens} tokens, ${pct2}%)`);
+      const pct3 = result.total_tokens > 0 ? Math.round(dirTokens / result.total_tokens * 100) : 0;
+      lines2.push(`${dir}/ (${dirTokens} tokens, ${pct3}%)`);
       for (const e of dirEntries) {
-        lines2.push(`  ${path29.basename(e.rel_path).padEnd(30)}  ${String(e.tokens).padStart(8)} tokens`);
+        lines2.push(`  ${path30.basename(e.rel_path).padEnd(30)}  ${String(e.tokens).padStart(8)} tokens`);
       }
     }
     out(lines2.join("\n"));
@@ -17388,7 +17735,7 @@ function cmdBudget(patterns, opts) {
   }
 }
 function cmdFailures(src, opts) {
-  const text = src !== void 0 ? fs28.readFileSync(src, "utf8") : fs28.readFileSync(0, "utf8");
+  const text = src !== void 0 ? fs29.readFileSync(src, "utf8") : fs29.readFileSync(0, "utf8");
   const result = extractFailures(text, opts.runner !== void 0 ? { runner: opts.runner } : {});
   if (opts.delta !== true) {
     out(opts.json === true ? formatFailuresJson(result) : formatFailuresText(result));
@@ -17442,7 +17789,7 @@ function generateCompactHelp() {
     "",
     "Compression: compress-text, retrieve, handoff-create, handoff-resolve,",
     "  compress, recall, bash-output, web-output, mcp-output, compress-text,",
-    "  compress",
+    "  compress, bench",
     "",
     "Config & Integration: install, uninstall, mcp-serve, mcp-status, hook,",
     "  bridges-status, worker, statusline, version, config, config-get,",
@@ -17628,6 +17975,16 @@ function buildProgram() {
   program2.command("bridges-status").description("hook-event parity matrix across every AI-harness bridge (read-only static analysis, never invokes a real harness binary)").option("--json", "emit the matrix as JSON instead of text").action(guard(cmdBridgesStatus));
   program2.command("commands").description("machine-readable manifest of every registered command, its options, and its arguments").option("--json", "emit the manifest as JSON instead of text").option("--grep <pattern>", "filter to commands whose name, description, or aliases match this regex").action(guard(cmdCommands));
   program2.command("mcp-serve").description("run token-goat as an MCP stdio server exposing surgical reads and local compression/handoff tools").action(guard(cmdMcpServe));
+  program2.command("bench").description("replay a corpus of captured command output through the compressors; prints the byte savings ratio and a fidelity check, and exits 1 when a must-keep line was dropped").option("--corpus <dir>", "corpus directory (default: tests/fixtures/bench, relative to the working directory)").option("--tsv <path>", "append one result row, keyed by the current commit, creating the file and its header if absent").option("--validate", "score the corpus with control filters instead: proves the ratio has a floor and the fidelity guard can actually fail").option("-j, --json", "output as JSON").action(
+    (opts) => runExitText(
+      () => runBenchCommand({
+        corpus: opts.corpus ?? path30.join("tests", "fixtures", "bench"),
+        ...opts.tsv !== void 0 ? { tsv: opts.tsv } : {},
+        ...opts.validate === true ? { validate: true } : {},
+        ...opts.json === true ? { json: true } : {}
+      })
+    )
+  );
   program2.command("compress-text [text]").description("compress arbitrary local text and print an opaque recovery ID plus compact payload").option("--file <path>", "read text from a local file instead of the argument").option("--payload", "always print the compact payload, even when inlining it costs more tokens than the original text").action(guard(cmdContentCompress));
   program2.command("retrieve <id>").description("retrieve original text previously stored by token-goat compress").option("--head <n>", "show first N lines").option("--tail <n>", "show last N lines").option("--grep <pattern>", "filter lines matching regex").option("--max-matches <n>", "cap --grep output to the first N matching lines").option("--section <heading>", "extract a specific section from the retrieved text").option("--full", "print the entire retrieved text with no head/tail elision (default behaviour when no other flag is given)").action(guard(cmdRetrieve));
   program2.command("handoff-create <name> [text]").description("create a project-local named compressed handoff").option("--file <path>", "read handoff text from a local file instead of the argument").action(guard(cmdHandoffCreate));
@@ -18076,7 +18433,7 @@ async function run(argv = process.argv) {
     return;
   }
   if (argv[2] === "--batch-serve" && typeof argv[3] === "string") {
-    const { serveBatch } = await import("./token-goat-chunk-G6XLWJWI.mjs");
+    const { serveBatch } = await import("./token-goat-chunk-E3K3BTEQ.mjs");
     serveBatch(argv[3], (a) => run(a));
     return;
   }