token-goat 2.9.1 → 2.9.3

package/dist/{token-goat-chunk-SQSB5P5P.mjs → token-goat-chunk-6FQMEMWX.mjs}

@@ -86,7 +86,7 @@ import {
   runZipRead,
   symbolNamesInFile,
   upsertNote
-} from "./token-goat-chunk-SXSWQMNP.mjs";
+} from "./token-goat-chunk-7A7SBE6R.mjs";
 import {
   DEFAULT_RECONCILE_BUDGET_MS,
   GEMINI_TOOL_NAME_MAP,
@@ -108,7 +108,7 @@ import {
   runReconcile,
   storeWebOutput,
   summarizeResidentContext
-} from "./token-goat-chunk-MR7MNSDR.mjs";
+} from "./token-goat-chunk-A4VBNWSL.mjs";
 import {
   AGENT_SALT_MARKER,
   BASH_OUTPUT_SUBDIR,
@@ -238,15 +238,20 @@ import {
   visionTokensSavedByText,
   walkProject,
   writeCompact
-} from "./token-goat-chunk-FDXINYK4.mjs";
+} from "./token-goat-chunk-3XVGPLDS.mjs";
 import {
   C,
   CONFIG_KEY_ENV_OVERRIDES,
+  CompressedOutput,
   ENV_KEYS,
   FILTERS,
   LOCK_WAIT_MS_HARDENED,
   MATERIALIZE_SHRUNK_IMAGE_JS,
+  PROJECT_LOCKED_KEYS,
+  PROJECT_LOCKED_SECTIONS,
   RESET,
+  TOOL_FILTERS,
+  ToolFilter,
   VERSION,
   _useRichStats,
   anchoredMarkerPattern,
@@ -255,6 +260,8 @@ import {
   canonicalize,
   cappedSourceBytesSaved,
   colorStdout,
+  combineStreams,
+  compileCustomPatterns,
   configPath,
   copilotCliConfigPath,
   copilotCliMcpToolsDir,
@@ -264,11 +271,14 @@ import {
   dataDir,
   decodeSource,
   defaultConfig,
+  deliverCompressed,
+  detectFromCommand,
   detectLanguage,
   detectSourceEncoding,
   encodeSource,
   ensureDirSync,
   ensureNewline,
+  envBool,
   escapeRegExp,
   extractErrorMessage,
   fg,
@@ -354,15 +364,24 @@ import {
   withFileLock,
   withRetryOnLock,
   writeJsonSettings
-} from "./token-goat-chunk-4ZDRTNGV.mjs";
+} from "./token-goat-chunk-KKHKXUVS.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
@@ -513,6 +532,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";
@@ -521,6 +541,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() {
@@ -1113,6 +1134,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`.
@@ -1419,6 +1441,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)
@@ -3473,9 +3496,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;
   }
   /**
@@ -3731,6 +3754,7 @@ function useColor() {
 var program = new Command();
 
 // src/command_intent.ts
+init_define_import_meta_env();
 var INTENT_SUGGESTIONS = [
   [
     ["search", "lookup", "query"],
@@ -3774,11 +3798,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";
@@ -3827,6 +3852,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";
@@ -3970,6 +3996,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";
@@ -4094,11 +4121,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
@@ -4317,7 +4346,7 @@ function materializeShrunkImage(context: string | undefined): string | undefined
   try {
     pruneMaterializedShrinks();
     const buf = Buffer.from(match[2], "base64");
-    const name = \`token-goat-shrink-\${process.pid}-\${Date.now()}-\${Math.random().toString(36).slice(2)}.\${match[1]}\`;
+    const name = \`token-goat-shrink-\${process.pid}-\${Date.now()}-\${globalThis.crypto.randomUUID()}.\${match[1]}\`;
     const file = path.join(os.tmpdir(), name);
     fs.writeFileSync(file, buf);
     return file;
@@ -4489,11 +4518,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
@@ -4783,11 +4817,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
@@ -5094,6 +5130,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";
@@ -5397,6 +5434,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";
@@ -5504,6 +5542,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() {
@@ -5551,6 +5590,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}`);
@@ -5664,6 +5704,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) {
@@ -5765,6 +5806,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) {
@@ -5818,6 +5860,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) {
@@ -5940,6 +5983,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";
@@ -6153,19 +6197,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 {
@@ -6402,6 +6446,40 @@ function checkStrayClaudeMdBlocks(searchRoot) {
     message: `${strays.length} stray cop${strays.length === 1 ? "y" : "ies"} outside CLAUDE.md (never refreshed by install, never removed by uninstall, will go stale): ${strays.join(", ")}`
   };
 }
+var LOCKED_BOOLEAN_SAFE_VALUE = {
+  "gdrive.enabled": false,
+  "injection.enabled": true,
+  "redaction.strict": true,
+  "mcp.confine_reads_to_project_root": true,
+  "screenshot.block_private_targets": true,
+  "network.offline": true,
+  "indexing.cross_project_symbols": false,
+  "webfetch.compress_bodies": true
+};
+function lockedEnvOverridableKeys() {
+  const out2 = [];
+  for (const key of Object.keys(CONFIG_KEY_ENV_OVERRIDES)) {
+    const section = key.split(".")[0] ?? "";
+    const locked = PROJECT_LOCKED_SECTIONS.includes(section) || PROJECT_LOCKED_KEYS.includes(key);
+    if (locked && (CONFIG_KEY_ENV_OVERRIDES[key] ?? []).length > 0) out2.push(key);
+  }
+  return out2.sort();
+}
+function envOverriddenSecuritySettings() {
+  const out2 = [];
+  for (const setting of lockedEnvOverridableKeys()) {
+    const safe = LOCKED_BOOLEAN_SAFE_VALUE[setting];
+    for (const envVar of CONFIG_KEY_ENV_OVERRIDES[setting] ?? []) {
+      if (safe === void 0) {
+        const raw = process.env[envVar];
+        if (raw !== void 0 && raw.trim() !== "") out2.push({ setting, envVar, kind: "replaced" });
+      } else if (envBool(envVar, safe) !== safe) {
+        out2.push({ setting, envVar, kind: "weakened" });
+      }
+    }
+  }
+  return out2;
+}
 function checkSecurityPosture(cfg, dataDirPath) {
   const results = [];
   results.push({
@@ -6424,6 +6502,19 @@ function checkSecurityPosture(cfg, dataDirPath) {
     status: "ok",
     message: allow > 0 ? `${allow} allowed host pattern${allow === 1 ? "" : "s"}, ${deny} denied: nothing outside the allow list is fetched` : `no allow list, ${deny} denied pattern${deny === 1 ? "" : "s"}: any host not denied can be fetched`
   });
+  const custom = compileCustomPatterns(cfg.redaction.custom_patterns);
+  const strictNote = cfg.redaction.strict ? "strict mode on" : "strict mode off (redaction.strict)";
+  const patternNote = custom.patterns.length === 0 ? "built-in patterns only" : `${custom.patterns.length} custom pattern${custom.patterns.length === 1 ? "" : "s"} plus the built-in ones`;
+  results.push(
+    custom.problems.length > 0 ? {
+      name: "Security redaction",
+      // A pattern the operator believes is redacting, but which never compiled, is the one
+      // failure here that is invisible from the output itself -- so it warns rather than
+      // being reported as a healthy count that happens to be short.
+      status: "warn",
+      message: `${custom.problems.length} custom redaction pattern${custom.problems.length === 1 ? "" : "s"} could not be used and ${custom.problems.length === 1 ? "is" : "are"} not redacting anything: ` + custom.problems.map((p) => `${p.pattern} (${p.reason})`).join("; ")
+    } : { name: "Security redaction", status: "ok", message: `${patternNote}, ${strictNote}` }
+  );
   const extraRoots = cfg.mcp.allowed_roots.length;
   results.push(
     cfg.mcp.confine_reads_to_project_root ? {
@@ -6432,6 +6523,27 @@ function checkSecurityPosture(cfg, dataDirPath) {
       message: extraRoots === 0 ? "reads are confined to the project root" : `reads are confined to the project root plus ${extraRoots} configured root${extraRoots === 1 ? "" : "s"}`
     } : { name: "Security mcp roots", status: "warn", message: "confinement is off (mcp.confine_reads_to_project_root): a read can leave the project" }
   );
+  const overridden = envOverriddenSecuritySettings();
+  const weakened = overridden.filter((o) => o.kind === "weakened");
+  const replaced = overridden.filter((o) => o.kind === "replaced");
+  const describe = (o) => `${o.setting} (${o.envVar})`;
+  const parts = [];
+  if (weakened.length > 0) parts.push(`held open: ${weakened.map(describe).join(", ")}`);
+  if (replaced.length > 0) parts.push(`set from the environment: ${replaced.map(describe).join(", ")}`);
+  results.push(
+    overridden.length === 0 ? {
+      name: "Security config overrides",
+      status: "ok",
+      // Naming the count keeps this from reading as a guarantee about settings it never looked
+      // at, which is what the first version of this line did while nine locked keys went
+      // unchecked behind it.
+      message: `no environment variable is overriding any of the ${lockedEnvOverridableKeys().length} project-locked settings`
+    } : {
+      name: "Security config overrides",
+      status: "warn",
+      message: `the environment, not the config file, is deciding ${overridden.length === 1 ? "a" : "these"} project-locked setting${overridden.length === 1 ? "" : "s"}. ${parts.join("; ")}. A project config cannot change these; an environment variable can, and one can be set by a file in a cloned repository.`
+    }
+  );
   results.push(dataDirPermissionResult(dataDirPath));
   return results;
 }
@@ -6616,7 +6728,96 @@ async function runDoctorAndExit(opts) {
   return results.some((r) => r.status === "fail") ? 1 : 0;
 }
 
+// src/capabilities.ts
+init_define_import_meta_env();
+function collectCapabilities(config = loadConfig()) {
+  const online = !config.network.offline;
+  return [
+    {
+      id: "network.http_fetch",
+      kind: "egress",
+      what: "Fetches a URL when a command asks for one, including page text and remote images.",
+      enabled: online,
+      controlledBy: "network.offline",
+      enforcedAt: "src/webfetch.ts::performHttpFetch"
+    },
+    {
+      id: "network.google_drive",
+      kind: "egress",
+      what: "Exports a Google Doc so a section of it can be read.",
+      // Two independent gates, so this reports the conjunction: turning either one off is enough.
+      enabled: online && config.gdrive.enabled,
+      controlledBy: "gdrive.enabled, network.offline",
+      enforcedAt: "src/gdrive.ts::fetchDoc (network gate in src/webfetch.ts::performHttpFetch)"
+    },
+    {
+      id: "network.embedding_model_download",
+      kind: "egress",
+      what: "Downloads the local embedding model once, so semantic search can run without a server.",
+      enabled: online,
+      controlledBy: "network.offline",
+      enforcedAt: "src/embed_model.ts"
+    },
+    {
+      id: "network.ocr_data_download",
+      kind: "egress",
+      what: "Downloads OCR language data once, so text can be read out of an image.",
+      enabled: online,
+      controlledBy: "network.offline",
+      enforcedAt: "src/image_ocr.ts"
+    },
+    {
+      id: "network.screenshot",
+      kind: "egress",
+      what: "Loads a page in a browser to capture it.",
+      enabled: online,
+      controlledBy: "network.offline",
+      enforcedAt: "src/screenshot.ts"
+    },
+    {
+      id: "at_rest.symbol_index",
+      kind: "at-rest",
+      what: "Stores the text of indexed source files in a local database, so a symbol can be returned without re-reading the file.",
+      // Always on: it is the product. Reported anyway, because a reviewer deciding about data at
+      // rest needs the always-on items more than the optional ones.
+      enabled: true,
+      controlledBy: "always on (this is what the tool does)",
+      enforcedAt: "src/db.ts"
+    },
+    {
+      id: "at_rest.command_output_cache",
+      kind: "at-rest",
+      what: "Keeps recent command and web output on disk so it can be recalled instead of re-run. Expires after 24 hours.",
+      enabled: true,
+      controlledBy: "always on, 24-hour expiry",
+      enforcedAt: "src/disk_cache.ts"
+    }
+  ];
+}
+function renderCapabilities(caps) {
+  const lines = [];
+  for (const kind of ["egress", "at-rest"]) {
+    const group = caps.filter((c) => c.kind === kind);
+    if (group.length === 0) continue;
+    lines.push(kind === "egress" ? "Can send data off this machine:" : "Leaves data on this machine:");
+    for (const c of group) {
+      lines.push(`  [${c.enabled ? "ON " : "OFF"}] ${c.id}`);
+      lines.push(`         ${c.what}`);
+      lines.push(`         controlled by: ${c.controlledBy}`);
+      lines.push(`         enforced at:   ${c.enforcedAt}`);
+    }
+    lines.push("");
+  }
+  lines.push("Verify rather than trust: `token-goat capabilities --json` reports the state of the");
+  lines.push('binary you have installed, and each "enforced at" names the code that decides it.');
+  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";
@@ -7075,6 +7276,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";
 
@@ -7094,8 +7296,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;
@@ -7362,6 +7569,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") {
@@ -7372,7 +7580,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],
@@ -7482,6 +7694,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");
@@ -8134,6 +8347,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, "\\$&");
@@ -9409,12 +9623,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(", ");
@@ -9426,6 +9640,7 @@ function formatBudgetText(result, contextK) {
 }
 
 // src/failures.ts
+init_define_import_meta_env();
 function getFailureCount(result) {
   return result.blocks.length || result.summaryLines.length;
 }
@@ -9850,6 +10065,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}$/;
@@ -9895,10 +10111,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;
@@ -11122,6 +11340,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";
@@ -11409,7 +11628,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;
@@ -11749,15 +11972,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}
 `);
@@ -11844,6 +12067,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"];
@@ -11970,6 +12194,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";
@@ -12639,6 +12864,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";
@@ -12855,6 +13081,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) {
@@ -12974,10 +13201,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";
@@ -13225,6 +13454,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"]);
@@ -13379,10 +13609,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");
@@ -13442,9 +13672,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");
     }
   }
@@ -13609,6 +13839,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";
@@ -13775,6 +14006,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";
@@ -14132,13 +14364,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,
@@ -14606,6 +14838,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";
@@ -14759,6 +14992,7 @@ async function runMcpAuditCommand(opts = {}) {
 }
 
 // src/cli_recall.ts
+init_define_import_meta_env();
 var RECALL_COMMAND = {
   bash: "bash-output",
   web: "web-output",
@@ -14818,7 +15052,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)";
@@ -14834,9 +15292,9 @@ function printSummary(rows) {
   };
   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");
   for (const row of rows) {
-    const pct2 = row.efficacyPct === null ? "n/a" : `${row.efficacyPct}%`;
+    const pct3 = 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(pct3, 10) + pad(suppressedCell(row), 17) + pad(String(row.manualEffective), 9) + pad(String(row.manualIneffective), 9) + formatSpentCell(row) + "\n"
     );
   }
 }
@@ -14888,6 +15346,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);
@@ -14981,10 +15440,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;
@@ -15122,7 +15581,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;
@@ -15148,7 +15607,7 @@ async function cmdIndex(pathArg, opts = {}) {
         }
         continue;
       }
-      if (!fs28.existsSync(key)) continue;
+      if (!fs29.existsSync(key)) continue;
     }
     if (!embedUnchanged) {
       paintProgress("embedding");
@@ -15208,8 +15667,8 @@ async function cmdMcpServe() {
   let StdioServerTransport;
   try {
     ;
-    ({ createMcpServer } = await import("./token-goat-chunk-CD6U5OD6.mjs"));
-    ({ StdioServerTransport } = await import("./token-goat-chunk-324QOJYZ.mjs"));
+    ({ createMcpServer } = await import("./token-goat-chunk-3UBORD6Z.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)}
@@ -15221,8 +15680,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) {
@@ -15233,7 +15692,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-AUM22UQ2.mjs");
+  const { relay } = await import("./token-goat-chunk-HC5NMGPD.mjs");
   await relay(event);
 }
 async function cmdInstall(opts) {
@@ -15346,16 +15805,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);
@@ -15365,10 +15824,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.`);
       }
     }
@@ -15572,7 +16031,7 @@ ${formatSessionOutline(turns)}`;
 }
 function sessionTranscriptSize(transcriptPath) {
   try {
-    return fs28.statSync(transcriptPath).size;
+    return fs29.statSync(transcriptPath).size;
   } catch {
     return 0;
   }
@@ -15702,7 +16161,7 @@ function fenceFileFieldIfMatched(text) {
 }
 function fileSizeOrZero(filePath) {
   try {
-    return fs28.statSync(filePath).size;
+    return fs29.statSync(filePath).size;
   } catch {
     return 0;
   }
@@ -15717,11 +16176,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}`);
@@ -15830,9 +16289,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;
@@ -16131,7 +16590,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)}`);
   }
@@ -16167,7 +16626,7 @@ function emitExtraFileArgsNote(command, first, extras, opts = {}) {
 }
 async function cmdCompress(opts) {
   try {
-    const bashRunner = await import("./token-goat-chunk-4KD2N46D.mjs");
+    const bashRunner = await import("./token-goat-chunk-LLNA42NI.mjs");
     if (opts.compress === false) {
       process.exitCode = bashRunner.runRaw(opts.cmd, parseTimeout(opts.timeout, bashRunner.DEFAULT_TIMEOUT_SECONDS));
       return;
@@ -16193,7 +16652,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);
@@ -16220,7 +16679,7 @@ async function cmdSkillCompact(name, opts) {
       }
       let body2;
       try {
-        body2 = decodeSource(fs28.readFileSync(filePath));
+        body2 = decodeSource(fs29.readFileSync(filePath));
       } catch {
         unresolvable++;
         continue;
@@ -16254,19 +16713,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>");
@@ -16275,7 +16734,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;
   }
@@ -16407,8 +16866,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;
@@ -16437,7 +16896,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}'`];
@@ -16452,7 +16911,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;
     }
@@ -16460,23 +16919,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}
 `);
@@ -16488,7 +16947,7 @@ function atomicWriteBuffer(dest, data) {
     });
   } catch (e) {
     try {
-      fs28.unlinkSync(tmp);
+      fs29.unlinkSync(tmp);
     } catch {
     }
     throw e;
@@ -16498,9 +16957,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") {
@@ -16511,7 +16970,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)")}`);
   }
@@ -16580,7 +17039,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`);
@@ -16610,7 +17069,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`);
     }
@@ -16618,7 +17077,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);
@@ -16662,7 +17121,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);
@@ -16721,7 +17180,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;
@@ -16745,7 +17204,7 @@ function cmdWriteFile(dest, opts) {
       try {
         atomicWriteBuffer(dest, Buffer.concat(chunks));
         enqueueDirtyPathSafe(dest);
-        resolve14();
+        resolve15();
       } catch (e) {
         try {
           mapFsError(e, void 0, dest);
@@ -16876,14 +17335,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)) {
@@ -16924,7 +17383,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;
@@ -17018,7 +17477,7 @@ function cmdInsertSection(file, opts) {
   }
   let preWriteStat;
   try {
-    preWriteStat = fs28.statSync(file);
+    preWriteStat = fs29.statSync(file);
   } catch {
   }
   const result = readSection(file, opts.after);
@@ -17044,7 +17503,7 @@ function cmdInsertSection(file, opts) {
   }
   let rawBytes;
   try {
-    rawBytes = fs28.readFileSync(file);
+    rawBytes = fs29.readFileSync(file);
   } catch (e) {
     mapFsError(e, void 0, file);
   }
@@ -17060,7 +17519,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)) {
@@ -17102,25 +17561,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;
   }
@@ -17161,14 +17620,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);
   }
@@ -17188,17 +17647,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"));
@@ -17232,7 +17691,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));
@@ -17286,10 +17745,11 @@ 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, help",
+    "  bridges-status, worker, statusline, version, config, config-get,",
+    "  capabilities, help",
     "",
     "Data: note, note-add, note-get, note-list, sqlite-query, sqlite-schema,",
     "  csv-profile, csv-query",
@@ -17471,6 +17931,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));
@@ -17493,6 +17963,12 @@ function buildProgram() {
       })
     )
   );
+  program2.command("capabilities").description("report every capability that can send data off this machine, and its current state").option("-j, --json", "emit as JSON, for asserting on in a pipeline").action(
+    guard((opts) => {
+      const caps = collectCapabilities();
+      console.log(opts.json ? JSON.stringify({ version: VERSION, capabilities: caps }, null, 2) : renderCapabilities(caps));
+    })
+  );
   program2.command("doctor").description("diagnose token-goat health").option("--context", "include context footprint analysis").option("--json", "emit check results as JSON instead of text").action(guard(cmdDoctor));
   program2.command("context-stats").description("show context statistics").option("--project <path>", "project root to analyze").option("-j, --json", "output as JSON").option("--fix", "apply automatic fixes (confirm-gated; shows a diff before writing)").option("-y, --yes", "with --fix, apply without prompting (non-interactive / scripted use)").action(guard(cmdContextStats));
   program2.command("bootstrap-audit").description("audit Claude Code startup-context contributors without reading prompt bodies").option("--project <path>", "project root to analyze").option("--home <path>", "home directory override (for CI/testing)").option("--follow-links", "follow external symlink/junction roots and direct children").option("-j, --json", "output as JSON").option("--top <n>", "largest metadata entries to show (default 10)", "10").option("--warn-tokens <n>", "warn when total estimated startup tokens exceed n").option("--fail-tokens <n>", "fail when total estimated startup tokens exceed n").option("--warn-bytes <n>", "warn when agent/skill metadata bytes exceed n").option("--fail-bytes <n>", "fail when agent/skill metadata bytes exceed n").action(guard(cmdBootstrapAudit));
@@ -17913,7 +18389,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;
   }