token-goat 2.8.2 → 2.8.4

package/dist/{token-goat-chunk-2MWF3OGR.mjs → token-goat-chunk-U4UI5F3S.mjs}

@@ -86,7 +86,7 @@ import {
   runZipRead,
   symbolNamesInFile,
   upsertNote
-} from "./token-goat-chunk-LILS6TIU.mjs";
+} from "./token-goat-chunk-RE7S7H26.mjs";
 import {
   BASH_OUTPUT_SUBDIR,
   GEMINI_TOOL_NAME_MAP,
@@ -113,16 +113,19 @@ import {
   searchRecall,
   storeWebOutput,
   summarizeResidentContext
-} from "./token-goat-chunk-5MLXFSRI.mjs";
+} from "./token-goat-chunk-IZRXU64B.mjs";
 import {
   AGENT_SALT_MARKER,
   CONTEXT_AUTOCOMPACT_TOKENS,
   DEFAULT_MAX_AGE_MS,
   DEFAULT_MAX_COUNT,
+  MATERIALIZE_SHRUNK_IMAGE_JS,
   MAX_FILES_SCANNED,
+  PARSER_FINGERPRINT,
   SESSIONS_SUBDIR,
   SKILLS_OUTPUT_SUBDIR,
   SKIP_DIRS,
+  UNTRUSTED_FILE_TAG,
   UNTRUSTED_TOOL_TAG,
   UNTRUSTED_WEB_TAG,
   WORKER_HEARTBEAT_STALE_MS,
@@ -158,6 +161,7 @@ import {
   extractCompactFromMarker,
   extractNamedSection,
   fenceUntrustedContent,
+  fenceUntrustedOcrText,
   findClaudeMdFiles,
   findContentDuplicates,
   findLatestSessionId,
@@ -256,7 +260,7 @@ import {
   vscodeDecoderConfigured,
   walkProject,
   writeCompact
-} from "./token-goat-chunk-AM23GDIS.mjs";
+} from "./token-goat-chunk-4OTIB7SB.mjs";
 import {
   C,
   CONFIG_KEY_ENV_OVERRIDES,
@@ -323,6 +327,7 @@ import {
   runGit,
   safeSlice,
   saveConfig,
+  savedTokensFromBytes,
   sleepSync,
   stripAnsi,
   stripOwnHooksFromMap,
@@ -338,7 +343,7 @@ import {
   withFileLock,
   withRetryOnLock,
   writeJsonSettings
-} from "./token-goat-chunk-IVCTQPZD.mjs";
+} from "./token-goat-chunk-E76UNTVK.mjs";
 import {
   __export
 } from "./token-goat-chunk-AEX54RUZ.mjs";
@@ -3457,9 +3462,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [path]
    * @return {(string|null|Command)}
    */
-  executableDir(path28) {
-    if (path28 === void 0) return this._executableDir;
-    this._executableDir = path28;
+  executableDir(path29) {
+    if (path29 === void 0) return this._executableDir;
+    this._executableDir = path29;
     return this;
   }
   /**
@@ -3758,9 +3763,9 @@ function attemptedCommandName(argv) {
 }
 
 // src/cli.ts
-import * as fs27 from "fs";
-import * as path27 from "path";
-import { homedir as homedir11 } from "os";
+import * as fs28 from "fs";
+import * as path28 from "path";
+import { homedir as homedir13 } from "os";
 
 // src/walk_index.ts
 import * as fs2 from "node:fs";
@@ -4094,10 +4099,11 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
-// pi built-in tool names -> token-goat internal tool names
+// pi built-in tool names -> token-goat internal tool names. powershell is pi's Windows shell twin of bash -- same input schema (PowerShellToolInput = BashToolInput, i.e. command/timeout) and registered under its own name (badlogic/pi-mono packages/coding-agent/src/core/tools/powershell.ts + tools/index.ts's ToolName union). Unmapped, every shell command in a powershell-tool pi session bypassed the Bash hooks entirely, the same shape as the Copilot shim's bash/powershell pairing.
 const TOOL_TO_TG: Record<string, string> = {
   read: "Read",
   bash: "Bash",
+  powershell: "Bash",
   edit: "Edit",
   write: "Write",
   grep: "Grep",
@@ -4108,15 +4114,14 @@ const TOOL_TO_TG: Record<string, string> = {
 const ARGS_TO_TG: Record<string, Record<string, string>> = {
   read: { path: "file_path", offset: "offset", limit: "limit" },
   bash: { command: "command", timeout: "timeout" },
+  powershell: { command: "command", timeout: "timeout" },
   edit: { path: "file_path" },
   write: { path: "file_path" },
   grep: { pattern: "pattern", path: "path" },
   find: { pattern: "pattern", path: "path" },
 };
 
-// Tools that have a pre-hook (read/search/fetch types only). Glob has no
-// pre_tool_use handler in token-goat (only Read/Grep/Bash/WebFetch do), so
-// it's excluded here rather than spawning a hook call that always no-ops.
+// Tools with a pre-hook whose output shape this extension can act on: deny ({block}), updatedInput (in-place arg rewrite), or the Read image-shrink materialization. Glob's pre handler (preGlobDedupHandler in hooks_glob.ts -- the old claim here that Glob has no pre handler was stale) emits only an advisory contextOutput hint, which pi's tool_call contract has no channel for (see the module docblock), so calling it would cost a hook call per find only to drop the answer; it stays excluded for that reason.
 const PRE_HOOK_TOOLS = new Set(["Read", "Grep", "Bash", "WebFetch"]);
 
 // resolveEntryPath reads a sidecar JSON file (token-goat-entry.json, written by
@@ -4268,6 +4273,30 @@ function extractUpdatedInput(resp: Record<string, unknown>): Record<string, unkn
 // since pi's tool_call handler has no context-injection channel -- only
 // in-place arg mutation. Returns undefined (leaving the read path untouched)
 // if the context isn't a shrink payload or anything goes wrong writing it.
+// Best-effort sweep of previously materialized shrunk copies in the OS temp dir: typed twin of pruneMaterializedShrinks in shrink_block.ts (MATERIALIZE_SHRUNK_IMAGE_JS), which documents why pi keeps its own copy. The temp file only needs to outlive the single tool call whose path was rewritten to it, so anything older than an hour is finished with; the "token-goat-shrink-" prefix check confines the sweep to this mechanism's own files.
+const MATERIALIZED_SHRINK_MAX_AGE_MS = 60 * 60 * 1000;
+let lastMaterializedShrinkSweepAtMs = 0;
+function pruneMaterializedShrinks(): void {
+  const now = Date.now();
+  if (now - lastMaterializedShrinkSweepAtMs < MATERIALIZED_SHRINK_MAX_AGE_MS) return;
+  lastMaterializedShrinkSweepAtMs = now;
+  try {
+    const dir = os.tmpdir();
+    for (const file of fs.readdirSync(dir)) {
+      if (!file.startsWith("token-goat-shrink-")) continue;
+      const full = path.join(dir, file);
+      try {
+        const st = fs.statSync(full);
+        if (st.isFile() && now - st.mtimeMs > MATERIALIZED_SHRINK_MAX_AGE_MS) fs.unlinkSync(full);
+      } catch {
+        // Best-effort per-file cleanup; one bad stat/unlink must not abort the sweep.
+      }
+    }
+  } catch {
+    // Best-effort; a readdir failure must never break the materialization below.
+  }
+}
+
 function materializeShrunkImage(context: string | undefined): string | undefined {
   if (typeof context !== "string") return undefined;
   const idx = context.indexOf("data:image/");
@@ -4275,6 +4304,7 @@ function materializeShrunkImage(context: string | undefined): string | undefined
   const match = /^data:image\\/([a-zA-Z0-9.+-]+);base64,([A-Za-z0-9+/=]+)$/.exec(context.slice(idx).trim());
   if (!match) return 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 file = path.join(os.tmpdir(), name);
@@ -4360,13 +4390,35 @@ export default function (pi: ExtensionAPI) {
       .filter((c: { type?: string }) => c && c.type === "text")
       .map((c: { text?: string }) => c.text ?? "")
       .join("\\n");
-    await callHook("post_tool_use", {
+    const resp = await callHook("post_tool_use", {
       session_id: sessionId,
       tool_name: tg,
       tool_input: toToolInput(event.toolName, (event.input ?? {}) as Record<string, unknown>),
       cwd,
       tool_response: { output },
     });
+    if (!resp) return;
+
+    // rewriteOutput: replace the tool result the model sees. pi's tool_result handler CAN modify the result: its own types declare "Fired after a tool executes. Can modify result." over ToolResultEvent and a ToolResultEventResult of { content, details, isError, usage }, and the shipped runtime applies it (dist/core/extensions/runner.js emitToolResult assigns handlerResult.content onto the event, and dist/core/agent-session.js afterToolCall returns hookResult.content as the tool result content). Without this, injection fencing, secret redaction and output compression were computed and thrown away on every pi session, the same whitelist-shaped drop fixed for opencode.
+    const hso = resp["hookSpecificOutput"] as Record<string, unknown> | undefined;
+    const updatedToolOutput = hso && typeof hso["updatedToolOutput"] === "string" ? (hso["updatedToolOutput"] as string) : undefined;
+    if (updatedToolOutput === undefined) return;
+
+    // Replace only the text blocks, in place, and keep every non-text block (images) untouched: emitToolResult overwrites content wholesale, so anything not carried here is dropped from what the model sees. details/isError/usage are deliberately not returned, since runner.js only overwrites the fields a handler actually provides.
+    const rewritten: typeof contentBlocks = [];
+    let replaced = false;
+    for (const block of contentBlocks) {
+      const isText = Boolean(block) && (block as { type?: string }).type === "text";
+      if (!isText) {
+        rewritten.push(block);
+        continue;
+      }
+      if (replaced) continue;
+      replaced = true;
+      rewritten.push({ type: "text", text: updatedToolOutput });
+    }
+    if (!replaced) rewritten.push({ type: "text", text: updatedToolOutput });
+    return { content: rewritten };
   });
 
   // Compaction: pi's session_before_compact REPLACES the summary rather than
@@ -4553,7 +4605,7 @@ import os from "node:os"
 import path from "node:path"
 import { fileURLToPath, pathToFileURL } from "node:url"
 
-// opencode built-in tool id -> token-goat canonical tool name.
+// opencode built-in tool id -> token-goat canonical tool name. websearch/skill/task were re-verified against opencode's own source at the tag matching the installed release (anomalyco/opencode v1.18.16 packages/opencode/src/tool/): WebSearchTool registers as "websearch" (websearch.ts), SkillTool as "skill" (skill.ts), TaskTool as "task" (task.ts, params prompt/subagent_type/description -- the exact keys token-goat's hooks_agent_spawn.ts reads, which registers a lowercase 'task' handler). Unmapped, all three were dead mechanisms here: no WebSearch repeat-search deny/compression, no repeat-skill-load deny, no agent-spawn briefing or report compaction. apply_patch (patchText only, no per-file path) and lsp/plan/question/todo have no token-goat equivalent and stay unmapped.
 const TOOL_TO_TG = {
   read: "Read",
   bash: "Bash",
@@ -4562,15 +4614,15 @@ const TOOL_TO_TG = {
   grep: "Grep",
   glob: "Glob",
   webfetch: "WebFetch",
+  websearch: "WebSearch",
+  skill: "Skill",
+  task: "task",
 }
 
-// Tools with a real pre_tool_use handler registered server-side (hooks_read.ts,
-// image_shrink.ts, hooks_bash.ts, hooks_fetch.ts). Edit/Write have no pre-hook
-// in token-goat at all, so skip the subprocess call for them entirely. Glob
-// has none either, so it's excluded too rather than spawning a no-op call.
-const PRE_HOOK_TOOLS = new Set(["read", "bash", "grep", "webfetch"])
+// Tools with a pre_tool_use handler server-side whose OUTPUT SHAPE this hook can act on: deny (throw), updatedInput (args rewrite), or the Read image-shrink materialization. websearch (repeat-search deny within the dedup TTL, hooks_websearch.ts), skill (repeat-load deny, hooks_skill.ts) and task (briefing updatedInput rewrite, hooks_agent_spawn.ts) all qualify. Edit/Write have no pre-hook at all. Glob DOES have one (preGlobDedupHandler, hooks_glob.ts) -- the old claim here that it has none was stale -- but its only output is an advisory contextOutput hint, and tool.execute.before has no context channel (see the module docblock), so calling it would spawn a subprocess per glob only to drop the answer; it stays excluded for that reason, not the old one.
+const PRE_HOOK_TOOLS = new Set(["read", "bash", "grep", "webfetch", "websearch", "skill", "task"])
 
-// opencode tool args (camelCase) -> token-goat snake_case tool_input keys.
+// opencode tool args (camelCase) -> token-goat snake_case tool_input keys. websearch's query (websearch.ts Parameters), skill's name (skill.ts Parameters; hooks_skill.ts reads tool_input['skill']) and task's prompt/subagent_type/description (task.ts BaseParameterFields) are all from opencode's own schemas at v1.18.16.
 const ARGS_TO_TG = {
   read: { filePath: "file_path", offset: "offset", limit: "limit" },
   bash: { command: "command", timeout: "timeout" },
@@ -4579,6 +4631,9 @@ const ARGS_TO_TG = {
   grep: { pattern: "pattern", path: "path" },
   glob: { pattern: "pattern", path: "path" },
   webfetch: { url: "url" },
+  websearch: { query: "query" },
+  skill: { name: "skill" },
+  task: { prompt: "prompt", subagent_type: "subagent_type", description: "description" },
 }
 
 function reverseArgMap(tool) {
@@ -4614,28 +4669,7 @@ function extractUpdatedInput(resp) {
   return hso && typeof hso === "object" ? hso.updatedInput : undefined
 }
 
-// Decode a token-goat image-shrink additionalContext payload
-// ("<summary>\\ndata:image/<fmt>;base64,<data>") into a real file on disk,
-// since tool.execute.before has no context-injection channel to hand the
-// shrunk image to the model directly -- only output.args mutation. Returns
-// undefined (leaving output.args untouched) if the context isn't a shrink
-// payload or anything goes wrong writing it.
-function materializeShrunkImage(context) {
-  if (typeof context !== "string") return undefined
-  const idx = context.indexOf("data:image/")
-  if (idx === -1) return undefined
-  const match = /^data:image\\/([a-zA-Z0-9.+-]+);base64,([A-Za-z0-9+/=]+)$/.exec(context.slice(idx).trim())
-  if (!match) return undefined
-  try {
-    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 file = path.join(os.tmpdir(), name)
-    fs.writeFileSync(file, buf)
-    return file
-  } catch {
-    return undefined
-  }
-}
+${MATERIALIZE_SHRUNK_IMAGE_JS}
 
 export const TokenGoatPlugin = async ({ directory }) => {
   return {
@@ -4685,6 +4719,14 @@ export const TokenGoatPlugin = async ({ directory }) => {
       })
       if (!resp) return
 
+      // rewriteOutput: replace the tool result wholesale. This is the shape every post_tool_use rewrite producer emits (WebFetch injection fencing and secret redaction, websearch redaction, bash/grep output compression, agent-report compaction), and it went unapplied here for the same whitelist reason the response-contract docblock above used to omit it -- the plugin only handled the shapes its author listed, so opencode sessions got the appended hint channel but never a fenced, redacted or compressed result. Mutating output.output is the exact mechanism the context append below already relies on, so this claims no capability the append did not.
+      const hso = resp.hookSpecificOutput
+      const updatedToolOutput = hso && typeof hso.updatedToolOutput === "string" ? hso.updatedToolOutput : undefined
+      if (updatedToolOutput !== undefined) {
+        output.output = updatedToolOutput
+        return
+      }
+
       const context = extractContext(resp)
       if (context && typeof output.output === "string") {
         output.output += \`\\n\\n[token-goat] \${context}\`
@@ -4739,15 +4781,11 @@ 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
 //
-// NOTE ON PARAMETER SHAPES: OpenClaw's tool-call params are forwarded to
-// token-goat's tool_input unchanged (no key remapping) -- verified against
-// OpenClaw's own event-type source that these keys are already snake_case
-// (file_path, command, etc.), matching token-goat's own convention. The
-// built-in tool NAME list below is broader than any single source confirms,
-// since an unmatched name is a harmless no-op here, not a wrong rewrite.
+// NOTE ON PARAMETER SHAPES: OpenClaw's bash tool really does use token-goat's own key names (command/timeout), but the path-carrying tools (read/edit/write) send the file path under "path", not "file_path" -- read out of OpenClaw's own tool input schemas (src/agents/sessions/tools/read-tool-contract.ts, edit.ts, bash.ts in openclaw/openclaw). toToolInput below ADDS the canonical file_path alongside the original path so token-goat's getFilePath()-based handlers can see it, without renaming anything. The built-in tool NAME list below is broader than any single source confirms, since an unmatched name is a harmless no-op here, not a wrong rewrite.
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
@@ -4758,20 +4796,43 @@ const TOOL_TO_TG = {
   edit: "Edit",
   apply_patch: "Edit",
   exec: "Bash",
+  bash: "Bash",
   grep: "Grep",
   glob: "Glob",
+  find: "Glob",
   webfetch: "WebFetch",
   web_search: "WebFetch",
   web_fetch: "WebFetch",
 };
 
-// Tools with a registered pre_tool_use handler in token-goat (Edit/Write have
-// none; Glob has none either -- see pi.ts/opencode.ts's identical
-// PRE_HOOK_TOOLS note -- so it's excluded to avoid a wasted no-op spawn).
+// Tools with a pre_tool_use handler whose output shape this hook can act on: deny (block/blockReason), updatedInput (params rewrite), or the Read image-shrink materialization. Edit/Write have no pre handler at all. Glob (OpenClaw's find) DOES have one -- preGlobDedupHandler in hooks_glob.ts; the old claim here that it has none was stale -- but its only output is an advisory contextOutput hint and before_tool_call has no context channel, so calling it would spawn a hook subprocess per find only to drop the answer; it stays excluded for that reason (matching pi.ts/opencode.ts's corrected note).
 const PRE_HOOK_TOOLS = new Set(["Read", "Grep", "Bash", "WebFetch"]);
 
+// OpenClaw tools whose file path travels under "path" (see the parameter-shapes note above). apply_patch is deliberately absent: its input is a patch document, not a single path.
+const PATH_ARG_TOOLS = new Set(["read", "write", "edit"]);
+
+// Build token-goat's tool_input from OpenClaw's params: same object, plus the canonical file_path added alongside the original path for the tools that carry one. Never renames or drops a key.
+function toToolInput(toolName, params) {
+  const p = params || {};
+  if (PATH_ARG_TOOLS.has(toolName) && typeof p.path === "string" && p.file_path === undefined) {
+    return { ...p, file_path: p.path };
+  }
+  return p;
+}
+
+// Pull the additionalContext / systemMessage string out of a hook response, whichever shape it came back as (see the response-contract note in this module's header comment).
+function extractContext(resp) {
+  if (!resp) return undefined;
+  const hso = resp["hookSpecificOutput"];
+  if (hso && typeof hso["additionalContext"] === "string") return hso["additionalContext"];
+  if (typeof resp["systemMessage"] === "string") return resp["systemMessage"];
+  return undefined;
+}
+
 ${BRIDGE_RELAY_JS}
 
+${MATERIALIZE_SHRUNK_IMAGE_JS}
+
 export default definePluginEntry({
   id: "token-goat",
   name: "token-goat",
@@ -4807,7 +4868,7 @@ export default definePluginEntry({
       const resp = await callHook("pre_tool_use", {
         session_id: sid,
         tool_name: tg,
-        tool_input: event.params || {},
+        tool_input: toToolInput(event.toolName, event.params),
         cwd: process.cwd(),
       });
       if (!resp) return {};
@@ -4826,6 +4887,12 @@ export default definePluginEntry({
         return { params: { ...(event.params || {}), ...updated } };
       }
 
+      // Image shrink has no context channel here -- translate it into a rewritten path pointing at a materialized shrunk copy instead, via the same params-rewrite channel the updatedInput merge above already relies on. OpenClaw's read tool takes the path under "path" (see the parameter-shapes note above), and the rest of the original params are preserved.
+      if (tg === "Read") {
+        const shrunkPath = materializeShrunkImage(extractContext(resp));
+        if (shrunkPath) return { params: { ...(event.params || {}), path: shrunkPath } };
+      }
+
       return {};
     });
 
@@ -4845,7 +4912,7 @@ export default definePluginEntry({
       await callHook("post_tool_use", {
         session_id: sid,
         tool_name: tg,
-        tool_input: event.params || {},
+        tool_input: toToolInput(event.toolName, event.params),
         cwd: process.cwd(),
         tool_response: toolResponse,
       });
@@ -5694,7 +5761,7 @@ function renderTopSessionFilesFromDisk(topN = 5, overrideSessionsDir) {
 var METHODOLOGY = {
   estimate_scope: "Local estimate of content avoided or reduced by token-goat.",
   billing: "They are not GitHub Copilot usage, provider-reported token consumption, or billing data.",
-  byte_derived_formula: "Most read, hook, and command entries use Math.round(bytes_saved / 4).",
+  byte_derived_formula: "Most read, hook, and command entries go through savedTokensFromBytes in src/stats.ts, which is Math.round(bytes_saved / 4).",
   filter_estimates: "Output compressors record their filter-calculated delta; image entries use the byte-derived approximation unless the source provides a narrower estimate.",
   advisory_events: "Zero-byte, zero-token advisory events show that guidance fired, not that an agent followed it.",
   audit: "Use stats --full or stats --json for source and command breakdowns; reconcile billing with provider-exported usage data."
@@ -5717,6 +5784,21 @@ function renderMethodology(json = false) {
     ""
   ].join("\n"));
 }
+function statsJsonPayload(summary) {
+  return {
+    total_events: summary.total_events,
+    total_bytes_saved: summary.total_bytes_saved,
+    total_tokens_saved: summary.total_tokens_saved,
+    by_kind: summary.by_kind,
+    by_day: summary.by_day,
+    by_project: summary.by_project,
+    by_command: summary.by_command,
+    by_source: summary.by_source,
+    by_harness: summary.by_harness,
+    counts: summary.counts,
+    window_days: summary.window_days
+  };
+}
 function runStats(opts = {}) {
   if (opts.methodology === true) {
     renderMethodology(opts.json === true);
@@ -5725,19 +5807,7 @@ function runStats(opts = {}) {
   const window = opts.windowDays ?? 30;
   const summary = summarize(window, void 0, opts.homeDir);
   if (opts.json === true) {
-    const out2 = {
-      total_events: summary.total_events,
-      total_bytes_saved: summary.total_bytes_saved,
-      total_tokens_saved: summary.total_tokens_saved,
-      by_kind: summary.by_kind,
-      by_day: summary.by_day,
-      by_project: summary.by_project,
-      by_command: summary.by_command,
-      by_source: summary.by_source,
-      by_harness: summary.by_harness,
-      window_days: summary.window_days
-    };
-    process.stdout.write(JSON.stringify(out2) + "\n");
+    process.stdout.write(JSON.stringify(statsJsonPayload(summary)) + "\n");
     return;
   }
   const renderOpts = { windowDays: window };
@@ -6286,7 +6356,9 @@ function checkUnmappedTools(dbPath) {
     if (rows.length === 0) {
       return { name, status: "ok", message: "every tool name seen so far reached a handler that wanted it" };
     }
-    const nearMisses = rows.filter((r) => r.near_miss !== null && r.near_miss !== void 0);
+    const nearMisses = rows.filter(
+      (r) => r.near_miss !== null && r.near_miss !== void 0 && r.near_miss !== r.tool_name
+    );
     if (nearMisses.length > 0) {
       const shown2 = nearMisses.slice(0, UNMAPPED_TOOL_SAMPLE).map((r) => `${r.harness} sent "${r.tool_name}" where "${r.near_miss}" is handled (${r.event_name}, ${r.hits}x)`);
       const more2 = nearMisses.length > UNMAPPED_TOOL_SAMPLE ? ` (+${nearMisses.length - UNMAPPED_TOOL_SAMPLE} more)` : "";
@@ -9188,12 +9260,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 pct = "";
+  let pct2 = "";
   if (contextK) {
-    pct = `  (${Math.round(result.total_tokens / (contextK * 1e3) * 100)}% of ${contextK}K)`;
+    pct2 = `  (${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, " ")}${pct}`
+    `  ${"Total".padEnd(colW, " ")}  ${String(result.total_lines).padStart(6, " ")}  ${String(result.total_tokens).padStart(8, " ")}${pct2}`
   );
   if (result.skipped.length > 0) {
     const skipped = result.skipped.slice(0, 5).join(", ");
@@ -11086,7 +11158,7 @@ function guardDeclarationRows(rows, budgetTokens) {
 function recordDepDocsStat(fullSourceBytes, emittedText, packageName) {
   const emittedBytes = Buffer.byteLength(emittedText, "utf8");
   const bytesSaved = Math.max(1, fullSourceBytes - emittedBytes);
-  recordStat("dep_docs", bytesSaved, Math.round(bytesSaved / 4), void 0, packageName);
+  recordStat("dep_docs", bytesSaved, savedTokensFromBytes(bytesSaved), void 0, packageName);
 }
 function runDepDocs(opts) {
   const root = resolveProjectRoot({ project: opts.projectRoot ?? process.cwd() });
@@ -11503,15 +11575,15 @@ function cmdCompactHint(opts) {
   const pressure = getContextPressure(cache ?? void 0);
   const [manifest, eventCount] = sessionId !== null ? buildManifestWithCount(sessionId) : ["", 0];
   const manifestTokens = estimateTokens(manifest);
-  const pct = (pressure.fillFraction * 100).toFixed(1);
+  const pct2 = (pressure.fillFraction * 100).toFixed(1);
   if (opts.json === true) {
-    const out2 = { tier: pressure.tier, fillFraction: pressure.fillFraction, pct: Number(pct), manifestTokens, eventCount };
+    const out2 = { tier: pressure.tier, fillFraction: pressure.fillFraction, pct: Number(pct2), 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} (${pct}% full)
+  process.stdout.write(`Compact hint \u2014 context: ${pressure.tier} (${pct2}% full)
 `);
   if (sessionId !== null) process.stdout.write(`Session: ${sessionId}
 `);
@@ -11611,6 +11683,19 @@ function indexSizeBytes(dbPath) {
   }
   return total;
 }
+function comparableSizes(result) {
+  const walInFlight = result.checkpointBusy && result.afterBytes > result.beforeBytes;
+  const before = walInFlight ? result.beforeDbBytes : result.beforeBytes;
+  const after = walInFlight ? result.afterDbBytes : result.afterBytes;
+  return { before, after, freed: before - after };
+}
+function dbFileBytes(dbPath) {
+  try {
+    return fs18.statSync(dbPath).size;
+  } catch {
+    return 0;
+  }
+}
 function tableExists(db, table) {
   const row = db.prepare(`SELECT 1 AS present FROM sqlite_master WHERE type IN ('table','view') AND name = ?`).get(table);
   return row?.present === 1;
@@ -11618,6 +11703,7 @@ function tableExists(db, table) {
 function reclaimIndex(dbPath, opts = {}) {
   const rebuild = opts.rebuild === true;
   const beforeBytes = indexSizeBytes(dbPath);
+  const beforeDbBytes = dbFileBytes(dbPath);
   const db = getDb(dbPath);
   const dropped = {};
   if (rebuild) {
@@ -11642,6 +11728,8 @@ function reclaimIndex(dbPath, opts = {}) {
   return {
     beforeBytes,
     afterBytes: indexSizeBytes(dbPath),
+    beforeDbBytes,
+    afterDbBytes: dbFileBytes(dbPath),
     dropped,
     rebuilt: rebuild,
     checkpointBusy: checkpointBusy || finalCheckpointBusy,
@@ -11677,13 +11765,12 @@ function cmdReclaimIndex(opts) {
     process.stdout.write(JSON.stringify({ dbPath, ...result }, null, 2) + "\n");
     return;
   }
-  const freed = result.beforeBytes - result.afterBytes;
+  const { before, after, freed } = comparableSizes(result);
+  const delta = freed >= 0 ? `freed ${mb(freed)}` : `grew ${mb(-freed)}`;
   process.stdout.write(`reclaim-index: ${dbPath}
 `);
-  process.stdout.write(
-    `  ${mb(result.beforeBytes)} -> ${mb(result.afterBytes)} (freed ${mb(freed)})
-`
-  );
+  process.stdout.write(`  ${mb(before)} -> ${mb(after)} (${delta})
+`);
   if (result.rebuilt) {
     for (const [table, n] of Object.entries(result.dropped)) {
       process.stdout.write(`  dropped ${n} row(s) from ${table}
@@ -11702,7 +11789,7 @@ function cmdReclaimIndex(opts) {
   }
   if (result.checkpointBusy) {
     process.stdout.write(
-      `  note: a concurrent reader blocked WAL truncation, so some space may still be held in ${path18.basename(dbPath)}-wal
+      `  note: a concurrent reader blocked WAL truncation, so some space is still held in ${path18.basename(dbPath)}-wal and the figures above count the main file only. The next checkpoint releases it
 `
     );
   }
@@ -12182,7 +12269,7 @@ function cmdProject(opts) {
 }
 function recordCompactDocStat(fullSourceBytes, emittedText, detail) {
   const bytesSaved = Math.max(1, fullSourceBytes - Buffer.byteLength(emittedText, "utf8"));
-  recordStat("compact_doc", bytesSaved, Math.round(bytesSaved / 4), void 0, detail);
+  recordStat("compact_doc", bytesSaved, savedTokensFromBytes(bytesSaved), void 0, detail);
 }
 function cmdCompactDoc(opts) {
   const resolved = path19.resolve(opts.filePath);
@@ -13107,10 +13194,10 @@ function printCopilotReport(report) {
     w(`  Conversation:      ${conversationTokens.toLocaleString()} tok
 `);
     if (total > 0) {
-      const pct = (fixed / total * 100).toFixed(1);
+      const pct2 = (fixed / total * 100).toFixed(1);
       w(`  ${fixed.toLocaleString()} tok of system prompt and tool definitions ships with every
 `);
-      w(`  request; at shutdown that was ${pct}% of the context. No hook can reach it: Copilot
+      w(`  request; at shutdown that was ${pct2}% 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");
@@ -13170,9 +13257,9 @@ function printCopilotReport(report) {
 `);
   } else {
     for (const block of report.blocks) {
-      const pct = block.bytes > 0 ? (block.repeatBytes / block.bytes * 100).toFixed(1) : "0.0";
+      const pct2 = 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 (${pct}%)
+      w(block.repeatBytes > 0 ? `, ${formatBytes(block.repeatBytes)} re-sent verbatim (${pct2}%)
 ` : "\n");
     }
   }
@@ -13502,22 +13589,693 @@ function formatSessionSlice(turns) {
   return parts.join("\n").trimEnd();
 }
 
-// src/cli_mcp_audit.ts
+// src/session_audit.ts
 import * as fs26 from "node:fs";
+import * as os12 from "node:os";
 import * as path26 from "node:path";
-function readMcpConfig(projectRoot) {
-  const configPath2 = path26.join(projectRoot, ".mcp.json");
+import * as readline3 from "node:readline";
+function emptyMeasured() {
+  return { apiCalls: 0, inputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0, outputTokens: 0 };
+}
+function emptyCategory() {
+  return { count: 0, bytes: 0, estTokens: 0 };
+}
+function addCategory(cat, bytes) {
+  cat.count += 1;
+  cat.bytes += bytes;
+  cat.estTokens += estimateTokensFromLength(bytes);
+}
+var LOCAL_ONLY_TYPES = /* @__PURE__ */ new Set([
+  "file-history-snapshot",
+  "queue-operation",
+  "mode",
+  "permission-mode",
+  "last-prompt",
+  "bridge-session",
+  "ai-title"
+]);
+var ATTACHMENT_VISIBLE_FIELDS = {
+  hook_success: ["content"],
+  hook_additional_context: ["content"],
+  task_reminder: ["content"],
+  skill_listing: ["content"],
+  agent_listing_delta: ["addedLines"],
+  file: ["content"],
+  queued_command: ["prompt"],
+  plan_file_reference: ["planContent"],
+  edited_text_file: ["snippet"],
+  read_truncation_notice: ["banner"],
+  total_tokens_reminder: ["text"],
+  nested_memory: ["content"],
+  mcp_instructions_delta: ["addedBlocks"],
+  invoked_skills: ["skills"],
+  date_change: ["newDate"],
+  goal_status: ["condition"],
+  task_status: ["deltaSummary", "description"],
+  command_permissions: ["allowedTools"]
+};
+var CACHE_WRITE_MULTIPLIER = 1.25;
+var CACHE_READ_MULTIPLIER = 0.1;
+var READ_DIVERT_MARKER_RE = /(?:was already read this session|Already read |You've already read|Use `token-goat (?:section|read|bash-output|config-get|skeleton)|token-goat bash-output --file)/;
+var READ_DIVERT_MAX_BYTES = 2500;
+var READ_FULL_SERVE_MIN_BYTES = 10240;
+var BASH_FILTER_MARKER_RE = /\[token-goat[:\]]/;
+var BASH_SMALL_RESULT_MAX_BYTES = 1024;
+function commandHead(raw) {
+  let s = raw.trim();
+  for (let guard = 0; guard < 20; guard++) {
+    const stripped = s.replace(/^[(\s]+/, "");
+    const env = /^[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|\S*)\s+/.exec(stripped);
+    if (env !== null) {
+      s = stripped.slice(env[0].length);
+      continue;
+    }
+    const cd = /^cd\s+(?:"[^"]*"|'[^']*'|[^\s;&]+)[^\S\n]*(?:&&|;|\n)\s*/.exec(stripped);
+    if (cd !== null) {
+      s = stripped.slice(cd[0].length);
+      continue;
+    }
+    if (stripped === s) break;
+    s = stripped;
+  }
+  const m = /^"([^"]+)"|^'([^']+)'|^(\S+)/.exec(s);
+  const tok = m === null ? "" : m[1] ?? m[2] ?? m[3] ?? "";
+  const base = tok.split(/[\\/]/).pop() ?? "";
+  const head = base.replace(/\.exe$/i, "").toLowerCase();
+  return head === "" ? "(none)" : head;
+}
+function normalizeReadPath(p) {
+  return p.replace(/\\/g, "/").toLowerCase();
+}
+function deepStringBytes(value) {
+  if (typeof value === "string") return Buffer.byteLength(value, "utf8");
+  if (Array.isArray(value)) return value.reduce((acc, v) => acc + deepStringBytes(v), 0);
+  if (value !== null && typeof value === "object") {
+    return Object.values(value).reduce((acc, v) => acc + deepStringBytes(v), 0);
+  }
+  return 0;
+}
+var OMISSION_MARKER_RE = /(?:--- (\d+) lines omitted ---|\[token-goat: \+?(\d+) more [a-z ]*lines omitted\]|--- patch: (\d+) lines omitted by token-goat ---|\.\.\. (\d+) lines omitted by token-goat \.\.\.)/g;
+function toolResultText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    let text = "";
+    for (const block of content) {
+      if (block !== null && typeof block === "object" && typeof block.text === "string") {
+        text += block.text;
+      }
+    }
+    return text;
+  }
+  return "";
+}
+function listCorpusTranscripts(corpusDir) {
+  const found = [];
+  const walk = (dir, entries) => {
+    for (const entry of entries) {
+      const full = path26.join(dir, entry.name);
+      if (entry.name.endsWith(".jsonl")) {
+        found.push(full);
+      } else if (entry.isDirectory()) {
+        let inner;
+        try {
+          inner = fs26.readdirSync(full, { withFileTypes: true });
+        } catch {
+          continue;
+        }
+        walk(full, inner);
+      }
+    }
+  };
+  walk(corpusDir, fs26.readdirSync(corpusDir, { withFileTypes: true }));
+  return found.sort();
+}
+function defaultCorpusDir() {
+  return path26.join(os12.homedir(), ".claude", "projects");
+}
+async function auditOneFile(filePath, s, toolMap, attachmentMap, hookMap, laneObservations, bashHeadMap) {
+  const isLane = filePath.split(/[\\/]/).includes("subagents");
+  let laneFirstPrefix = null;
+  let laneBriefBytes = -1;
+  const toolNameById = /* @__PURE__ */ new Map();
+  const bashHeadById = /* @__PURE__ */ new Map();
+  let pendingBashReread = [];
+  const readCallById = /* @__PURE__ */ new Map();
+  const readPathEpoch = /* @__PURE__ */ new Map();
+  let compactEpoch = 0;
+  let sawTokenGoatHook = false;
+  let fileRepeats = 0;
+  let fileRepeatsFullNoRange = 0;
+  let fileRepeatsFullNoRangeAfterCompaction = 0;
+  const usageSeenIds = /* @__PURE__ */ new Set();
+  const perCall = [];
+  const laneCalls = [0, 0];
+  let pendingReread = [];
+  const lastVisibleByKind = /* @__PURE__ */ new Map();
+  const flushLane = (lane) => {
+    const kept = [];
+    for (const p of pendingReread) {
+      if (p.lane !== lane) {
+        kept.push(p);
+        continue;
+      }
+      attachmentRollup(attachmentMap, p.kind).rereadTokens += p.tokens * Math.max(0, laneCalls[lane] - p.atCall);
+    }
+    pendingReread = kept;
+    const keptBash = [];
+    for (const p of pendingBashReread) {
+      if (p.lane !== lane) {
+        keptBash.push(p);
+        continue;
+      }
+      s.bashInterception.untouchedRereadTokens += p.tokens * Math.max(0, laneCalls[lane] - p.atCall);
+    }
+    pendingBashReread = keptBash;
+  };
+  const stream = fs26.createReadStream(filePath);
+  const rl = readline3.createInterface({ input: stream, crlfDelay: Infinity });
+  const streamFailure = new Promise((_, reject) => stream.on("error", reject));
+  const consume = (async () => {
+    for await (const line of rl) {
+      if (line.length === 0) continue;
+      s.lines += 1;
+      const lineBytes = Buffer.byteLength(line, "utf8");
+      s.totalBytes += lineBytes;
+      let obj;
+      try {
+        obj = JSON.parse(line);
+      } catch {
+        s.parseFailedLines += 1;
+        addCategory(s.estimated.otherLocal, lineBytes);
+        continue;
+      }
+      const type = typeof obj["type"] === "string" ? obj["type"] : "(untyped)";
+      const census = s.lineTypes[type] ??= { lines: 0, bytes: 0 };
+      census.lines += 1;
+      census.bytes += lineBytes;
+      if (LOCAL_ONLY_TYPES.has(type)) {
+        addCategory(s.estimated.otherLocal, lineBytes);
+        continue;
+      }
+      const message = obj["message"];
+      if (type === "assistant" && message !== void 0) {
+        const usage = message.usage;
+        if (usage !== void 0 && typeof message.id === "string" && !usageSeenIds.has(message.id)) {
+          usageSeenIds.add(message.id);
+          const num = (k) => typeof usage[k] === "number" ? usage[k] : 0;
+          const input = num("input_tokens");
+          const cacheWrite = num("cache_creation_input_tokens");
+          const cacheRead = num("cache_read_input_tokens");
+          const output = num("output_tokens");
+          s.measured.apiCalls += 1;
+          s.measured.inputTokens += input;
+          s.measured.cacheCreationTokens += cacheWrite;
+          s.measured.cacheReadTokens += cacheRead;
+          s.measured.outputTokens += output;
+          if (obj["isSidechain"] === true) {
+            s.measuredSidechain.apiCalls += 1;
+            s.measuredSidechain.inputTokens += input;
+            s.measuredSidechain.cacheCreationTokens += cacheWrite;
+            s.measuredSidechain.cacheReadTokens += cacheRead;
+            s.measuredSidechain.outputTokens += output;
+          }
+          if (isLane && laneFirstPrefix === null) laneFirstPrefix = input + cacheWrite + cacheRead;
+          perCall.push({ inputTotal: input + cacheWrite + cacheRead, cacheRead, output });
+          const callLane = obj["isSidechain"] === true ? 1 : 0;
+          laneCalls[callLane] = laneCalls[callLane] + 1;
+        }
+        const blocks = Array.isArray(message.content) ? message.content : [];
+        for (const block of blocks) {
+          if (block === null || typeof block !== "object") continue;
+          if (block["type"] === "text" && typeof block["text"] === "string") {
+            addCategory(s.estimated.assistantText, Buffer.byteLength(block["text"], "utf8"));
+          } else if (block["type"] === "thinking" && typeof block["thinking"] === "string") {
+            addCategory(s.estimated.assistantThinking, Buffer.byteLength(block["thinking"], "utf8"));
+          } else if (block["type"] === "tool_use" && typeof block["id"] === "string") {
+            const name = typeof block["name"] === "string" ? block["name"] : "(unnamed)";
+            if (!toolNameById.has(block["id"])) {
+              toolNameById.set(block["id"], name);
+              toolRollup(toolMap, name).calls += 1;
+              const input = block["input"] !== null && typeof block["input"] === "object" ? block["input"] : {};
+              if (name === "Bash" && typeof input["command"] === "string") {
+                bashHeadById.set(block["id"], commandHead(input["command"]));
+              } else if (name === "Read" && typeof input["file_path"] === "string") {
+                const norm = normalizeReadPath(input["file_path"]);
+                const priorEpoch = readPathEpoch.get(norm);
+                readCallById.set(block["id"], { wasSeenBefore: priorEpoch !== void 0, hasRange: input["offset"] !== void 0 || input["limit"] !== void 0, afterCompaction: priorEpoch !== void 0 && compactEpoch > priorEpoch });
+                readPathEpoch.set(norm, compactEpoch);
+              }
+            }
+            let inputBytes;
+            try {
+              inputBytes = Buffer.byteLength(JSON.stringify(block["input"] ?? null), "utf8");
+            } catch {
+              inputBytes = 0;
+            }
+            addCategory(s.estimated.toolUseInputs, inputBytes);
+          }
+        }
+        continue;
+      }
+      if (type === "user" && message !== void 0) {
+        const blocks = Array.isArray(message.content) ? message.content : [];
+        let sawToolResult = false;
+        for (const block of blocks) {
+          if (block === null || typeof block !== "object" || block["type"] !== "tool_result") continue;
+          sawToolResult = true;
+          const text = toolResultText(block["content"]);
+          const bytes = Buffer.byteLength(text, "utf8");
+          const id = typeof block["tool_use_id"] === "string" ? block["tool_use_id"] : "";
+          const name = toolNameById.get(id) ?? "(unknown)";
+          addCategory(s.estimated.toolResults, bytes);
+          const roll = toolRollup(toolMap, name);
+          if (!toolNameById.has(id)) roll.calls += 1;
+          roll.resultBytes += bytes;
+          roll.resultEstTokens += estimateTokensFromLength(bytes);
+          if (name === "Read") {
+            s.readInterception.readResults += 1;
+            if (bytes < READ_DIVERT_MAX_BYTES && READ_DIVERT_MARKER_RE.test(text)) {
+              s.readInterception.divertedByMarker += 1;
+              s.readInterception.divertedBytes += bytes;
+            } else if (bytes >= READ_FULL_SERVE_MIN_BYTES) {
+              s.readInterception.fullServesOver10k += 1;
+              s.readInterception.fullServeBytesOver10k += bytes;
+              const call = readCallById.get(id);
+              if (call === void 0) {
+                s.readInterception.fullServesPathUnknown += 1;
+              } else if (call.wasSeenBefore) {
+                s.readInterception.fullServesRepeat += 1;
+                s.readInterception.repeatBytes += bytes;
+                fileRepeats += 1;
+                if (call.hasRange) {
+                  s.readInterception.repeatWithRange += 1;
+                } else {
+                  s.readInterception.repeatFullNoRange += 1;
+                  fileRepeatsFullNoRange += 1;
+                  if (call.afterCompaction) fileRepeatsFullNoRangeAfterCompaction += 1;
+                }
+              } else {
+                s.readInterception.fullServesFirstRead += 1;
+              }
+            }
+          } else if (name === "Bash") {
+            const b = s.bashInterception;
+            b.bashResults += 1;
+            if (BASH_FILTER_MARKER_RE.test(text)) {
+              b.markedByFilter += 1;
+              b.markedBytes += bytes;
+            } else if (bytes < BASH_SMALL_RESULT_MAX_BYTES) {
+              b.smallUntouched += 1;
+              b.smallUntouchedBytes += bytes;
+            } else {
+              b.untouched += 1;
+              b.untouchedBytes += bytes;
+              const tokens = estimateTokensFromLength(bytes);
+              b.untouchedEstTokens += tokens;
+              const lane = obj["isSidechain"] === true ? 1 : 0;
+              pendingBashReread.push({ tokens, atCall: laneCalls[lane], lane });
+              const head = bashHeadById.get(id) ?? "(unknown)";
+              let headRoll = bashHeadMap.get(head);
+              if (headRoll === void 0) {
+                headRoll = { head, results: 0, bytes: 0 };
+                bashHeadMap.set(head, headRoll);
+              }
+              headRoll.results += 1;
+              headRoll.bytes += bytes;
+            }
+          }
+          OMISSION_MARKER_RE.lastIndex = 0;
+          for (const m of text.matchAll(OMISSION_MARKER_RE)) {
+            s.omissionMarkers.fires += 1;
+            s.omissionMarkers.linesOmitted += Number(m[1] ?? m[2] ?? m[3] ?? m[4] ?? 0);
+          }
+        }
+        if (!sawToolResult) {
+          const target = obj["isMeta"] === true ? s.estimated.harnessMeta : s.estimated.userTurns;
+          let contentBytes = 0;
+          if (typeof message.content === "string") {
+            contentBytes = Buffer.byteLength(message.content, "utf8");
+          } else {
+            for (const block of blocks) {
+              if (block !== null && typeof block === "object" && typeof block["text"] === "string") {
+                contentBytes += Buffer.byteLength(block["text"], "utf8");
+              }
+            }
+          }
+          addCategory(target, contentBytes);
+          if (isLane && laneBriefBytes < 0 && obj["isMeta"] !== true) laneBriefBytes = contentBytes;
+        }
+        continue;
+      }
+      if (type === "attachment") {
+        addCategory(s.estimated.attachments, lineBytes);
+        const att = obj["attachment"] !== null && typeof obj["attachment"] === "object" ? obj["attachment"] : {};
+        const kind = typeof att["type"] === "string" ? att["type"] : "(untyped)";
+        const lane = obj["isSidechain"] === true ? 1 : 0;
+        const roll = attachmentRollup(attachmentMap, kind);
+        roll.injections += 1;
+        roll.lineBytes += lineBytes;
+        const fields = ATTACHMENT_VISIBLE_FIELDS[kind];
+        if (fields !== void 0) {
+          const visibleBytes = fields.reduce((acc, f) => acc + deepStringBytes(att[f]), 0);
+          roll.visibleBytes += visibleBytes;
+          const tokens = visibleBytes > 0 ? estimateTokensFromLength(visibleBytes) : 0;
+          roll.estTokens += tokens;
+          if (tokens > 0) pendingReread.push({ kind, tokens, atCall: laneCalls[lane], lane });
+          let serialized;
+          try {
+            serialized = JSON.stringify(fields.map((f) => att[f]));
+          } catch {
+            serialized = "";
+          }
+          const previous = lastVisibleByKind.get(kind);
+          if (previous !== void 0) {
+            if (previous === serialized) roll.repeatedIdentical += 1;
+            else roll.repeatedChanged += 1;
+          }
+          lastVisibleByKind.set(kind, serialized);
+        }
+        if (kind === "hook_success") {
+          const command = typeof att["command"] === "string" ? att["command"] : "";
+          const origin = command.includes("token-goat") || command.includes("token_goat") ? "token-goat" : "other";
+          if (origin === "token-goat") sawTokenGoatHook = true;
+          const event = typeof att["hookEvent"] === "string" ? att["hookEvent"] : "(none)";
+          const hook = hookRollup(hookMap, origin, event);
+          hook.fires += 1;
+          hook.stdoutBytes += typeof att["stdout"] === "string" ? Buffer.byteLength(att["stdout"], "utf8") : 0;
+          hook.contextBytes += typeof att["content"] === "string" ? Buffer.byteLength(att["content"], "utf8") : 0;
+        }
+        continue;
+      }
+      if (type === "system" || type === "summary") {
+        if (obj["subtype"] === "compact_boundary") {
+          flushLane(obj["isSidechain"] === true ? 1 : 0);
+          compactEpoch += 1;
+        }
+        addCategory(s.estimated.system, lineBytes);
+        continue;
+      }
+      addCategory(s.estimated.otherLocal, lineBytes);
+    }
+  })();
+  void consume.catch(() => {
+  });
+  void streamFailure.catch(() => {
+  });
   try {
-    if (!fs26.existsSync(configPath2)) {
-      return null;
+    await Promise.race([consume, streamFailure]);
+  } finally {
+    rl.close();
+    stream.destroy();
+  }
+  flushLane(0);
+  flushLane(1);
+  if (sawTokenGoatHook) {
+    s.readInterception.repeatInHookedSessions += fileRepeats;
+    s.readInterception.repeatFullNoRangeInHookedSessions += fileRepeatsFullNoRange;
+    s.readInterception.repeatFullNoRangeHookedAfterCompaction += fileRepeatsFullNoRangeAfterCompaction;
+  }
+  if (isLane) {
+    let agentType = "(none)";
+    try {
+      const meta = JSON.parse(fs26.readFileSync(filePath.replace(/\.jsonl$/i, ".meta.json"), "utf8"));
+      if (typeof meta["agentType"] === "string" && meta["agentType"] !== "") agentType = meta["agentType"];
+    } catch {
     }
-    const content = fs26.readFileSync(configPath2, "utf-8");
+    laneObservations.push({ firstPrefixTokens: laneFirstPrefix, calls: usageSeenIds.size, briefBytes: Math.max(0, laneBriefBytes), agentType });
+  }
+  const callCount = perCall.length;
+  for (let i = 0; i < callCount; i++) {
+    const call = perCall[i];
+    const d = s.positionDeciles[Math.min(9, Math.floor(i * 10 / callCount))];
+    d.apiCalls += 1;
+    d.inputTokens += call.inputTotal;
+    d.cacheReadTokens += call.cacheRead;
+    d.outputTokens += call.output;
+  }
+}
+function toolRollup(toolMap, name) {
+  let roll = toolMap.get(name);
+  if (roll === void 0) {
+    roll = { name, calls: 0, resultBytes: 0, resultEstTokens: 0 };
+    toolMap.set(name, roll);
+  }
+  return roll;
+}
+function attachmentRollup(attachmentMap, kind) {
+  let roll = attachmentMap.get(kind);
+  if (roll === void 0) {
+    roll = { kind, injections: 0, lineBytes: 0, visibleBytes: 0, estTokens: 0, rereadTokens: 0, billedEquivTokens: 0, repeatedIdentical: 0, repeatedChanged: 0 };
+    attachmentMap.set(kind, roll);
+  }
+  return roll;
+}
+function hookRollup(hookMap, origin, event) {
+  const key = `${origin}|${event}`;
+  let roll = hookMap.get(key);
+  if (roll === void 0) {
+    roll = { origin, event, fires: 0, stdoutBytes: 0, contextBytes: 0 };
+    hookMap.set(key, roll);
+  }
+  return roll;
+}
+async function auditSessionCorpus(opts = {}) {
+  const corpusDir = path26.resolve(opts.dir ?? defaultCorpusDir());
+  if (!fs26.existsSync(corpusDir)) {
+    throw new Error(`session corpus directory not found: ${corpusDir}`);
+  }
+  const files = listCorpusTranscripts(corpusDir);
+  if (files.length === 0) {
+    throw new Error(`no .jsonl session transcripts found under ${corpusDir}`);
+  }
+  const started = Date.now();
+  const summary = {
+    corpusDir,
+    filesScanned: 0,
+    filesFailed: 0,
+    lines: 0,
+    parseFailedLines: 0,
+    totalBytes: 0,
+    runtimeMs: 0,
+    measured: emptyMeasured(),
+    measuredSidechain: emptyMeasured(),
+    estimated: {
+      userTurns: emptyCategory(),
+      toolResults: emptyCategory(),
+      assistantText: emptyCategory(),
+      assistantThinking: emptyCategory(),
+      toolUseInputs: emptyCategory(),
+      attachments: emptyCategory(),
+      harnessMeta: emptyCategory(),
+      system: emptyCategory(),
+      otherLocal: emptyCategory()
+    },
+    tools: [],
+    attachmentKinds: [],
+    hookOutputs: [],
+    positionDeciles: Array.from({ length: 10 }, (_, i) => ({ decile: i + 1, apiCalls: 0, inputTokens: 0, cacheReadTokens: 0, outputTokens: 0 })),
+    sidechainLanes: { laneFiles: 0, lanesWithUsage: 0, meanFirstCallPrefixTokens: 0, medianFirstCallPrefixTokens: 0, p90FirstCallPrefixTokens: 0, meanCallsPerLane: 0, meanBriefBytes: 0, prefixBilledEquivTokens: 0 },
+    laneAgentTypes: [],
+    readInterception: { readResults: 0, divertedByMarker: 0, divertedBytes: 0, fullServesOver10k: 0, fullServeBytesOver10k: 0, fullServesFirstRead: 0, fullServesRepeat: 0, repeatBytes: 0, repeatWithRange: 0, repeatFullNoRange: 0, repeatInHookedSessions: 0, repeatFullNoRangeInHookedSessions: 0, repeatFullNoRangeHookedAfterCompaction: 0, fullServesPathUnknown: 0 },
+    bashInterception: { bashResults: 0, markedByFilter: 0, markedBytes: 0, smallUntouched: 0, smallUntouchedBytes: 0, untouched: 0, untouchedBytes: 0, untouchedEstTokens: 0, untouchedRereadTokens: 0, untouchedBilledEquivTokens: 0, untouchedHeads: [] },
+    lineTypes: {},
+    omissionMarkers: { fires: 0, linesOmitted: 0 }
+  };
+  const toolMap = /* @__PURE__ */ new Map();
+  const attachmentMap = /* @__PURE__ */ new Map();
+  const hookMap = /* @__PURE__ */ new Map();
+  const laneObservations = [];
+  const bashHeadMap = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    try {
+      await auditOneFile(file, summary, toolMap, attachmentMap, hookMap, laneObservations, bashHeadMap);
+      summary.filesScanned += 1;
+    } catch {
+      summary.filesFailed += 1;
+    }
+  }
+  const withUsage = laneObservations.filter((l) => l.firstPrefixTokens !== null);
+  const prefixes = withUsage.map((l) => l.firstPrefixTokens).sort((a, b) => a - b);
+  const mean = (arr) => arr.length === 0 ? 0 : Math.round(arr.reduce((a, b) => a + b, 0) / arr.length);
+  summary.sidechainLanes = {
+    laneFiles: laneObservations.length,
+    lanesWithUsage: withUsage.length,
+    meanFirstCallPrefixTokens: mean(prefixes),
+    medianFirstCallPrefixTokens: prefixes.length === 0 ? 0 : prefixes[Math.floor(prefixes.length / 2)],
+    p90FirstCallPrefixTokens: prefixes.length === 0 ? 0 : prefixes[Math.min(prefixes.length - 1, Math.floor(prefixes.length * 0.9))],
+    meanCallsPerLane: mean(withUsage.map((l) => l.calls)),
+    meanBriefBytes: mean(withUsage.map((l) => l.briefBytes)),
+    prefixBilledEquivTokens: Math.round(withUsage.reduce((acc, l) => acc + l.firstPrefixTokens * (CACHE_WRITE_MULTIPLIER + CACHE_READ_MULTIPLIER * Math.max(0, l.calls - 1)), 0))
+  };
+  const byType = /* @__PURE__ */ new Map();
+  for (const l of laneObservations) {
+    const bucket = byType.get(l.agentType);
+    if (bucket === void 0) byType.set(l.agentType, [l]);
+    else bucket.push(l);
+  }
+  summary.laneAgentTypes = [...byType.entries()].map(([agentType, obs]) => {
+    const typed = obs.filter((l) => l.firstPrefixTokens !== null).map((l) => l.firstPrefixTokens).sort((a, b) => a - b);
+    return { agentType, lanes: obs.length, lanesWithUsage: typed.length, meanFirstCallPrefixTokens: mean(typed), medianFirstCallPrefixTokens: typed.length === 0 ? 0 : typed[Math.floor(typed.length / 2)] };
+  }).sort((a, b) => b.lanes - a.lanes || a.agentType.localeCompare(b.agentType));
+  summary.bashInterception.untouchedBilledEquivTokens = Math.round(CACHE_WRITE_MULTIPLIER * summary.bashInterception.untouchedEstTokens + CACHE_READ_MULTIPLIER * summary.bashInterception.untouchedRereadTokens);
+  summary.bashInterception.untouchedHeads = [...bashHeadMap.values()].sort((a, b) => b.bytes - a.bytes || b.results - a.results || a.head.localeCompare(b.head));
+  summary.tools = [...toolMap.values()].sort((a, b) => b.resultBytes - a.resultBytes || a.name.localeCompare(b.name));
+  for (const roll of attachmentMap.values()) {
+    roll.billedEquivTokens = Math.round(CACHE_WRITE_MULTIPLIER * roll.estTokens + CACHE_READ_MULTIPLIER * roll.rereadTokens);
+  }
+  summary.attachmentKinds = [...attachmentMap.values()].sort((a, b) => b.billedEquivTokens - a.billedEquivTokens || b.injections - a.injections || a.kind.localeCompare(b.kind));
+  summary.hookOutputs = [...hookMap.values()].sort((a, b) => b.contextBytes - a.contextBytes || b.fires - a.fires || a.origin.localeCompare(b.origin) || a.event.localeCompare(b.event));
+  summary.runtimeMs = Date.now() - started;
+  return summary;
+}
+function fmt(n) {
+  return n.toLocaleString("en-US");
+}
+function pct(part, whole) {
+  return whole === 0 ? "0.0%" : `${(part / whole * 100).toFixed(1)}%`;
+}
+function formatSessionAudit(s) {
+  const lines = [];
+  lines.push("# Session corpus audit");
+  lines.push(`Corpus: ${s.corpusDir}`);
+  lines.push(`Files: ${fmt(s.filesScanned)} scanned, ${fmt(s.filesFailed)} unreadable`);
+  lines.push(`Lines: ${fmt(s.lines)} (${fmt(s.parseFailedLines)} unparseable), bytes: ${fmt(s.totalBytes)}`);
+  lines.push(`Runtime: ${(s.runtimeMs / 1e3).toFixed(1)}s`);
+  lines.push("");
+  lines.push("## Measured billed tokens (assistant message.usage, one count per API response)");
+  const m = s.measured;
+  lines.push(`API calls: ${fmt(m.apiCalls)} (sidechain: ${fmt(s.measuredSidechain.apiCalls)})`);
+  lines.push(`Output tokens:      ${fmt(m.outputTokens)}`);
+  lines.push(`Input, uncached:    ${fmt(m.inputTokens)}`);
+  lines.push(`Input, cache-write: ${fmt(m.cacheCreationTokens)}`);
+  lines.push(`Input, cache-read:  ${fmt(m.cacheReadTokens)}`);
+  const totalInput = m.inputTokens + m.cacheCreationTokens + m.cacheReadTokens;
+  lines.push(`Cache-read share of input: ${pct(m.cacheReadTokens, totalInput)}`);
+  lines.push("");
+  lines.push("## Estimated content attribution (chars/3 heuristic; NOT billed units)");
+  const e = s.estimated;
+  const rows = [
+    ["tool results", e.toolResults],
+    ["assistant text", e.assistantText],
+    ["assistant thinking", e.assistantThinking],
+    ["tool call inputs", e.toolUseInputs],
+    ["attachments (harness)", e.attachments],
+    ["user turns", e.userTurns],
+    ["meta user lines", e.harnessMeta],
+    ["system lines", e.system],
+    ["local bookkeeping (never sent)", e.otherLocal]
+  ];
+  const modelVisibleBytes = rows.slice(0, 8).reduce((acc, [, c]) => acc + c.bytes, 0);
+  for (const [label, cat] of rows.sort((a, b) => b[1].bytes - a[1].bytes)) {
+    lines.push(`${label.padEnd(31)} count ${fmt(cat.count).padStart(11)}  bytes ${fmt(cat.bytes).padStart(15)}  est-tokens ${fmt(cat.estTokens).padStart(13)}  ${label === "local bookkeeping (never sent)" ? "(excluded from share)" : pct(cat.bytes, modelVisibleBytes)}`);
+  }
+  lines.push("");
+  lines.push("## Tool results by tool (estimated content size; calls = tool_use invocations)");
+  for (const t of s.tools.slice(0, 25)) {
+    lines.push(`${t.name.padEnd(42)} calls ${fmt(t.calls).padStart(9)}  bytes ${fmt(t.resultBytes).padStart(15)}  est-tokens ${fmt(t.resultEstTokens).padStart(12)}`);
+  }
+  if (s.tools.length > 25) lines.push(`(${s.tools.length - 25} smaller tools omitted from this table; --json has all)`);
+  lines.push("");
+  lines.push("## Attachment kinds by modeled billed cost (model-visible fields only; NOT billed units)");
+  lines.push("Model: est-tokens x 1.25 cache-write + reread-tokens x 0.1 cache-read; an injection stays in context until the next compact boundary on its lane, or end of transcript.");
+  for (const a of s.attachmentKinds.slice(0, 15)) {
+    lines.push(`${a.kind.padEnd(28)} inj ${fmt(a.injections).padStart(9)}  visible-bytes ${fmt(a.visibleBytes).padStart(13)}  est-tok ${fmt(a.estTokens).padStart(12)}  reread-tok ${fmt(a.rereadTokens).padStart(14)}  billed-equiv ${fmt(a.billedEquivTokens).padStart(12)}  identical-reinject ${fmt(a.repeatedIdentical).padStart(8)}`);
+  }
+  if (s.attachmentKinds.length > 15) lines.push(`(${s.attachmentKinds.length - 15} smaller kinds omitted from this table; --json has all)`);
+  lines.push("");
+  lines.push("## Hook stdout channel (hook_success attachments; context-bytes is the model-visible share)");
+  for (const h of s.hookOutputs) {
+    lines.push(`${h.origin.padEnd(11)} ${h.event.padEnd(18)} fires ${fmt(h.fires).padStart(9)}  stdout-bytes ${fmt(h.stdoutBytes).padStart(13)}  context-bytes ${fmt(h.contextBytes).padStart(13)}`);
+  }
+  lines.push("");
+  lines.push("## Measured billed tokens by session position (deciles of each session's API calls)");
+  for (const d of s.positionDeciles) {
+    lines.push(`decile ${d.decile.toString().padStart(2)}  calls ${fmt(d.apiCalls).padStart(9)}  input ${fmt(d.inputTokens).padStart(15)}  cache-read ${fmt(d.cacheReadTokens).padStart(15)}  output ${fmt(d.outputTokens).padStart(11)}`);
+  }
+  lines.push("");
+  lines.push("## Subagent lanes (spawn-prefix carriage; same residency model as the attachment census; NOT billed units)");
+  const sl = s.sidechainLanes;
+  lines.push(`Lane files: ${fmt(sl.laneFiles)} (${fmt(sl.lanesWithUsage)} with usage)`);
+  lines.push(`First-call prefix tokens: mean ${fmt(sl.meanFirstCallPrefixTokens)}, median ${fmt(sl.medianFirstCallPrefixTokens)}, p90 ${fmt(sl.p90FirstCallPrefixTokens)}`);
+  lines.push(`Calls per lane: mean ${fmt(sl.meanCallsPerLane)}; task-brief bytes: mean ${fmt(sl.meanBriefBytes)}`);
+  lines.push(`Prefix billed-equiv tokens: ${fmt(sl.prefixBilledEquivTokens)} (write x 1.25, then x 0.1 per later call in the lane)`);
+  for (const t of s.laneAgentTypes.slice(0, 12)) {
+    lines.push(`  type ${t.agentType.padEnd(24)} lanes ${fmt(t.lanes).padStart(7)} (${fmt(t.lanesWithUsage)} with usage)  prefix mean ${fmt(t.meanFirstCallPrefixTokens).padStart(9)}, median ${fmt(t.medianFirstCallPrefixTokens).padStart(9)}`);
+  }
+  if (s.laneAgentTypes.length > 12) lines.push(`  (${s.laneAgentTypes.length - 12} smaller agent types omitted from this table; --json has all)`);
+  lines.push("");
+  lines.push("## Read interception (token-goat divert markers inside Read tool results)");
+  const ri = s.readInterception;
+  lines.push(`Read results: ${fmt(ri.readResults)}; diverted by marker: ${fmt(ri.divertedByMarker)} (${fmt(ri.divertedBytes)} bytes); full serves >=10 KiB: ${fmt(ri.fullServesOver10k)} (${fmt(ri.fullServeBytesOver10k)} bytes)`);
+  lines.push(`Full-serve split (same transcript file; a session's lanes are separate files, so repeats UNDER-count): first read ${fmt(ri.fullServesFirstRead)}, repeat ${fmt(ri.fullServesRepeat)} (${fmt(ri.repeatBytes)} bytes), path unknown ${fmt(ri.fullServesPathUnknown)}`);
+  lines.push(`Repeats: with offset/limit ${fmt(ri.repeatWithRange)} (deliberate paging), whole-file ${fmt(ri.repeatFullNoRange)} (divert-miss candidates), in sessions with a token-goat hook fire ${fmt(ri.repeatInHookedSessions)} (whole-file among them: ${fmt(ri.repeatFullNoRangeInHookedSessions)}, of which post-compaction and so correct by design: ${fmt(ri.repeatFullNoRangeHookedAfterCompaction)})`);
+  lines.push("");
+  lines.push("## Bash filter fire-rate (token-goat in-band markers inside Bash tool results)");
+  const bi = s.bashInterception;
+  lines.push(`Bash results: ${fmt(bi.bashResults)}; marked by a filter: ${fmt(bi.markedByFilter)} (${fmt(bi.markedBytes)} bytes); small unmarked <${fmt(BASH_SMALL_RESULT_MAX_BYTES)} B: ${fmt(bi.smallUntouched)} (${fmt(bi.smallUntouchedBytes)} bytes)`);
+  lines.push(`Untouched >=${fmt(BASH_SMALL_RESULT_MAX_BYTES)} B: ${fmt(bi.untouched)} (${fmt(bi.untouchedBytes)} bytes, est-tokens ${fmt(bi.untouchedEstTokens)}, billed-equiv ${fmt(bi.untouchedBilledEquivTokens)})`);
+  lines.push("A filter that matched but fell under the 100-byte net-savings floor leaves no transcript trace and counts as untouched here.");
+  for (const h of bi.untouchedHeads.slice(0, 15)) {
+    lines.push(`  ${h.head.padEnd(28)} results ${fmt(h.results).padStart(9)}  bytes ${fmt(h.bytes).padStart(15)}`);
+  }
+  if (bi.untouchedHeads.length > 15) lines.push(`  (${bi.untouchedHeads.length - 15} smaller command heads omitted from this table; --json has all)`);
+  lines.push("");
+  lines.push("## Mid-trim omission markers inside tool results");
+  lines.push(`fires: ${fmt(s.omissionMarkers.fires)}, lines discarded: ${fmt(s.omissionMarkers.linesOmitted)}`);
+  return lines.join("\n");
+}
+
+// src/cli_mcp_audit.ts
+import * as fs27 from "node:fs";
+import * as os13 from "node:os";
+import * as path27 from "node:path";
+function readMcpJsonFile(configPath2) {
+  try {
+    if (!fs27.existsSync(configPath2)) return null;
+    const content = fs27.readFileSync(configPath2, "utf-8");
     const parsed = JSON.parse(content);
-    return parsed.mcpServers || parsed;
+    const servers = parsed && typeof parsed === "object" ? parsed.mcpServers ?? parsed : null;
+    return servers && typeof servers === "object" ? servers : null;
+  } catch {
+    return null;
+  }
+}
+function driveLetterCaseVariants(p) {
+  const m = /^([a-zA-Z]:)(.*)$/s.exec(p);
+  if (m === null) return [p];
+  const [, drive, rest] = m;
+  return [`${drive.toLowerCase()}${rest}`, `${drive.toUpperCase()}${rest}`];
+}
+function readClaudeJsonConfig(claudeJsonPath, projectRoot) {
+  try {
+    if (!fs27.existsSync(claudeJsonPath)) return null;
+    const parsed = JSON.parse(fs27.readFileSync(claudeJsonPath, "utf-8"));
+    const projects = parsed && typeof parsed === "object" ? parsed.projects : null;
+    if (!projects || typeof projects !== "object") return null;
+    const slashForms = [projectRoot, projectRoot.replace(/\\/g, "/"), projectRoot.replace(/\//g, "\\")];
+    const candidates = [...new Set(slashForms.flatMap(driveLetterCaseVariants))];
+    for (const key of candidates) {
+      const entry = projects[key];
+      if (entry && typeof entry === "object") {
+        const servers = entry["mcpServers"];
+        if (servers && typeof servers === "object") return servers;
+      }
+    }
+    return null;
   } catch {
     return null;
   }
 }
+function discoverMcpConfig(projectRoot, home) {
+  const mcpJsonPath = path27.join(projectRoot, ".mcp.json");
+  const claudeJsonPath = path27.join(home, ".claude.json");
+  const sourcesChecked = [mcpJsonPath, claudeJsonPath];
+  const fromMcpJson = readMcpJsonFile(mcpJsonPath);
+  if (fromMcpJson !== null) return { servers: fromMcpJson, sourcePath: mcpJsonPath, sourcesChecked };
+  const fromClaudeJson = readClaudeJsonConfig(claudeJsonPath, projectRoot);
+  if (fromClaudeJson !== null) return { servers: fromClaudeJson, sourcePath: claudeJsonPath, sourcesChecked };
+  return { servers: null, sourcePath: null, sourcesChecked };
+}
 function analyzeMcpCache() {
   const serverMetrics = /* @__PURE__ */ new Map();
   const blobs = listBlobs(BASH_OUTPUT_SUBDIR).filter((b) => b.id.startsWith("mcp_"));
@@ -13539,8 +14297,9 @@ function analyzeMcpCache() {
   }
   return serverMetrics;
 }
-function buildMcpAuditReport(projectRoot) {
-  const config = readMcpConfig(projectRoot);
+function buildMcpAuditReport(projectRoot, home = os13.homedir()) {
+  const discovery = discoverMcpConfig(projectRoot, home);
+  const config = discovery.servers;
   const cacheMetrics = analyzeMcpCache();
   const servers = [];
   let totalCost = 0;
@@ -13574,7 +14333,10 @@ function buildMcpAuditReport(projectRoot) {
   servers.sort((a, b) => b.totalTokens - a.totalTokens);
   return {
     projectRoot,
-    configFound: config !== null,
+    configFound: discovery.sourcePath !== null,
+    configSourcePath: discovery.sourcePath,
+    configSourcesChecked: discovery.sourcesChecked,
+    costKnown: discovery.sourcePath !== null || cacheMetrics.size > 0,
     servers,
     totalCost
   };
@@ -13586,11 +14348,12 @@ function printReport3(report) {
   w("\n# token-goat mcp-audit\n");
   w(`Project: ${report.projectRoot}
 `);
-  w(`Config found: ${report.configFound ? "yes" : "no"}
+  w(report.configSourcePath !== null ? `Config found: yes (${report.configSourcePath})
+` : `Config found: no (checked: ${report.configSourcesChecked.join(", ")})
 `);
   w("\n## MCP servers\n");
   if (report.servers.length === 0) {
-    w("  none\n");
+    w(report.costKnown ? "  none\n" : "  none discovered from a readable config source\n");
   } else {
     w("| Server | Per-Call (tok) | Calls | Total (tok) |\n");
     w("|--------|---|---|---|\n");
@@ -13599,9 +14362,10 @@ function printReport3(report) {
 `);
     }
   }
-  w(`
+  w(report.costKnown ? `
 Total cost: ${report.totalCost} tok
-`);
+` : "\nTotal cost: unknown -- no readable MCP config was found and no MCP calls have been recorded in this session's cache yet\n");
+  w("\nNote: plugin-provided MCP servers have no on-disk config token-goat can read, so a live session may have MCP servers this audit cannot see or price.\n");
 }
 async function runMcpAuditCommand(opts = {}) {
   const projectRoot = resolveProjectRoot(opts.project !== void 0 ? { project: opts.project } : {});
@@ -13620,6 +14384,20 @@ var RECALL_COMMAND = {
   web: "web-output",
   mcp: "mcp-output"
 };
+function fenceTagForCacheType(cacheType) {
+  return cacheType === "web" ? UNTRUSTED_WEB_TAG : UNTRUSTED_TOOL_TAG;
+}
+function fenceSnippetIfMatched(hit) {
+  let matches2 = [];
+  try {
+    if (loadConfig().injection.enabled) matches2 = scanForInjectionPatterns(hit.snippet);
+  } catch {
+    matches2 = [];
+  }
+  if (matches2.length === 0) return hit.snippet;
+  recordStat("injection_detected", 0, 0, void 0, matches2.join(","));
+  return fenceUntrustedContent(hit.snippet, matches2, fenceTagForCacheType(hit.cacheType));
+}
 function printHits(query, hits) {
   const w = (text) => {
     process.stdout.write(text);
@@ -13635,7 +14413,7 @@ function printHits(query, hits) {
 `);
     w(`  ${label}
 `);
-    w(`  ${hit.snippet}
+    w(`  ${fenceSnippetIfMatched(hit)}
 
 `);
   }
@@ -13648,7 +14426,8 @@ function runRecallCommand(query, opts = {}) {
   };
   const hits = browse ? listRecentRecall(scope) : searchRecall(query, scope);
   if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify(hits)}
+    const fenced = hits.map((hit) => ({ ...hit, snippet: fenceSnippetIfMatched(hit) }));
+    process.stdout.write(`${JSON.stringify(fenced)}
 `);
     return;
   }
@@ -13671,19 +14450,20 @@ 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 pct = row.efficacyPct === null ? "n/a" : `${row.efficacyPct}%`;
+    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(pct, 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(pct2, 10) + pad(suppressedCell(row), 17) + pad(String(row.manualEffective), 9) + pad(String(row.manualIneffective), 9) + formatSpentCell(row) + "\n"
     );
   }
 }
 function printTotals(totals) {
   const spent = totals.spentBytes === null ? "n/a" : String(totals.spentBytes);
-  const net = totals.netBytes === null ? "n/a" : String(totals.netBytes);
   const legacyNote = totals.legacyEmissions > 0 ? ` (excludes ${totals.legacyEmissions} legacy emission(s) recorded before spend tracking)` : "";
-  process.stdout.write(`
-TOTAL   saved=${totals.savedBytes}   spent=${spent}   net=${net}${legacyNote}
-`);
+  process.stdout.write(
+    `
+TOTAL   saved=${totals.savedBytes} (all-time, every hint kind)   spent=${spent} (hint_emissions ledger only)${legacyNote}
+`
+  );
 }
 function runHintStatsCommand(opts = {}) {
   if (opts.reset === true) {
@@ -13817,10 +14597,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 (fs27.statSync(file).size > CONTENT_MAX_INPUT_CHARS) {
+    if (fs28.statSync(file).size > CONTENT_MAX_INPUT_CHARS) {
       throw new CliError(`file exceeds the ${CONTENT_MAX_INPUT_CHARS}-byte safety limit`);
     }
-    value = fs27.readFileSync(file, "utf8");
+    value = fs28.readFileSync(file, "utf8");
   } else {
     if (text === void 0) throw new CliError("provide text or --file");
     value = text;
@@ -13957,10 +14737,10 @@ async function cmdIndex(pathArg, opts = {}) {
       continue;
     }
     const sha = fingerprintFile(key);
-    if (sha === null && !fs27.existsSync(key)) continue;
+    if (sha === null && !fs28.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;
+    const parseUnchanged = !force && !spellingStale && sha !== null && entry?.sha === sha && entry.parserSha === PARSER_FINGERPRINT;
     const embeddingsEnabled = loadConfig().indexing?.embeddings_enabled ?? true;
     const depsAvailable = embeddingsEnabled && embeddingsDepsAvailable(getDb(dbPath));
     const embedUnchanged = !force && parseUnchanged && sha !== null && isEmbedFresh(entry?.embedSha, sha, embeddingsEnabled, depsAvailable);
@@ -13983,7 +14763,7 @@ async function cmdIndex(pathArg, opts = {}) {
         }
         continue;
       }
-      if (!fs27.existsSync(key)) continue;
+      if (!fs28.existsSync(key)) continue;
     }
     if (!embedUnchanged) {
       paintProgress("embedding");
@@ -14016,7 +14796,7 @@ function cmdMap(opts) {
     out(text);
   }
   const bytesSaved = mapLookupBytesSaved(map, text);
-  recordStat("map_lookup", bytesSaved, Math.round(bytesSaved / 4));
+  recordStat("map_lookup", bytesSaved, savedTokensFromBytes(bytesSaved));
 }
 function cmdBridgesStatus(opts) {
   if (opts.json === true) {
@@ -14043,7 +14823,7 @@ async function cmdMcpServe() {
   let StdioServerTransport;
   try {
     ;
-    ({ createMcpServer } = await import("./token-goat-chunk-AL644JUV.mjs"));
+    ({ createMcpServer } = await import("./token-goat-chunk-LZOAPGWR.mjs"));
     ({ StdioServerTransport } = await import("./token-goat-chunk-324QOJYZ.mjs"));
   } catch (err2) {
     process.stderr.write(
@@ -14056,8 +14836,8 @@ async function cmdMcpServe() {
   const server = await createMcpServer();
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  await new Promise((resolve12) => {
-    server.onclose = resolve12;
+  await new Promise((resolve13) => {
+    server.onclose = resolve13;
   });
 }
 function printBridgeVerificationNotice(harness) {
@@ -14068,7 +14848,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-JU7QESB3.mjs");
+  const { relay } = await import("./token-goat-chunk-L6YP6FKQ.mjs");
   await relay(event);
 }
 async function cmdInstall(opts) {
@@ -14181,16 +14961,16 @@ async function cmdInstall(opts) {
     );
   }
   try {
-    const skillDir = path27.join(homedir11(), ".claude", "skills");
-    if (fs27.existsSync(skillDir)) {
-      const entries = fs27.readdirSync(skillDir, { withFileTypes: true });
+    const skillDir = path28.join(homedir13(), ".claude", "skills");
+    if (fs28.existsSync(skillDir)) {
+      const entries = fs28.readdirSync(skillDir, { withFileTypes: true });
       const skillNames = [];
       const sessionId = getSessionId();
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const skillFile = path27.join(skillDir, entry.name, "SKILL.md");
-        if (fs27.existsSync(skillFile)) {
-          const body = fs27.readFileSync(skillFile, "utf-8");
+        const skillFile = path28.join(skillDir, entry.name, "SKILL.md");
+        if (fs28.existsSync(skillFile)) {
+          const body = fs28.readFileSync(skillFile, "utf-8");
           const compact = extractCompactFromMarker(body);
           if (compact === null) continue;
           const sourceSha = contentHash(body);
@@ -14200,10 +14980,10 @@ async function cmdInstall(opts) {
       }
       if (skillNames.length > 0) {
         const dir = skillOutputsDir();
-        await fs27.promises.mkdir(dir, { recursive: true });
-        const pregenPath = path27.join(dir, "pregen.json");
+        await fs28.promises.mkdir(dir, { recursive: true });
+        const pregenPath = path28.join(dir, "pregen.json");
         const pregenData = { ts: Date.now(), names: skillNames };
-        await fs27.promises.writeFile(pregenPath, JSON.stringify(pregenData, null, 2));
+        await fs28.promises.writeFile(pregenPath, JSON.stringify(pregenData, null, 2));
         out(`Pre-generated ${skillNames.length} skill compacts.`);
       }
     }
@@ -14381,6 +15161,15 @@ function cmdWaste(opts = {}) {
     ...opts.copilot === true ? { copilot: true } : {}
   });
 }
+async function cmdSessionAudit(opts = {}) {
+  let summary;
+  try {
+    summary = await auditSessionCorpus({ ...opts.dir !== void 0 ? { dir: opts.dir } : {} });
+  } catch (err2) {
+    throw new CliError(err2 instanceof Error ? err2.message : String(err2));
+  }
+  out(opts.json === true ? JSON.stringify(summary) : formatSessionAudit(summary));
+}
 async function cmdSessionOutline(sessionIdOrPath, opts = {}) {
   const transcriptPath = resolveSessionTranscript(sessionIdOrPath, opts.project !== void 0 ? { project: opts.project } : {});
   if (transcriptPath === null) {
@@ -14394,11 +15183,11 @@ ${formatSessionOutline(turns)}`;
   out(text);
   const fullSourceBytes = sessionTranscriptSize(transcriptPath);
   const bytesSaved = Math.max(1, fullSourceBytes - Buffer.byteLength(text, "utf8"));
-  recordStat("session_outline", bytesSaved, Math.round(bytesSaved / 4));
+  recordStat("session_outline", bytesSaved, savedTokensFromBytes(bytesSaved));
 }
 function sessionTranscriptSize(transcriptPath) {
   try {
-    return fs27.statSync(transcriptPath).size;
+    return fs28.statSync(transcriptPath).size;
   } catch {
     return 0;
   }
@@ -14416,7 +15205,7 @@ async function cmdSessionSlice(sessionIdOrPath, opts) {
   out(text);
   const fullSourceBytes = sessionTranscriptSize(transcriptPath);
   const bytesSaved = Math.max(1, fullSourceBytes - Buffer.byteLength(text, "utf8"));
-  recordStat("session_slice", bytesSaved, Math.round(bytesSaved / 4));
+  recordStat("session_slice", bytesSaved, savedTokensFromBytes(bytesSaved));
 }
 function cmdMcpAudit(opts = {}) {
   return runMcpAuditCommand({
@@ -14522,9 +15311,20 @@ function _applyFiltersAndPrint(content, opts, fenceUntrusted = false, fenceTag =
   }
   return emit2(result.join("\n"));
 }
+function fenceFileTextIfMatched(text) {
+  let matches2 = [];
+  try {
+    if (loadConfig().injection.enabled) matches2 = scanForInjectionPatterns(text);
+  } catch {
+    matches2 = [];
+  }
+  if (matches2.length === 0) return text;
+  recordStat("injection_detected", 0, 0, void 0, matches2.join(","));
+  return fenceUntrustedContent(text, matches2, UNTRUSTED_FILE_TAG);
+}
 function fileSizeOrZero(filePath) {
   try {
-    return fs27.statSync(filePath).size;
+    return fs28.statSync(filePath).size;
   } catch {
     return 0;
   }
@@ -14539,11 +15339,11 @@ function cmdBashOutput(id, opts) {
     }
     let content;
     try {
-      const st = fs27.statSync(opts.file);
+      const st = fs28.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(fs27.readFileSync(opts.file)));
+      content = redactIfDotenv(opts.file, decodeSource(fs28.readFileSync(opts.file)));
     } catch (e) {
       if (e instanceof CliError) throw e;
       throw new CliError(`cannot read file: ${opts.file}`);
@@ -14585,10 +15385,10 @@ function cmdMcpOutput(id, opts) {
 }
 async function cmdPdfExtract(file, opts) {
   const text = await runPdfExtractText(file, opts.pages, opts.layout === true);
-  const printed = _applyFiltersAndPrint(text, opts);
+  const printed = _applyFiltersAndPrint(text, opts, true, UNTRUSTED_FILE_TAG);
   const fullSourceBytes = fileSizeOrZero(file);
   const bytesSaved = Math.max(1, fullSourceBytes - Buffer.byteLength(printed, "utf8"));
-  recordStat("pdf_extract", bytesSaved, Math.round(bytesSaved / 4));
+  recordStat("pdf_extract", bytesSaved, savedTokensFromBytes(bytesSaved));
 }
 async function cmdPdfLocate(file, pattern, opts) {
   const locateOpts = {
@@ -14598,24 +15398,25 @@ async function cmdPdfLocate(file, pattern, opts) {
   if (opts.context !== void 0) locateOpts.context = requirePositiveInt("--context", opts.context);
   if (opts.pages !== void 0) locateOpts.pages = opts.pages;
   const matches2 = await runPdfLocate(file, pattern, locateOpts);
-  const pages = matches2.map((m) => m.page);
+  const fencedMatches = matches2.map((m) => ({ ...m, snippet: fenceFileTextIfMatched(m.snippet) }));
+  const pages = fencedMatches.map((m) => m.page);
   let printed;
   if (opts.json === true) {
-    printed = JSON.stringify({ file, pattern, matchCount: matches2.length, pages, matches: matches2 }, null, 2);
+    printed = JSON.stringify({ file, pattern, matchCount: fencedMatches.length, pages, matches: fencedMatches }, null, 2);
     out(printed);
-  } else if (matches2.length === 0) {
+  } else if (fencedMatches.length === 0) {
     printed = "(no matches)";
     out(printed);
   } else {
-    const lines = matches2.map((m) => `p${m.page}: ${m.snippet}`);
+    const lines = fencedMatches.map((m) => `p${m.page}: ${m.snippet}`);
     printed = `${lines.join("\n")}
 
-${countNoun(matches2.length, "match", "matches")} across ${countNoun(pages.length, "page")}`;
+${countNoun(fencedMatches.length, "match", "matches")} across ${countNoun(pages.length, "page")}`;
     out(printed);
   }
   const fullSourceBytes = fileSizeOrZero(file);
   const bytesSaved = Math.max(1, fullSourceBytes - Buffer.byteLength(printed, "utf8"));
-  recordStat("pdf_locate", bytesSaved, Math.round(bytesSaved / 4));
+  recordStat("pdf_locate", bytesSaved, savedTokensFromBytes(bytesSaved));
 }
 async function cmdPdfOutline(file, opts) {
   const entries = await runPdfOutline(file);
@@ -14627,11 +15428,12 @@ async function cmdPdfOutline(file, opts) {
     }
     return;
   }
-  const text = opts.json === true ? JSON.stringify(entries, null, 2) : entries.map((e) => `${"  ".repeat(e.level)}${e.title}${e.page !== null ? `  (p.${e.page})` : ""}`).join("\n");
+  const fencedEntries = entries.map((e) => ({ ...e, title: fenceFileTextIfMatched(e.title) }));
+  const text = opts.json === true ? JSON.stringify(fencedEntries, null, 2) : fencedEntries.map((e) => `${"  ".repeat(e.level)}${e.title}${e.page !== null ? `  (p.${e.page})` : ""}`).join("\n");
   out(text);
   const fullSourceBytes = fileSizeOrZero(file);
   const bytesSaved = Math.max(1, fullSourceBytes - Buffer.byteLength(text, "utf8"));
-  recordStat("pdf_outline", bytesSaved, Math.round(bytesSaved / 4));
+  recordStat("pdf_outline", bytesSaved, savedTokensFromBytes(bytesSaved));
 }
 async function cmdPdfMeta(file, opts = {}) {
   const meta = await runPdfMeta(file);
@@ -14645,7 +15447,7 @@ async function cmdPdfMeta(file, opts = {}) {
   out(text);
   const fullSourceBytes = fileSizeOrZero(file);
   const bytesSaved = Math.max(1, fullSourceBytes - Buffer.byteLength(text, "utf8"));
-  recordStat("pdf_meta", bytesSaved, Math.round(bytesSaved / 4));
+  recordStat("pdf_meta", bytesSaved, savedTokensFromBytes(bytesSaved));
 }
 async function cmdImageMeta(file, opts = {}) {
   const meta = await runImageMeta(file);
@@ -14667,7 +15469,17 @@ ${msg}`;
   out(text);
   const fullSourceBytes = fileSizeOrZero(file);
   const bytesSaved = Math.max(1, fullSourceBytes - Buffer.byteLength(text, "utf8"));
-  recordStat("image_meta", bytesSaved, Math.round(bytesSaved / 4));
+  recordStat("image_meta", bytesSaved, savedTokensFromBytes(bytesSaved));
+}
+function fenceOcrText(text) {
+  try {
+    if (loadConfig().injection.enabled) {
+      const matches2 = scanForInjectionPatterns(text);
+      if (matches2.length > 0) recordStat("injection_detected", 0, 0, void 0, matches2.join(","));
+    }
+  } catch {
+  }
+  return fenceUntrustedOcrText(text);
 }
 async function cmdImageText(file, opts = {}) {
   const result = await runImageText(file);
@@ -14679,18 +15491,22 @@ async function cmdImageText(file, opts = {}) {
   }
   let text;
   if (opts.json === true) {
-    text = JSON.stringify(result, null, 2);
+    text = JSON.stringify(
+      result.text === null ? result : { ...result, text: fenceOcrText(result.text) },
+      null,
+      2
+    );
   } else {
     const lines = [`Confidence: ${Math.round(result.confidence)}%`, `Characters: ${result.chars}`];
     text = result.textHeavy && result.text !== null ? `${lines.join("\n")}
 
-${result.text}` : `${lines.join("\n")}
+${fenceOcrText(result.text)}` : `${lines.join("\n")}
 (below usefulness threshold; text likely noise, not shown)`;
   }
   out(text);
   const fullSourceBytes = fileSizeOrZero(file);
   const bytesSaved = Math.max(1, fullSourceBytes - Buffer.byteLength(text, "utf8"));
-  recordStat("image_text", bytesSaved, Math.round(bytesSaved / 4));
+  recordStat("image_text", bytesSaved, savedTokensFromBytes(bytesSaved));
 }
 function cmdVideoChapters(file) {
   const { chapters, subtitleStreams } = extractVideoChapters(file);
@@ -14716,7 +15532,7 @@ function cmdVideoChapters(file) {
   out(text);
   const fullSourceBytes = fileSizeOrZero(file);
   const bytesSaved = Math.max(1, fullSourceBytes - Buffer.byteLength(text, "utf8"));
-  recordStat("video_chapters", bytesSaved, Math.round(bytesSaved / 4));
+  recordStat("video_chapters", bytesSaved, savedTokensFromBytes(bytesSaved));
 }
 function formatVideoTimestamp(totalSeconds) {
   const hours = Math.floor(totalSeconds / 3600);
@@ -14743,23 +15559,24 @@ function cmdSharepointResolve(url) {
 function recordXlsxStat(kind, file, emitted) {
   const fullSourceBytes = fileSizeOrZero(file);
   const bytesSaved = Math.max(1, fullSourceBytes - Buffer.byteLength(emitted, "utf8"));
-  recordStat(kind, bytesSaved, Math.round(bytesSaved / 4));
+  recordStat(kind, bytesSaved, savedTokensFromBytes(bytesSaved));
 }
 async function cmdXlsxSheets(file, opts = {}) {
   const sheets = await listSheets(file);
-  const text = opts.json === true ? JSON.stringify(sheets.map((s) => ({ name: s.name, ref: s.ref, rows: s.rows, cols: s.cols })), null, 2) : sheets.map((s) => `${s.name}  ${s.ref}  (${s.rows} rows x ${s.cols} cols)`).join("\n");
+  const fencedSheets = sheets.map((s) => ({ ...s, name: fenceFileTextIfMatched(s.name) }));
+  const text = opts.json === true ? JSON.stringify(fencedSheets.map((s) => ({ name: s.name, ref: s.ref, rows: s.rows, cols: s.cols })), null, 2) : fencedSheets.map((s) => `${s.name}  ${s.ref}  (${s.rows} rows x ${s.cols} cols)`).join("\n");
   out(text);
   recordXlsxStat("xlsx_sheets", file, text);
 }
 async function cmdXlsxHead(file, opts) {
   const rows = opts.rows !== void 0 ? requireNonNegativeInt("--rows", opts.rows) : 20;
-  const text = await headSheet(file, opts.sheet, rows);
+  const text = fenceFileTextIfMatched(await headSheet(file, opts.sheet, rows));
   out(text);
   recordXlsxStat("xlsx_head", file, text);
 }
 async function cmdXlsxRange(file, opts) {
   const result = await rangeSheet(file, opts.sheet, opts.range, opts.formulas === true);
-  const text = formatXlsxRange(result);
+  const text = fenceFileTextIfMatched(formatXlsxRange(result));
   out(text);
   recordXlsxStat("xlsx_range", file, text);
 }
@@ -14771,31 +15588,32 @@ async function cmdXlsxQuery(file, opts) {
     ...wheres !== void 0 ? { wheres } : {},
     ...opts.head !== void 0 ? { head: requireNonNegativeInt("--head", opts.head) } : {}
   });
-  const text = formatCsvTable(result);
+  const text = fenceFileTextIfMatched(formatCsvTable(result, (opts.where ?? []).map((w) => `--where ${w}`)));
   out(text);
   recordXlsxStat("xlsx_query", file, text);
 }
 function recordDocStat(kind, file, emitted) {
   const fullSourceBytes = fileSizeOrZero(file);
   const bytesSaved = Math.max(1, fullSourceBytes - Buffer.byteLength(emitted, "utf8"));
-  recordStat(kind, bytesSaved, Math.round(bytesSaved / 4));
+  recordStat(kind, bytesSaved, savedTokensFromBytes(bytesSaved));
 }
 async function cmdPptxOutline(file, opts) {
   const slides = await pptxOutline(file);
-  const text = opts.json === true ? JSON.stringify(slides, null, 2) : slides.map((s) => `${s.slide}. ${s.title || "(untitled)"}  [${s.bodyChars} body chars${s.hasNotes ? ", has notes" : ""}]`).join("\n");
+  const fencedSlides = slides.map((s) => ({ ...s, title: fenceFileTextIfMatched(s.title) }));
+  const text = opts.json === true ? JSON.stringify(fencedSlides, null, 2) : fencedSlides.map((s) => `${s.slide}. ${s.title || "(untitled)"}  [${s.bodyChars} body chars${s.hasNotes ? ", has notes" : ""}]`).join("\n");
   out(text);
   recordDocStat("pptx_outline", file, text);
 }
 async function cmdPptxSlide(file, opts) {
   const n = requireNonNegativeInt("--slide", opts.slide);
-  const text = await pptxSlideText(file, n, opts.notes === true);
+  const text = fenceFileTextIfMatched(await pptxSlideText(file, n, opts.notes === true));
   out(text);
   recordDocStat("pptx_slide", file, text);
 }
 async function cmdPptxNotes(file, opts) {
   const n = opts.slide !== void 0 ? requireNonNegativeInt("--slide", opts.slide) : void 0;
   const text = await pptxNotesText(file, n);
-  const printed = text.length > 0 ? text : "no speaker notes found";
+  const printed = text.length > 0 ? fenceFileTextIfMatched(text) : "no speaker notes found";
   out(printed);
   recordDocStat("pptx_notes", file, printed);
 }
@@ -14805,7 +15623,7 @@ async function cmdPptxText(file, opts) {
     out("no matches");
     return;
   }
-  const text = matches2.map((m) => `Slide ${m.slide}: ...${m.snippet}...`).join("\n");
+  const text = fenceFileTextIfMatched(matches2.map((m) => `Slide ${m.slide}: ...${m.snippet}...`).join("\n"));
   out(text);
   recordDocStat("pptx_text", file, text);
 }
@@ -14819,13 +15637,14 @@ async function cmdDocxOutline(file, opts) {
     }
     return;
   }
-  const text = opts.json === true ? JSON.stringify(headings, null, 2) : headings.map((h) => `${"  ".repeat(h.level - 1)}${h.text}`).join("\n");
+  const fencedHeadings = headings.map((h) => ({ ...h, text: fenceFileTextIfMatched(h.text) }));
+  const text = opts.json === true ? JSON.stringify(fencedHeadings, null, 2) : fencedHeadings.map((h) => `${"  ".repeat(h.level - 1)}${h.text}`).join("\n");
   out(text);
   recordDocStat("docx_outline", file, text);
 }
 async function cmdDocxText(file, opts) {
   const text = await docxText(file);
-  const printed = _applyFiltersAndPrint(text, opts);
+  const printed = _applyFiltersAndPrint(text, opts, true, UNTRUSTED_FILE_TAG);
   recordDocStat("docx_text", file, printed);
 }
 function cmdTranscriptOutline(file, opts) {
@@ -14963,7 +15782,7 @@ function emitExtraFileArgsNote(command, first, extras, opts = {}) {
 }
 async function cmdCompress(opts) {
   try {
-    const bashRunner = await import("./token-goat-chunk-BTZSUIYA.mjs");
+    const bashRunner = await import("./token-goat-chunk-NZFTWBGV.mjs");
     if (opts.compress === false) {
       process.exitCode = bashRunner.runRaw(opts.cmd, parseTimeout(opts.timeout, bashRunner.DEFAULT_TIMEOUT_SECONDS));
       return;
@@ -14989,9 +15808,12 @@ async function cmdSkillBody(name, opts) {
   if (filePath === null) {
     throw new CliError(`skill '${name}' not found`);
   }
-  const body = decodeSource(fs27.readFileSync(filePath));
+  const body = decodeSource(fs28.readFileSync(filePath));
   if (opts.compact === true) {
-    out(extractCompactFromMarker(body) ?? body);
+    const emitted = extractCompactFromMarker(body) ?? body;
+    out(emitted);
+    const bytesSaved = Buffer.byteLength(body, "utf8") - Buffer.byteLength(emitted, "utf8");
+    if (bytesSaved > 0) recordStat("skill_body:compact", bytesSaved, savedTokensFromBytes(bytesSaved), void 0, name);
   } else {
     out(body);
   }
@@ -15003,12 +15825,26 @@ async function cmdSkillCompact(name, opts) {
     const skills = await listSkills(sessionId);
     let regenerated = 0;
     let skipped = 0;
+    let noMarker = 0;
+    let unresolvable = 0;
     for (const skill of skills) {
       const filePath = await getSkillFilePath(skill.name);
-      if (!filePath) continue;
-      const body2 = decodeSource(fs27.readFileSync(filePath));
+      if (!filePath) {
+        unresolvable++;
+        continue;
+      }
+      let body2;
+      try {
+        body2 = decodeSource(fs28.readFileSync(filePath));
+      } catch {
+        unresolvable++;
+        continue;
+      }
       const compact2 = extractCompactFromMarker(body2);
-      if (compact2 === null) continue;
+      if (compact2 === null) {
+        noMarker++;
+        continue;
+      }
       const sourceSha2 = contentHash(body2);
       if (skill.compactStale === false) {
         skipped++;
@@ -15017,7 +15853,13 @@ async function cmdSkillCompact(name, opts) {
         regenerated++;
       }
     }
-    out(`Regenerated ${regenerated}, skipped ${skipped} (fresh), total ${skills.length}.`);
+    const parts = [`Regenerated ${regenerated}, skipped ${skipped} (fresh)`];
+    if (noMarker > 0) parts.push(`no marker ${noMarker}`);
+    if (unresolvable > 0) parts.push(`unresolvable ${unresolvable}`);
+    out(`${parts.join(", ")}, total ${skills.length}.`);
+    if (noMarker > 0) {
+      out(`${noMarker} cached skill${noMarker === 1 ? " has" : "s have"} no COMPACT_END marker and cannot be compacted; run \`token-goat skill-size\` for per-skill marker recommendations.`);
+    }
     return;
   }
   let body;
@@ -15027,19 +15869,19 @@ async function cmdSkillCompact(name, opts) {
     if (!opts.path.trim()) {
       throw new CliError("--path cannot be empty");
     }
-    if (!fs27.existsSync(opts.path)) {
+    if (!fs28.existsSync(opts.path)) {
       throw new CliError(`skill file not found: ${opts.path}`);
     }
     try {
-      body = fs27.readFileSync(opts.path, "utf-8");
+      body = fs28.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 ?? path27.basename(path27.dirname(path27.resolve(opts.path)));
-    sourcePath = path27.resolve(opts.path);
+    cacheName = name ?? path28.basename(path28.dirname(path28.resolve(opts.path)));
+    sourcePath = path28.resolve(opts.path);
   } else {
     if (name === void 0 || !name.trim()) {
       throw new CliError("skill-compact requires a <name> or --path <file>");
@@ -15048,7 +15890,7 @@ async function cmdSkillCompact(name, opts) {
     if (filePath === null) {
       throw new CliError(`skill '${name}' not found`);
     }
-    body = fs27.readFileSync(filePath, "utf-8");
+    body = fs28.readFileSync(filePath, "utf-8");
     cacheName = name;
     sourcePath = filePath;
   }
@@ -15180,8 +16022,8 @@ async function cmdSkillDiff(name) {
   }
   const newer = versions[0];
   const older = versions[1];
-  const newerBody = await fs27.promises.readFile(path27.resolve(dir, `${newer.outputId}.txt`), "utf-8").catch(() => null);
-  const olderBody = await fs27.promises.readFile(path27.resolve(dir, `${older.outputId}.txt`), "utf-8").catch(() => null);
+  const newerBody = await fs28.promises.readFile(path28.resolve(dir, `${newer.outputId}.txt`), "utf-8").catch(() => null);
+  const olderBody = await fs28.promises.readFile(path28.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;
@@ -15210,7 +16052,7 @@ async function cmdSkillSection(nameHeading, headingArg) {
   if (!filePath) {
     throw new CliError(`skill '${skillName}' not found`);
   }
-  const body = decodeSource(fs27.readFileSync(filePath));
+  const body = decodeSource(fs28.readFileSync(filePath));
   const extracted = extractNamedSection(body, heading);
   if (!extracted) {
     const messages = [`Section '${heading}' not found in skill '${skillName}'`];
@@ -15225,7 +16067,7 @@ async function cmdSkillSection(nameHeading, headingArg) {
 }
 function atomicWriteBuffer(dest, data) {
   try {
-    if (fs27.statSync(dest).isDirectory()) {
+    if (fs28.statSync(dest).isDirectory()) {
       const e = Object.assign(new Error(`EISDIR: illegal operation on a directory, open '${dest}'`), { code: "EISDIR", path: dest });
       throw e;
     }
@@ -15233,23 +16075,23 @@ function atomicWriteBuffer(dest, data) {
     if (e.code !== "ENOENT") throw e;
   }
   const rnd = randomBytes(4).toString("hex");
-  const tmp = path27.join(path27.dirname(path27.resolve(dest)), `.tmp.${process.pid}.${rnd}`);
+  const tmp = path28.join(path28.dirname(path28.resolve(dest)), `.tmp.${process.pid}.${rnd}`);
   try {
-    fs27.writeFileSync(tmp, data, { mode: 384 });
+    fs28.writeFileSync(tmp, data, { mode: 384 });
     try {
-      const destMode = fs27.statSync(dest).mode;
-      fs27.chmodSync(tmp, destMode);
+      const destMode = fs28.statSync(dest).mode;
+      fs28.chmodSync(tmp, destMode);
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
     }
     withRetryOnLock(() => {
       try {
-        fs27.renameSync(tmp, dest);
+        fs28.renameSync(tmp, dest);
       } catch (e) {
         if (e.code === "EXDEV") {
-          fs27.copyFileSync(tmp, dest);
+          fs28.copyFileSync(tmp, dest);
           try {
-            fs27.unlinkSync(tmp);
+            fs28.unlinkSync(tmp);
           } catch (ue) {
             process.stderr.write(`token-goat write-file: warning: could not remove temp file ${tmp}: ${ue.message}
 `);
@@ -15261,7 +16103,7 @@ function atomicWriteBuffer(dest, data) {
     });
   } catch (e) {
     try {
-      fs27.unlinkSync(tmp);
+      fs28.unlinkSync(tmp);
     } catch {
     }
     throw e;
@@ -15271,9 +16113,9 @@ function mapFsError(e, src, dest, srcLabel = "source") {
   const fe = e;
   if (fe.code === "ENOENT") {
     const errPath = fe.path ?? "";
-    const isSource = src !== void 0 && path27.resolve(errPath) === path27.resolve(src);
+    const isSource = src !== void 0 && path28.resolve(errPath) === path28.resolve(src);
     if (isSource) throw new CliError(`${/\bfile$/i.test(srcLabel) ? srcLabel : `${srcLabel} file`} not found: ${src}`);
-    const destDir = dest ? path27.dirname(path27.resolve(dest)) : path27.dirname(path27.resolve(errPath || "."));
+    const destDir = dest ? path28.dirname(path28.resolve(dest)) : path28.dirname(path28.resolve(errPath || "."));
     throw new CliError(`destination directory does not exist: ${destDir}`);
   }
   if (fe.code === "ENOTDIR") {
@@ -15284,7 +16126,7 @@ function mapFsError(e, src, dest, srcLabel = "source") {
   }
   if (fe.code === "EISDIR") {
     const errPath = fe.path ?? "";
-    const isSource = src !== void 0 && (errPath === "" || path27.resolve(errPath) === path27.resolve(src));
+    const isSource = src !== void 0 && (errPath === "" || path28.resolve(errPath) === path28.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)")}`);
   }
@@ -15353,7 +16195,7 @@ function validateWritablePath(dest, label) {
     throw new CliError(`${label} path contains a null byte`);
   }
   if (isWindows()) {
-    const base = path27.basename(dest);
+    const base = path28.basename(dest);
     const stem = base.replace(/\.[^.]*$/, "").toUpperCase();
     if (WIN_RESERVED.has(stem)) {
       throw new CliError(`${label} '${base}' is a reserved Windows device name`);
@@ -15383,7 +16225,7 @@ function readFileBoundedRaw(filePath, label, allowStdIn = false) {
     throw new CliError(`${label} ${filePath} requires piped input; use ${altLabel} for interactive use`);
   }
   try {
-    const st = fs27.statSync(filePath);
+    const st = fs28.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`);
     }
@@ -15391,7 +16233,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 fs27.readFileSync(filePath);
+    return fs28.readFileSync(filePath);
   } catch (e) {
     if (e instanceof CliError) throw e;
     mapFsError(e, filePath, void 0, label);
@@ -15435,7 +16277,7 @@ function cmdNoteAdd(file, opts) {
     throw new CliError("note content must be valid UTF-8 text");
   }
   const resolvedPath = resolveIndexPath(file);
-  if (!fs27.existsSync(resolvedPath)) {
+  if (!fs28.existsSync(resolvedPath)) {
     throw new CliError(`File not found: '${resolvedPath}'`);
   }
   healStaleIndex(resolvedPath);
@@ -15494,7 +16336,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((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     const chunks = [];
     let totalBytes = 0;
     let settled = false;
@@ -15518,7 +16360,7 @@ function cmdWriteFile(dest, opts) {
       try {
         atomicWriteBuffer(dest, Buffer.concat(chunks));
         enqueueDirtyPathSafe(dest);
-        resolve12();
+        resolve13();
       } catch (e) {
         try {
           mapFsError(e, void 0, dest);
@@ -15649,14 +16491,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 && !fs27.existsSync(until)) sleepSync(5);
+        while (Date.now() < deadline && !fs28.existsSync(until)) sleepSync(5);
       } else {
         sleepSync(testDelayMs);
       }
     }
     let preRenameStat;
     try {
-      preRenameStat = fs27.statSync(file);
+      preRenameStat = fs28.statSync(file);
     } catch {
     }
     if (preRenameStat !== void 0 && (preRenameStat.mtimeMs !== preWriteStat.mtimeMs || preRenameStat.size !== preWriteStat.size)) {
@@ -15697,7 +16539,7 @@ function cmdReplace(file, opts) {
   const targetBuf = readFileBoundedRaw(file, "target file", true);
   let preWriteStat;
   try {
-    preWriteStat = fs27.statSync(file);
+    preWriteStat = fs28.statSync(file);
   } catch {
   }
   const usingFrom = opts.oldFrom !== void 0 || opts.newFrom !== void 0;
@@ -15791,7 +16633,7 @@ function cmdInsertSection(file, opts) {
   }
   let preWriteStat;
   try {
-    preWriteStat = fs27.statSync(file);
+    preWriteStat = fs28.statSync(file);
   } catch {
   }
   const result = readSection(file, opts.after);
@@ -15817,7 +16659,7 @@ function cmdInsertSection(file, opts) {
   }
   let rawBytes;
   try {
-    rawBytes = fs27.readFileSync(file);
+    rawBytes = fs28.readFileSync(file);
   } catch (e) {
     mapFsError(e, void 0, file);
   }
@@ -15833,7 +16675,7 @@ function cmdInsertSection(file, opts) {
   if (preWriteStat !== void 0) {
     let preRenameStat;
     try {
-      preRenameStat = fs27.statSync(file);
+      preRenameStat = fs28.statSync(file);
     } catch {
     }
     if (preRenameStat !== void 0 && (preRenameStat.mtimeMs !== preWriteStat.mtimeMs || preRenameStat.size !== preWriteStat.size)) {
@@ -15868,31 +16710,42 @@ ${content}`;
     const sections = await getDocSections(fileId, { fresh: false });
     emitted = formatSections(sections);
   }
-  out(emitted);
-  const bytesSaved = Math.max(1, fullSourceBytes - Buffer.byteLength(emitted, "utf8"));
-  recordStat("gdrive_sections", bytesSaved, Math.round(bytesSaved / 4));
+  let toEmit = emitted;
+  try {
+    if (loadConfig().injection.enabled) {
+      const matches2 = scanForInjectionPatterns(emitted);
+      if (matches2.length > 0) {
+        recordStat("injection_detected", 0, 0, void 0, matches2.join(","));
+        toEmit = fenceUntrustedContent(emitted, matches2, UNTRUSTED_WEB_TAG);
+      }
+    }
+  } catch {
+  }
+  out(toEmit);
+  const bytesSaved = Math.max(1, fullSourceBytes - Buffer.byteLength(toEmit, "utf8"));
+  recordStat("gdrive_sections", bytesSaved, savedTokensFromBytes(bytesSaved));
 }
 function expandGlobs(root, patterns, globFnOverride) {
   const out2 = [];
-  const globFn = globFnOverride ?? fs27["globSync"];
+  const globFn = globFnOverride ?? fs28["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(path27.isAbsolute(h) ? h : path27.join(root, h));
+        for (const h of hits) out2.push(path28.isAbsolute(h) ? h : path28.join(root, h));
         continue;
       } catch {
       }
     }
-    out2.push(path27.isAbsolute(p) ? p : path27.join(root, p));
+    out2.push(path28.isAbsolute(p) ? p : path28.join(root, p));
   }
   return out2;
 }
 function readIgnoreFile(root) {
-  const ignorePath = path27.join(root, ".tokengoatignore");
+  const ignorePath = path28.join(root, ".tokengoatignore");
   let raw;
   try {
-    raw = fs27.readFileSync(ignorePath, "utf8");
+    raw = fs28.readFileSync(ignorePath, "utf8");
   } catch {
     return void 0;
   }
@@ -15933,14 +16786,14 @@ function cmdPack(patterns, opts) {
   }
   let instruction;
   if (opts.instructionFile !== void 0) {
-    instruction = fs27.readFileSync(opts.instructionFile, "utf8");
+    instruction = fs28.readFileSync(opts.instructionFile, "utf8");
   }
   const formatted = formatPack(result, style, {
     ...opts.lineNumbers === true ? { line_numbers: true } : {},
     ...instruction !== void 0 ? { instruction } : {}
   });
   if (opts.output !== void 0) {
-    fs27.writeFileSync(opts.output, formatted, "utf8");
+    fs28.writeFileSync(opts.output, formatted, "utf8");
   } else {
     out(formatted);
   }
@@ -15958,17 +16811,17 @@ function cmdTokens(patterns, opts) {
   if (opts.tree === true) {
     const dirs = /* @__PURE__ */ new Map();
     for (const e of entries) {
-      const dir = path27.dirname(e.rel_path);
+      const dir = path28.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 pct = result.total_tokens > 0 ? Math.round(dirTokens / result.total_tokens * 100) : 0;
-      lines2.push(`${dir}/ (${dirTokens} tokens, ${pct}%)`);
+      const pct2 = result.total_tokens > 0 ? Math.round(dirTokens / result.total_tokens * 100) : 0;
+      lines2.push(`${dir}/ (${dirTokens} tokens, ${pct2}%)`);
       for (const e of dirEntries) {
-        lines2.push(`  ${path27.basename(e.rel_path).padEnd(30)}  ${String(e.tokens).padStart(8)} tokens`);
+        lines2.push(`  ${path28.basename(e.rel_path).padEnd(30)}  ${String(e.tokens).padStart(8)} tokens`);
       }
     }
     out(lines2.join("\n"));
@@ -15999,7 +16852,7 @@ function cmdBudget(patterns, opts) {
   }
 }
 function cmdFailures(src, opts) {
-  const text = src !== void 0 ? fs27.readFileSync(src, "utf8") : fs27.readFileSync(0, "utf8");
+  const text = src !== void 0 ? fs28.readFileSync(src, "utf8") : fs28.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));
@@ -16201,6 +17054,7 @@ function buildProgram() {
   program2.command("waste").description("session spend-ledger: token cost per tool/file from the current Claude Code session transcript, plus waste signals").option("--project <path>", "project root to analyze").option("--transcript <path>", "explicit transcript JSONL path (default: most-recently-modified transcript for this project)").option("--top <n>", "number of top expensive tool calls to show (default: 10)").option("--copilot", "analyze a Copilot CLI session event log instead, reporting Copilot's own token split").option("--json", "output JSON").action(guard(cmdWaste));
   program2.command("session-outline [session-id-or-path]").description("turn-by-turn structure (role, preview, tool calls, approx size) of a Claude Code session JSONL transcript, instead of a raw Read; defaults to the current project's most recent session").option("--project <path>", "project root to resolve the session transcript against").option("--json", "output JSON").action(guard(cmdSessionOutline));
   program2.command("session-slice [session-id-or-path]").description("full content of one turn range from a Claude Code session JSONL transcript (see session-outline for turn numbers), instead of a raw Read").requiredOption("--range <spec>", "turn range, e.g. 5-9 or 12 (see session-outline for turn numbers)").option("--project <path>", "project root to resolve the session transcript against").option("--json", "output JSON").action(guard(cmdSessionSlice));
+  program2.command("session-audit").description("corpus-wide token attribution across every local Claude Code session transcript: measured billed usage, estimated content size by source and by tool, and billed cost by session position (aggregate counts only, never transcript content)").option("--dir <path>", "transcript corpus root to scan (default: ~/.claude/projects)").option("--json", "output JSON").action(guard(cmdSessionAudit));
   program2.command("mcp-audit").description("MCP server schema cost-vs-usage report: estimate per-server token cost from cached tool calls").option("--project <path>", "project root to analyze").option("--json", "output JSON").action(guard(cmdMcpAudit));
   program2.command("recall [query]").description("search across every cached bash-output, web-output, and mcp-output entry (full-text); with no query, list them newest-first").option("--type <type>", "filter to one cache type: bash, web, or mcp").option("--limit <n>", "max results to return (default: 10)").option("--json", "output JSON").action(guard(cmdRecall));
   program2.command("hint-stats").description("per-category efficacy report for token-goat's discretionary hint hooks (emitted/acted-on/suppression)").option("--json", "output JSON").option("--reset", "clear all tracked emissions and manual marks").option("--mark-effective <category>", 'record a manual "effective" vote for a hint category').option("--mark-ineffective <category>", 'record a manual "ineffective" vote for a hint category').action(guard(cmdHintStats));
@@ -16565,7 +17419,7 @@ function buildProgram() {
     )
   );
   program2.command("gdrive-sections <file-id>").description("fetch and list sections from a public Google Doc").option("--heading <name>", "get content of one named section").option("--fresh", "skip the on-disk cache and force a live fetch").action(guard(cmdGdriveSections));
-  program2.command("compress").alias("bash").alias("run").description("run a shell command and emit a compressed view of its output").requiredOption("-c, --cmd <command>", "the shell command to run, as one string").option("-f, --filter <name>", "filter name (auto-detected from the command when omitted)").option("--timeout <seconds>", "wall-clock timeout in seconds (0 = built-in default)").option("--no-compress", "stream output raw without compression (debug the wrapper)").option("--profile <name>", "compression profile: aggressive | balanced | minimal").option("--max-tokens <n>", "post-compress token cap (0 = no cap)").action(cmdCompress);
+  program2.command("compress").alias("bash").alias("run").description("run a shell command (under a POSIX shell / bash) and emit a compressed view of its output").requiredOption("-c, --cmd <command>", "the shell command to run, as one string (use / for paths across platforms)").option("-f, --filter <name>", "filter name (auto-detected from the command when omitted)").option("--timeout <seconds>", "wall-clock timeout in seconds (0 = built-in default)").option("--no-compress", "stream output raw without compression (debug the wrapper)").option("--profile <name>", "compression profile: aggressive | balanced | minimal").option("--max-tokens <n>", "post-compress token cap (0 = no cap)").action(cmdCompress);
   program2.command("version").description("print the token-goat version").action(
     guard(() => {
       out(VERSION);