token-goat 2.6.36 → 2.8.0

package/dist/{token-goat-chunk-KYFJC37X.mjs → token-goat-chunk-VXSYZGBA.mjs}

@@ -16,7 +16,7 @@ import {
   findSpecSeparator,
   getTrackedFiles,
   healStaleIndex,
-  isAvailable,
+  isAvailable as isAvailable2,
   listSections,
   load,
   loadError,
@@ -84,17 +84,21 @@ import {
   runZipRead,
   symbolNamesInFile,
   upsertNote
-} from "./token-goat-chunk-IYTVE6KN.mjs";
+} from "./token-goat-chunk-SRAR6DOK.mjs";
 import {
   BASH_OUTPUT_SUBDIR,
   GEMINI_TOOL_NAME_MAP,
   HOOK_EVENTS,
   WEB_OUTPUT_SUBDIR,
+  accumulateResidentLine,
   buildCommandManifest,
   checkSymbolBodySize,
   commandHash,
+  createResidentContextStats,
   filterCommandManifest,
+  formatBytes,
   formatCommandManifest,
+  formatTokenEstimate,
   getBashOutput,
   getWebOutput,
   getWebOutputByUrlFromDisk,
@@ -102,10 +106,12 @@ import {
   isRecallCacheType,
   listRecentRecall,
   normalizeCommandForCacheKey,
+  readCopilotMcpTools,
   readStdinJson,
   searchRecall,
-  storeWebOutput
-} from "./token-goat-chunk-VYMGEVZS.mjs";
+  storeWebOutput,
+  summarizeResidentContext
+} from "./token-goat-chunk-AO6MFFTW.mjs";
 import {
   AGENT_SALT_MARKER,
   CONTEXT_AUTOCOMPACT_TOKENS,
@@ -132,16 +138,20 @@ import {
   confirmAndApply,
   contentHash,
   copilotCliConfigPath,
+  copilotCliMcpToolsDir,
   copilotCliScriptPath,
+  copilotCliUserRoot,
   detectWalkMode,
   dirtyQueuePathFor,
   docxOutline,
   docxText,
   drainHeartbeatPathFor,
+  embeddingBackendLoadError,
   embeddingsDepsAvailable,
   emptyIndexMessage,
   enqueueDirtyPathSafe,
   estimateTokens,
+  estimateTokensFromLength,
   extractChecklistSection,
   extractCompactFromMarker,
   extractNamedSection,
@@ -182,6 +192,7 @@ import {
   installKimi,
   installSkill,
   installVscode,
+  isAvailable,
   isCodexInstalled,
   isCompactFresh,
   isCopilotCliInstalled,
@@ -243,7 +254,7 @@ import {
   vscodeDecoderConfigured,
   walkProject,
   writeCompact
-} from "./token-goat-chunk-UFOVM7ZN.mjs";
+} from "./token-goat-chunk-2F6TFBZE.mjs";
 import {
   C,
   CONFIG_KEY_ENV_OVERRIDES,
@@ -324,7 +335,7 @@ import {
   withFileLock,
   withRetryOnLock,
   writeJsonSettings
-} from "./token-goat-chunk-V465YKOR.mjs";
+} from "./token-goat-chunk-44Y77VHR.mjs";
 import {
   __export
 } from "./token-goat-chunk-AEX54RUZ.mjs";
@@ -3440,9 +3451,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [path]
    * @return {(string|null|Command)}
    */
-  executableDir(path27) {
-    if (path27 === void 0) return this._executableDir;
-    this._executableDir = path27;
+  executableDir(path28) {
+    if (path28 === void 0) return this._executableDir;
+    this._executableDir = path28;
     return this;
   }
   /**
@@ -3741,8 +3752,8 @@ function attemptedCommandName(argv) {
 }
 
 // src/cli.ts
-import * as fs26 from "fs";
-import * as path26 from "path";
+import * as fs27 from "fs";
+import * as path27 from "path";
 import { homedir as homedir11 } from "os";
 
 // src/walk_index.ts
@@ -4998,13 +5009,19 @@ function isOpenclawInstalled() {
 
 // src/bridges_status.ts
 var NO_SERVER_HANDLER_REASON = "token-goat has no registered server-side handler for this event (zero registerHook('notification'|'stop', ...) call sites in src/) -- wiring it client-side would currently be a no-op";
+var NO_POST_COMPACT_EVENT_REASON = "post_compact is a Claude Code event (hook_event_name PostCompact, carrying compact_summary); no equivalent has been confirmed for this harness, so it is left unwired rather than guessed at";
+var NO_SEPARATE_FAILURE_EVENT_REASON = "post_tool_use_failure exists because Copilot CLI routes a failed tool result to a separate postToolUseFailure event instead of postToolUse. No separate failure event is wired for this harness, so a failed tool call either arrives on post_tool_use like any other result or is not seen; which of the two has not been checked here";
+var COPILOT_NO_POST_COMPACT_REASON = "Copilot CLI has no post-compaction hook: its HookType enum (schemas/api.schema.json, 1.0.79 and 1.0.80) declares preCompact and no postCompact, and both preCompact call sites in app.js await the hook and never assign its result. Whether the summary is reachable another way is open. app.js does emit session.compaction_complete carrying summaryContent, and the session event writer subscribes to '*' -- but emit() vs emitEphemeral() does NOT gate that writer: dispatchEventHandlers runs outside the ephemeral branch in emitInternal, on('*') early-returns past every filter, and the writer's callback applies no filter of its own before handing the JSON to native recordEventJson. The durable-vs-ephemeral decision is in Rust (api_session_event_writer.rs) and was not readable. Nor is the event uniformly summary-bearing: two of the four emit sites are the branches taken when no summary exists, summaryContent is optional in the schema, and the relay session class emits the same event via emitEphemeral. No compaction has ever been observed on the machines checked, so nothing empirical anchors any of it. Context can be written back on the next turn through userPromptSubmitted additionalContext";
 var BRIDGE_CAPABILITY_MATRIX = [
   {
     harness: "claudecode",
     label: "Claude Code",
     sourceFile: "src/install.ts (HOOK_EVENT_MAP)",
-    implemented: /* @__PURE__ */ new Set(["pre_tool_use", "post_tool_use", "pre_compact", "user_prompt_submit", "subagent_stop", "session_start"]),
-    reasons: [{ events: ["notification", "stop"], reason: NO_SERVER_HANDLER_REASON }]
+    implemented: /* @__PURE__ */ new Set(["pre_tool_use", "post_tool_use", "pre_compact", "post_compact", "user_prompt_submit", "subagent_stop", "session_start"]),
+    reasons: [
+      { events: ["post_tool_use_failure"], reason: NO_SEPARATE_FAILURE_EVENT_REASON },
+      { events: ["notification", "stop"], reason: NO_SERVER_HANDLER_REASON }
+    ]
   },
   {
     harness: "codex",
@@ -5012,6 +5029,8 @@ var BRIDGE_CAPABILITY_MATRIX = [
     sourceFile: "src/bridges/codex_install.ts (CODEX_HOOK_EVENTS, CODEX_GLOBAL_HOOK_EVENTS)",
     implemented: /* @__PURE__ */ new Set(["pre_tool_use", "post_tool_use", "pre_compact", "user_prompt_submit", "subagent_stop"]),
     reasons: [
+      { events: ["post_tool_use_failure"], reason: NO_SEPARATE_FAILURE_EVENT_REASON },
+      { events: ["post_compact"], reason: NO_POST_COMPACT_EVENT_REASON },
       { events: ["notification", "stop"], reason: NO_SERVER_HANDLER_REASON },
       {
         events: ["session_start"],
@@ -5025,6 +5044,8 @@ var BRIDGE_CAPABILITY_MATRIX = [
     sourceFile: "src/bridges/grok_install.ts (GROK_HOOK_EVENTS)",
     implemented: /* @__PURE__ */ new Set(["pre_tool_use", "post_tool_use", "pre_compact", "user_prompt_submit", "subagent_stop"]),
     reasons: [
+      { events: ["post_tool_use_failure"], reason: NO_SEPARATE_FAILURE_EVENT_REASON },
+      { events: ["post_compact"], reason: NO_POST_COMPACT_EVENT_REASON },
       { events: ["notification", "stop"], reason: NO_SERVER_HANDLER_REASON },
       {
         events: ["session_start"],
@@ -5032,6 +5053,55 @@ var BRIDGE_CAPABILITY_MATRIX = [
       }
     ]
   },
+  /**
+   * What Copilot CLI's wired events can actually carry, read from the shipping 1.0.80 bundle
+   * rather than from its hooks reference page. A row's `implemented` set says an event is wired;
+   * it deliberately says nothing about how much of that event's response the harness honors, and
+   * for Copilot the difference matters:
+   *
+   * - `pre_tool_use` deny is real, and the reason text reaches the model. The native string table
+   *   (runtime.node offset 98057208) carries `permissionDecision`, `permissionDecisionReason`, the
+   *   default "No reason provided." and the formatter "Denied by preToolUse hook: " as distinct
+   *   literals, and app.js sets `{textResultForLlm: reason, resultType: "denied"}` per denial and
+   *   filters that call out of execution. This was previously only an inference drawn from an
+   *   incident comment; it is now confirmed. The fail-closed "(hook errored)" deny-all strings sit
+   *   beside these, so that incident was behavior layered on top of a working deny handler, not a
+   *   substitute for one.
+   * - `post_tool_use` honors `modifiedResult`, so compression, injection fencing and image shrink
+   *   do reach the model: `postToolExecution` (app.js offset 2043150) assigns the returned
+   *   `toolResultJson` onto the tool result in place.
+   * - `post_tool_use` drops `additionalContext` on the JS path -- no supplier for the
+   *   `onAdditionalContext` callback anywhere in the bundle, and no `additional_contexts` key in
+   *   that event's native return payload, unlike its pre-tool sibling. Whether native folds it
+   *   into the returned result instead was not verified.
+   * - Failed tool calls never reach `post_tool_use` at all. Copilot routes them to a separate
+   *   `postToolUseFailure` event, which is handed only a stringified error and honors only
+   *   `additionalContext`; `modifiedResult` is documented as not honored there. So on Copilot the
+   *   output of a failed tool call reaches the model unfenced, uncompressed and unshrunk, and no
+   *   response shape token-goat's shim can emit changes that. Known gap, deliberately recorded.
+   *   What `additionalContext` does on that event is no longer doc-derived: app.js offset 2043380
+   *   reads the native processor's return and, when it carries `additionalContext`, either folds
+   *   it into `textResultForLlm` (if `appendFailureContextToToolResult` is set) or formats it and
+   *   pushes `{content, source: "system"}` onto `toolResult.newMessages`. So the channel is real
+   *   and model-visible -- it just carries advice alongside the failure, never a replacement for
+   *   it. It is wired now, as its own `post_tool_use_failure` event rather than a reuse of
+   *   `post_tool_use`: routing failures through the success event would let success-path handlers
+   *   mark a file as successfully read when the read failed. Because the channel spends tokens
+   *   instead of saving them, its handler (`src/hooks_tool_failure.ts`) stays silent on a first
+   *   failure and speaks only on an exact repeat.
+   * - `pre_compact` is wired and fires, but nothing it returns can reach the model. Both dispatch
+   *   sites call it in statement position and drop the result: app.js offset 2467452 (the manual
+   *   `/compact` path) and offset 2571216 (`case "execute_pre_compact_hook"`). The contrast is
+   *   what makes this conclusive rather than an absence of evidence -- the same `event()` runner's
+   *   return IS read for other events, e.g. `notification` at offset 2296123 assigns it and
+   *   forwards `additionalContext` as a prepended system prompt. The compaction prompt is then
+   *   built from session history and the user's own focus text, with no hook channel into it.
+   *   So token-goat's `pre_compact` registration here is observe-only by construction, not merely
+   *   unused: a future attempt to inject a session manifest through it would silently do nothing.
+   *   Not verified: whether the native declarative runner applies `additionalContext` itself. The
+   *   trail ends in stripped Rust. That it would make the explicit JS handling for `notification`
+   *   and `userPromptSubmitted` redundant is an argument, not a proof.
+   */
   {
     harness: "copilot_cli",
     label: "Copilot CLI",
@@ -5043,12 +5113,14 @@ var BRIDGE_CAPABILITY_MATRIX = [
       "pre_compact",
       "stop",
       "subagent_stop",
-      "user_prompt_submit"
+      "user_prompt_submit",
+      "post_tool_use_failure"
     ]),
     reasons: [
+      { events: ["post_compact"], reason: COPILOT_NO_POST_COMPACT_REASON },
       {
         events: ["notification"],
-        reason: "Copilot CLI has a real 'notification' hook event, but copilot_cli.ts's COPILOT_TO_TG_EVENT deliberately leaves it (and sessionEnd/postToolUseFailure/subagentStart/errorOccurred/permissionRequest) unimplemented rather than guessed at"
+        reason: "Copilot CLI has a real 'notification' hook event, but copilot_cli.ts's COPILOT_TO_TG_EVENT deliberately leaves it (and sessionEnd/subagentStart/errorOccurred/permissionRequest) unimplemented rather than guessed at"
       }
     ]
   },
@@ -5058,6 +5130,8 @@ var BRIDGE_CAPABILITY_MATRIX = [
     sourceFile: "src/bridges/gemini_install.ts (GEMINI_HOOK_EVENTS)",
     implemented: /* @__PURE__ */ new Set(["pre_tool_use", "post_tool_use", "pre_compact"]),
     reasons: [
+      { events: ["post_tool_use_failure"], reason: NO_SEPARATE_FAILURE_EVENT_REASON },
+      { events: ["post_compact"], reason: NO_POST_COMPACT_EVENT_REASON },
       {
         events: ["notification", "stop", "user_prompt_submit", "subagent_stop", "session_start"],
         reason: `Gemini CLI's hooks integration only wires BeforeTool/AfterTool/PreCompress (README "Gemini CLI users")`
@@ -5070,6 +5144,8 @@ var BRIDGE_CAPABILITY_MATRIX = [
     sourceFile: "src/bridges/qwen_install.ts (QWEN_HOOK_EVENTS)",
     implemented: /* @__PURE__ */ new Set(["pre_tool_use", "post_tool_use", "pre_compact", "user_prompt_submit", "subagent_stop"]),
     reasons: [
+      { events: ["post_tool_use_failure"], reason: NO_SEPARATE_FAILURE_EVENT_REASON },
+      { events: ["post_compact"], reason: NO_POST_COMPACT_EVENT_REASON },
       {
         events: ["notification"],
         reason: "Only five Qwen Code events have a token-goat handler; every other real event (Notification, SessionEnd, PostToolUseFailure, StopFailure, SubagentStart, PermissionRequest, TodoCreated, TodoCompleted) is left unimplemented rather than guessed at (qwen_install.ts)"
@@ -5086,7 +5162,11 @@ var BRIDGE_CAPABILITY_MATRIX = [
     label: "Kimi Code CLI",
     sourceFile: "src/bridges/kimi_install.ts (KIMI_EVENT_ARG), src/bridges/kimi.ts (KIMI_HOOK_SCRIPT)",
     implemented: /* @__PURE__ */ new Set(["pre_tool_use", "post_tool_use", "pre_compact", "user_prompt_submit", "subagent_stop", "session_start"]),
-    reasons: [{ events: ["notification", "stop"], reason: NO_SERVER_HANDLER_REASON }]
+    reasons: [
+      { events: ["post_tool_use_failure"], reason: NO_SEPARATE_FAILURE_EVENT_REASON },
+      { events: ["post_compact"], reason: NO_POST_COMPACT_EVENT_REASON },
+      { events: ["notification", "stop"], reason: NO_SERVER_HANDLER_REASON }
+    ]
   },
   {
     harness: "opencode",
@@ -5094,6 +5174,8 @@ var BRIDGE_CAPABILITY_MATRIX = [
     sourceFile: "src/bridges/opencode.ts",
     implemented: /* @__PURE__ */ new Set(["pre_tool_use", "post_tool_use", "pre_compact"]),
     reasons: [
+      { events: ["post_tool_use_failure"], reason: NO_SEPARATE_FAILURE_EVENT_REASON },
+      { events: ["post_compact"], reason: NO_POST_COMPACT_EVENT_REASON },
       {
         events: ["notification", "stop", "user_prompt_submit", "subagent_stop", "session_start"],
         reason: "opencode's plugin API only exposes three relevant hooks -- tool.execute.before, tool.execute.after, experimental.session.compacting (opencode.ts module docstring, verified against opencode's real source)"
@@ -5106,6 +5188,8 @@ var BRIDGE_CAPABILITY_MATRIX = [
     sourceFile: "src/bridges/openclaw.ts",
     implemented: /* @__PURE__ */ new Set(["pre_tool_use", "post_tool_use", "pre_compact"]),
     reasons: [
+      { events: ["post_tool_use_failure"], reason: NO_SEPARATE_FAILURE_EVENT_REASON },
+      { events: ["post_compact"], reason: NO_POST_COMPACT_EVENT_REASON },
       {
         events: ["notification", "stop", "user_prompt_submit", "subagent_stop", "session_start"],
         reason: "OpenClaw's in-process plugin API only exposes before_tool_call/after_tool_call/before_compaction as api.on() handlers relevant here"
@@ -5118,6 +5202,8 @@ var BRIDGE_CAPABILITY_MATRIX = [
     sourceFile: "src/bridges/pi.ts",
     implemented: /* @__PURE__ */ new Set(["pre_tool_use", "post_tool_use", "pre_compact"]),
     reasons: [
+      { events: ["post_tool_use_failure"], reason: NO_SEPARATE_FAILURE_EVENT_REASON },
+      { events: ["post_compact"], reason: NO_POST_COMPACT_EVENT_REASON },
       {
         events: ["notification", "stop", "user_prompt_submit", "subagent_stop", "session_start"],
         reason: "pi's extension API subscribes to session_start/tool_call/tool_result/session_before_compact/session_compact, of which only tool_call/tool_result/session_before_compact map onto real HOOK_EVENTS names (pre_tool_use/post_tool_use/pre_compact) -- pi's own session_start event is never forwarded to token-goat's callHook()"
@@ -5484,7 +5570,7 @@ function purgeDataDirectories() {
   }
   return result;
 }
-function formatBytes(bytes) {
+function formatBytes2(bytes) {
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
   if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
@@ -5505,8 +5591,8 @@ function formatTopFiles(ranked) {
   if (ranked.length === 0) return "";
   const lines = ["Top files this session:"];
   for (const { path: filePath, count } of ranked) {
-    const basename7 = path10.basename(filePath);
-    lines.push(`  ${count.toString().padStart(3)}x  ${basename7}  (${filePath})`);
+    const basename8 = path10.basename(filePath);
+    lines.push(`  ${count.toString().padStart(3)}x  ${basename8}  (${filePath})`);
   }
   return lines.join("\n");
 }
@@ -5856,7 +5942,7 @@ function checkInstall() {
   }
 }
 function checkTsCompiler() {
-  if (isAvailable()) {
+  if (isAvailable2()) {
     return { name: "TypeScript compiler", status: "ok", message: "available" };
   }
   const err2 = loadError();
@@ -5866,6 +5952,27 @@ function checkTsCompiler() {
     message: err2 !== null ? `unavailable: ${extractErrorMessage(err2)}` : "unavailable (not attempted)"
   };
 }
+function checkEmbeddings(config) {
+  const name = "Embeddings";
+  if ((config.indexing?.embeddings_enabled ?? true) === false) {
+    return { name, status: "ok", message: "disabled by config (indexing.embeddings_enabled)" };
+  }
+  if (isAvailable()) return { name, status: "ok", message: "available" };
+  const err2 = embeddingBackendLoadError();
+  const code = err2?.code;
+  if (code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND") {
+    return {
+      name,
+      status: "warn",
+      message: "onnxruntime-node is not installed, so semantic falls back to keyword search \u2014 install it with: npm install -g onnxruntime-node (drop -g if token-goat is a project dependency)"
+    };
+  }
+  return {
+    name,
+    status: "warn",
+    message: err2 !== null ? `onnxruntime-node is installed but failed to load: ${extractErrorMessage(err2)}` : "unavailable (not attempted)"
+  };
+}
 function checkConfigValid(configPath2) {
   if (!fs12.existsSync(configPath2)) {
     return {
@@ -6064,6 +6171,46 @@ function dataDirPermissionResult(dataDirPath) {
     return { name: "Security data dir", status: "warn", message: "could not be read, so its permissions are unknown" };
   }
 }
+var COMPACTION_CHANNEL_WINDOW = 5;
+function checkCompactionChannel(dbPath) {
+  const name = "Compaction channel";
+  if (!fs12.existsSync(dbPath)) {
+    return { name, status: "ok", message: "no database yet" };
+  }
+  try {
+    const db = getDb(dbPath);
+    const present = db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'stats'").get();
+    if (present === void 0) {
+      return { name, status: "ok", message: "no compaction has been measured yet" };
+    }
+    const rows = db.prepare("SELECT detail FROM stats WHERE kind = 'compact_summary' ORDER BY rowid DESC LIMIT ?").all(COMPACTION_CHANNEL_WINDOW * 4);
+    const conclusive = [];
+    for (const row of rows) {
+      const m = /manifest_paths=(\d+)\/(\d+)/.exec(row.detail ?? "");
+      if (m === null) continue;
+      const sampled = Number(m[2]);
+      if (sampled === 0) continue;
+      conclusive.push({ survived: Number(m[1]), sampled });
+      if (conclusive.length >= COMPACTION_CHANNEL_WINDOW) break;
+    }
+    if (conclusive.length === 0) {
+      return { name, status: "ok", message: "no compaction has been measured yet" };
+    }
+    const dead = conclusive.filter((c) => c.survived === 0).length;
+    if (conclusive.length >= COMPACTION_CHANNEL_WINDOW && dead === conclusive.length) {
+      return {
+        name,
+        status: "warn",
+        message: `none of the last ${conclusive.length} compaction summaries kept a single file path token-goat sent ahead of them -- Claude Code may have stopped feeding a PreCompact hook's output to the summarizer, which would make the session manifest a no-op`
+      };
+    }
+    const kept = conclusive.reduce((n, c) => n + c.survived, 0);
+    const sent = conclusive.reduce((n, c) => n + c.sampled, 0);
+    return { name, status: "ok", message: `${kept}/${sent} sampled paths survived the last ${conclusive.length} compaction(s)` };
+  } catch (e) {
+    return { name, status: "warn", message: `could not read compaction stats: ${extractErrorMessage(e)}` };
+  }
+}
 function runDoctor(dataDir2, configPath2, rootDir, processes) {
   const results = [];
   const actualDataDir = dataDir2 || dataDir();
@@ -6075,8 +6222,10 @@ function runDoctor(dataDir2, configPath2, rootDir, processes) {
   results.push(checkSymbolBodySize(path11.join(actualDataDir, "global.db")));
   results.push(checkSymbolCount(path11.join(actualDataDir, "global.db"), rootDir));
   results.push(checkDirtyQueueHealth(actualDataDir));
+  results.push(checkCompactionChannel(path11.join(actualDataDir, "global.db")));
   const actualConfigPath = configPath2 || configPath();
   results.push(checkConfigValid(actualConfigPath));
+  results.push(checkEmbeddings(loadConfig(rootDir)));
   for (const result of checkSecurityPosture(loadConfig(rootDir), actualDataDir)) results.push(result);
   results.push(checkDiskSpace(actualDataDir));
   const copilotResult = checkCopilotCli(copilotCliConfigPath(), copilotCliScriptPath());
@@ -12408,8 +12557,8 @@ async function runMemoryCommand(opts = {}) {
 }
 
 // src/cli_waste.ts
-import * as fs23 from "node:fs";
-import * as path23 from "node:path";
+import * as fs24 from "node:fs";
+import * as path24 from "node:path";
 
 // src/waste.ts
 import * as fs22 from "node:fs";
@@ -12494,6 +12643,7 @@ function parseTranscript2(transcriptPath) {
   const calls = [];
   const resultTextById = /* @__PURE__ */ new Map();
   const assistantTurns = [];
+  const resident = createResidentContextStats();
   let seq = 0;
   for (const line of raw.split("\n")) {
     const trimmed = line.trim();
@@ -12506,6 +12656,7 @@ function parseTranscript2(transcriptPath) {
     }
     if (obj === null || typeof obj !== "object") continue;
     const o = obj;
+    accumulateResidentLine(resident, o, trimmed.length);
     const message = o["message"];
     if (message === null || typeof message !== "object") continue;
     const messageObj = message;
@@ -12545,7 +12696,7 @@ function parseTranscript2(transcriptPath) {
     }
     if (role === "assistant" && sawTextBlock) assistantTurns.push(turnTextTokens);
   }
-  return { calls, resultTextById, assistantTurns };
+  return { calls, resultTextById, assistantTurns, resident };
 }
 function costPerCall(parsed) {
   return parsed.calls.map((c) => ({
@@ -12651,11 +12802,250 @@ async function buildWasteReport(transcriptPath, opts = {}) {
     topCalls: topExpensiveCalls(costs, topN).map((c) => ({ seq: c.seq, name: c.name, summary: c.summary, tokens: c.tokens })),
     neverTouchedAgain: neverTouchedAgain(costs),
     repeatedUncompressedBash: await repeatedUncompressedBashCommands(costs),
-    assistantOutput: assistantOutputCost(parsed.assistantTurns)
+    assistantOutput: assistantOutputCost(parsed.assistantTurns),
+    residentContext: summarizeResidentContext(parsed.resident)
   };
 }
 
+// src/copilot_waste.ts
+import * as fs23 from "node:fs";
+import * as path23 from "node:path";
+var HOOK_RECORD_TYPES = /* @__PURE__ */ new Set(["hook.start", "hook.end"]);
+function splitInjectedBlocks(transformed) {
+  const out2 = [];
+  const blockRe = /<([a-z_][a-z0-9_]*)>([\s\S]*?)<\/\1>/gi;
+  let m;
+  while ((m = blockRe.exec(transformed)) !== null) {
+    const tag = (m[1] ?? "").toLowerCase();
+    const body = m[2] ?? "";
+    let kind = tag;
+    if (tag === "system_reminder") {
+      const inner = /^\s*<([a-z_][a-z0-9_]*)>/i.exec(body);
+      kind = inner !== null ? `reminder:${(inner[1] ?? "").toLowerCase()}` : "reminder:text";
+    }
+    out2.push({ kind, body: m[0] });
+  }
+  return out2;
+}
+function findLatestCopilotSession() {
+  const root = path23.join(copilotCliUserRoot(), "session-state");
+  let entries;
+  try {
+    entries = fs23.readdirSync(root);
+  } catch {
+    return null;
+  }
+  let best = null;
+  let bestMtime = -Infinity;
+  for (const entry of entries) {
+    const candidate = path23.join(root, entry, "events.jsonl");
+    try {
+      const st = fs23.statSync(candidate);
+      if (!st.isFile()) continue;
+      if (st.mtimeMs > bestMtime) {
+        bestMtime = st.mtimeMs;
+        best = candidate;
+      }
+    } catch {
+    }
+  }
+  return best;
+}
+function readNumber(source, key) {
+  const value = source[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function buildCopilotWasteReport(eventsPath) {
+  const raw = fs23.readFileSync(eventsPath, "utf-8");
+  const report = {
+    sessionPath: eventsPath,
+    sessionId: path23.basename(path23.dirname(eventsPath)),
+    turns: 0,
+    tokens: null,
+    blocks: [],
+    compactions: [],
+    hookRecordBytes: 0,
+    totalEventBytes: Buffer.byteLength(raw, "utf-8"),
+    // Read through the real resolution chain rather than passed in. Copilot's
+    // own COPILOT_CACHE_HOME override is what tests point at a fixture, so the
+    // shipping path is the tested path and there is no seam here that only a
+    // test ever supplies.
+    mcpTools: readCopilotMcpTools()
+  };
+  const classes = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Map();
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const type = typeof event["type"] === "string" ? event["type"] : "";
+    const data = event["data"] ?? {};
+    if (HOOK_RECORD_TYPES.has(type)) {
+      report.hookRecordBytes += Buffer.byteLength(trimmed, "utf-8");
+      continue;
+    }
+    if (type === "session.shutdown") {
+      report.tokens = {
+        systemTokens: readNumber(data, "systemTokens"),
+        toolDefinitionsTokens: readNumber(data, "toolDefinitionsTokens"),
+        conversationTokens: readNumber(data, "conversationTokens"),
+        currentTokens: readNumber(data, "currentTokens")
+      };
+      continue;
+    }
+    if (type === "session.compaction_complete") {
+      const summary = typeof data["summaryContent"] === "string" ? data["summaryContent"] : "";
+      report.compactions.push({
+        trigger: typeof data["trigger"] === "string" ? data["trigger"] : "unknown",
+        summaryBytes: Buffer.byteLength(summary, "utf-8"),
+        preTokens: readNumber(data, "preCompactionTokens"),
+        postTokens: readNumber(data, "postCompactionTokens")
+      });
+      continue;
+    }
+    if (type !== "user.message") continue;
+    const transformed = typeof data["transformedContent"] === "string" ? data["transformedContent"] : "";
+    if (transformed === "") continue;
+    report.turns += 1;
+    for (const block of splitInjectedBlocks(transformed)) {
+      const bytes = Buffer.byteLength(block.body, "utf-8");
+      let cls = classes.get(block.kind);
+      if (cls === void 0) {
+        cls = { kind: block.kind, count: 0, bytes: 0, repeatBytes: 0, repeatCount: 0 };
+        classes.set(block.kind, cls);
+      }
+      cls.count += 1;
+      cls.bytes += bytes;
+      let bucket = seen.get(block.kind);
+      if (bucket === void 0) {
+        bucket = /* @__PURE__ */ new Set();
+        seen.set(block.kind, bucket);
+      }
+      if (bucket.has(block.body)) {
+        cls.repeatBytes += bytes;
+        cls.repeatCount += 1;
+      } else {
+        bucket.add(block.body);
+      }
+    }
+  }
+  report.blocks = [...classes.values()].sort((a, b) => b.bytes - a.bytes);
+  return report;
+}
+
 // src/cli_waste.ts
+function printCopilotReport(report) {
+  const w = (text) => {
+    process.stdout.write(text);
+  };
+  w("\n# token-goat waste (Copilot CLI)\n");
+  w(`Session: ${report.sessionId}
+`);
+  w(`  ${report.sessionPath}
+`);
+  w("\n## Per-request fixed overhead (Copilot's own token counts)\n");
+  if (report.tokens === null) {
+    w("  No shutdown record yet, so Copilot has not published a token split for this session.\n");
+  } else {
+    const { systemTokens, toolDefinitionsTokens, conversationTokens } = report.tokens;
+    const fixed = systemTokens + toolDefinitionsTokens;
+    const total = fixed + conversationTokens;
+    w(`  System prompt:     ${systemTokens.toLocaleString()} tok
+`);
+    w(`  Tool definitions:  ${toolDefinitionsTokens.toLocaleString()} tok
+`);
+    w(`  Conversation:      ${conversationTokens.toLocaleString()} tok
+`);
+    if (total > 0) {
+      const pct = (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("  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");
+      w("  --agent / --no-ask-user / --no-custom-instructions, whose effect on this number is\n");
+      w("  entailed by how they are wired but has not been measured here. Copilot also ships\n");
+      w("  built-in MCP servers, which --disable-builtin-mcps turns off wholesale. Note that\n");
+      w("  --enable-all-github-mcp-tools moves this number the wrong way: its own help text calls\n");
+      w("  the default a subset, so enabling everything adds definitions rather than removing\n");
+      w("  them. --add-github-mcp-tool and --add-github-mcp-toolset replace that subset too.\n");
+    }
+  }
+  w("\n## Tool definitions by MCP server (estimated)\n");
+  const mcp = report.mcpTools;
+  if (!mcp.cacheFound) {
+    w(`  No MCP tool cache at ${copilotCliMcpToolsDir()}.
+`);
+    w("  That is not the same as having no MCP servers: it means nothing has been cached\n");
+    w("  there yet, which is also what a Copilot that has never connected one looks like.\n");
+  } else if (mcp.servers.length === 0) {
+    w("  Cache is present but holds no servers, so none of the tool-definition budget\n");
+    w(`  above is MCP: it is all Copilot's own tools, which the flags above can narrow
+`);
+    w("  but dropping a server cannot.\n");
+  } else {
+    for (const server of mcp.servers) {
+      const tokens = server.estimatedTokens.toLocaleString();
+      w(`  ${server.serverName}: ${countNoun(server.toolCount, "tool")}, `);
+      w(`${formatBytes(server.definitionBytes)}, ~${tokens} tok
+`);
+    }
+    const mcpTokens = mcp.servers.reduce((sum, server) => sum + server.estimatedTokens, 0);
+    w(`  ~${mcpTokens.toLocaleString()} tok estimated across `);
+    w(`${countNoun(mcp.servers.length, "server")}, re-sent every request.
+`);
+    if (report.tokens !== null && report.tokens.toolDefinitionsTokens > 0) {
+      const share = (mcpTokens / report.tokens.toolDefinitionsTokens * 100).toFixed(1);
+      w(`  Copilot counted ${report.tokens.toolDefinitionsTokens.toLocaleString()} tok of tool `);
+      w(`definitions in total, so this is roughly ${share}% of it.
+`);
+      w("  The two are not a split of each other and come from different places: Copilot\n");
+      w("  counted its own with its own tokeniser, while these are estimated from the bytes\n");
+      w(`  of the cached definitions. The remainder is mostly Copilot's own non-MCP tools,
+`);
+      w("  which are not cached here: dropping a server does not touch them, though the\n");
+      w("  tool-filter flags above still can.\n");
+    }
+    w("  Dropping a server saves its line above on every request for the rest of the session.\n");
+  }
+  if (mcp.unreadable > 0) {
+    const verb = mcp.unreadable === 1 ? "is" : "are";
+    w(`  ${countNoun(mcp.unreadable, "cache file")} could not be read and ${verb} not counted above.
+`);
+  }
+  w("\n## Injected blocks in the assembled prompt\n");
+  if (report.blocks.length === 0) {
+    w(`  none across ${countNoun(report.turns, "turn")}
+`);
+  } else {
+    for (const block of report.blocks) {
+      const pct = 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}%)
+` : "\n");
+    }
+  }
+  w("\n## Compactions\n");
+  if (report.compactions.length === 0) {
+    w(`  ${countNoun(report.compactions.length, "compaction")} recorded this session
+`);
+  } else {
+    for (const c of report.compactions) {
+      w(`  ${c.trigger}: summary ${formatBytes(c.summaryBytes)}, ${c.preTokens.toLocaleString()} -> ${c.postTokens.toLocaleString()} tok
+`);
+    }
+  }
+  w("\n## On disk but never billed\n");
+  w(`  Hook records: ${formatBytes(report.hookRecordBytes)} of ${formatBytes(report.totalEventBytes)} in the event log.
+`);
+  w("  hook.start/hook.end never reach the model, so this is log weight, not context weight.\n");
+}
 function printReport2(report) {
   const w = (text) => {
     process.stdout.write(text);
@@ -12708,10 +13098,71 @@ function printReport2(report) {
   w(`  Re-send upper bound: ${ao.resendCeilingTokens} tok if every turn were resent at full price on every later request
 `);
   w("  Real cost is substantially lower: prompt caching bills resent conversation history at cache-read rates, not full input price.\n");
+  printResidentContext(report.residentContext, w);
+}
+function printResidentContext(resident, w) {
+  w("\n## Harness-injected context (never passes through a hook)\n");
+  if (resident.attachmentClasses.length === 0) {
+    w("  none\n");
+  } else {
+    w(`  Total injected: ${formatBytes(resident.totalAttachmentBytes)} across ${countNoun(resident.attachmentClasses.length, "class", "classes")}
+`);
+    for (const c of resident.attachmentClasses.slice(0, 8)) {
+      w(`  ${c.type}: ${countNoun(c.count, "injection")}, ${formatBytes(c.bytes)}
+`);
+    }
+  }
+  const task = resident.latestTaskList;
+  if (task !== null) {
+    w("\n## Task list (re-injected in full whenever it changes)\n");
+    w(`  Latest: ${formatBytes(task.bytes)} (~${formatTokenEstimate(estimateTokensFromLength(task.bytes))} tok est), ${countNoun(task.itemCount, "item")}
+`);
+    w(`  ${task.completed} completed, ${task.inProgress} in progress, ${task.pending} pending
+`);
+    w(`  Descriptions: ${formatBytes(task.descriptionBytes)} total, ${formatBytes(task.completedDescriptionBytes)} of it on completed items
+`);
+    w(`  Injected ${countNoun(resident.taskReminderCount, "time")} this session, ${formatBytes(resident.taskReminderBytes)} cumulative
+`);
+  }
+  if (resident.repeatedSkillBodies.length > 0) {
+    w("\n## Skill bodies injected more than once\n");
+    w("  Slash expansion and the Skill tool both send the whole body every time; no hook sees either.\n");
+    for (const s of resident.repeatedSkillBodies.slice(0, 8)) {
+      w(`  ${s.skill}: ${countNoun(s.count, "injection")}, ${formatBytes(s.bytes)} (~${formatTokenEstimate(estimateTokensFromLength(s.bytes))} tok est)
+`);
+    }
+  }
+  w("\n## Compactions\n");
+  w(`  ${countNoun(resident.compactionCount, "compaction")} this session`);
+  w(resident.compactionCount === 0 ? "\n" : ", each re-injecting the fixed preamble (CLAUDE.md, memory, skill and agent listings)\n");
 }
 async function runWasteCommand(opts = {}) {
+  if (opts.copilot === true) {
+    const eventsPath = opts.transcript !== void 0 ? path24.resolve(opts.transcript) : findLatestCopilotSession();
+    if (eventsPath === null || !fs24.existsSync(eventsPath)) {
+      const detail = eventsPath === null ? "no Copilot CLI session found under <copilot-home>/session-state" : `Copilot session event log not found: ${eventsPath}`;
+      if (opts.json === true) {
+        process.stdout.write(`${JSON.stringify({ error: detail })}
+`);
+      } else {
+        process.stdout.write("\n# token-goat waste (Copilot CLI)\n");
+        process.stdout.write(`${detail}
+`);
+      }
+      process.exitCode = 1;
+      return;
+    }
+    const copilotReport = buildCopilotWasteReport(eventsPath);
+    if (opts.json === true) {
+      process.stdout.write(`${JSON.stringify(copilotReport)}
+`);
+      return;
+    }
+    printCopilotReport(copilotReport);
+    return;
+  }
   const projectRoot = resolveProjectRoot(opts.project !== void 0 ? { project: opts.project } : {});
-  const transcriptPath = opts.transcript !== void 0 ? path23.resolve(opts.transcript) : findLatestTranscript(projectRoot);
+  const transcriptPath = opts.transcript !== void 0 ? path24.resolve(opts.transcript) : findLatestTranscript(projectRoot);
   if (transcriptPath === null) {
     if (opts.json === true) {
       process.stdout.write(`${JSON.stringify({ error: "no session transcript found", project: projectRoot })}
@@ -12725,7 +13176,7 @@ async function runWasteCommand(opts = {}) {
     process.exitCode = 1;
     return;
   }
-  if (!fs23.existsSync(transcriptPath)) {
+  if (!fs24.existsSync(transcriptPath)) {
     process.stderr.write(`token-goat: transcript not found: ${transcriptPath}
 `);
     process.exitCode = 1;
@@ -12741,17 +13192,17 @@ async function runWasteCommand(opts = {}) {
 }
 
 // src/session_read.ts
-import * as fs24 from "node:fs";
-import * as path24 from "node:path";
+import * as fs25 from "node:fs";
+import * as path25 from "node:path";
 import * as readline2 from "node:readline";
 function resolveSessionTranscript(arg, opts = {}) {
   if (arg !== void 0 && arg !== "") {
-    if (fs24.existsSync(arg) && fs24.statSync(arg).isFile()) return arg;
+    if (fs25.existsSync(arg) && fs25.statSync(arg).isFile()) return arg;
     const projectRoot2 = resolveProjectRoot(opts.project !== void 0 ? { project: opts.project } : {});
     const dir = projectTranscriptsDir(projectRoot2);
     const byId = arg.endsWith(".jsonl") ? arg : `${arg}.jsonl`;
-    const candidate = path24.join(dir, byId);
-    if (fs24.existsSync(candidate) && fs24.statSync(candidate).isFile()) return candidate;
+    const candidate = path25.join(dir, byId);
+    if (fs25.existsSync(candidate) && fs25.statSync(candidate).isFile()) return candidate;
     return null;
   }
   const projectRoot = resolveProjectRoot(opts.project !== void 0 ? { project: opts.project } : {});
@@ -12809,7 +13260,7 @@ function toolCallsForBlocks(blocks) {
   return blocks.filter((b) => b.type === "tool_use" && b.name !== void 0).map((b) => b.name);
 }
 async function* streamTurns(transcriptPath) {
-  const input = fs24.createReadStream(transcriptPath, { encoding: "utf8" });
+  const input = fs25.createReadStream(transcriptPath, { encoding: "utf8" });
   const rl = readline2.createInterface({ input, crlfDelay: Infinity });
   try {
     let lineNumber = 0;
@@ -12907,15 +13358,15 @@ function formatSessionSlice(turns) {
 }
 
 // src/cli_mcp_audit.ts
-import * as fs25 from "node:fs";
-import * as path25 from "node:path";
+import * as fs26 from "node:fs";
+import * as path26 from "node:path";
 function readMcpConfig(projectRoot) {
-  const configPath2 = path25.join(projectRoot, ".mcp.json");
+  const configPath2 = path26.join(projectRoot, ".mcp.json");
   try {
-    if (!fs25.existsSync(configPath2)) {
+    if (!fs26.existsSync(configPath2)) {
       return null;
     }
-    const content = fs25.readFileSync(configPath2, "utf-8");
+    const content = fs26.readFileSync(configPath2, "utf-8");
     const parsed = JSON.parse(content);
     return parsed.mcpServers || parsed;
   } catch {
@@ -13221,10 +13672,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 (fs26.statSync(file).size > CONTENT_MAX_INPUT_CHARS) {
+    if (fs27.statSync(file).size > CONTENT_MAX_INPUT_CHARS) {
       throw new CliError(`file exceeds the ${CONTENT_MAX_INPUT_CHARS}-byte safety limit`);
     }
-    value = fs26.readFileSync(file, "utf8");
+    value = fs27.readFileSync(file, "utf8");
   } else {
     if (text === void 0) throw new CliError("provide text or --file");
     value = text;
@@ -13361,7 +13812,7 @@ async function cmdIndex(pathArg, opts = {}) {
       continue;
     }
     const sha = fingerprintFile(key);
-    if (sha === null && !fs26.existsSync(key)) continue;
+    if (sha === null && !fs27.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;
@@ -13387,7 +13838,7 @@ async function cmdIndex(pathArg, opts = {}) {
         }
         continue;
       }
-      if (!fs26.existsSync(key)) continue;
+      if (!fs27.existsSync(key)) continue;
     }
     if (!embedUnchanged) {
       paintProgress("embedding");
@@ -13447,11 +13898,11 @@ async function cmdMcpServe() {
   let StdioServerTransport;
   try {
     ;
-    ({ createMcpServer } = await import("./token-goat-chunk-65BKISIS.mjs"));
-    ({ StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js"));
+    ({ createMcpServer } = await import("./token-goat-chunk-FBGBTICM.mjs"));
+    ({ StdioServerTransport } = await import("./token-goat-chunk-324QOJYZ.mjs"));
   } catch (err2) {
     process.stderr.write(
-      `token-goat: mcp-server unavailable (install @modelcontextprotocol/sdk to use this feature): ${String(err2)}
+      `token-goat: mcp-server unavailable (could not load the MCP server modules): ${String(err2)}
 `
     );
     process.exitCode = 1;
@@ -13461,14 +13912,14 @@ async function cmdMcpServe() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
   await new Promise((resolve12) => {
-    server.server.onclose = resolve12;
+    server.onclose = resolve12;
   });
 }
 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-FRTBMRP7.mjs");
+  const { relay } = await import("./token-goat-chunk-A62K4XW2.mjs");
   await relay(event);
 }
 async function cmdInstall(opts) {
@@ -13572,16 +14023,16 @@ async function cmdInstall(opts) {
     );
   }
   try {
-    const skillDir = path26.join(homedir11(), ".claude", "skills");
-    if (fs26.existsSync(skillDir)) {
-      const entries = fs26.readdirSync(skillDir, { withFileTypes: true });
+    const skillDir = path27.join(homedir11(), ".claude", "skills");
+    if (fs27.existsSync(skillDir)) {
+      const entries = fs27.readdirSync(skillDir, { withFileTypes: true });
       const skillNames = [];
       const sessionId = getSessionId();
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const skillFile = path26.join(skillDir, entry.name, "SKILL.md");
-        if (fs26.existsSync(skillFile)) {
-          const body = fs26.readFileSync(skillFile, "utf-8");
+        const skillFile = path27.join(skillDir, entry.name, "SKILL.md");
+        if (fs27.existsSync(skillFile)) {
+          const body = fs27.readFileSync(skillFile, "utf-8");
           const compact = extractCompactFromMarker(body);
           if (compact === null) continue;
           const sourceSha = contentHash(body);
@@ -13591,10 +14042,10 @@ async function cmdInstall(opts) {
       }
       if (skillNames.length > 0) {
         const dir = skillOutputsDir();
-        await fs26.promises.mkdir(dir, { recursive: true });
-        const pregenPath = path26.join(dir, "pregen.json");
+        await fs27.promises.mkdir(dir, { recursive: true });
+        const pregenPath = path27.join(dir, "pregen.json");
         const pregenData = { ts: Date.now(), names: skillNames };
-        await fs26.promises.writeFile(pregenPath, JSON.stringify(pregenData, null, 2));
+        await fs27.promises.writeFile(pregenPath, JSON.stringify(pregenData, null, 2));
         out(`Pre-generated ${skillNames.length} skill compacts.`);
       }
     }
@@ -13682,7 +14133,7 @@ function runPurge() {
   }
   const result = purgeDataDirectories();
   for (const root of result.absent) out(`Nothing to purge at ${root}.`);
-  for (const removed of result.removed) out(`Purged ${removed.path} (${formatBytes(removed.bytes)} reclaimed).`);
+  for (const removed of result.removed) out(`Purged ${removed.path} (${formatBytes2(removed.bytes)} reclaimed).`);
   for (const failure of result.failed) err(`token-goat: could not purge ${failure.path}: ${failure.reason}`);
 }
 function cmdWorkerStart() {
@@ -13768,7 +14219,8 @@ function cmdWaste(opts = {}) {
     ...opts.project !== void 0 ? { project: opts.project } : {},
     ...opts.transcript !== void 0 ? { transcript: opts.transcript } : {},
     ...opts.json === true ? { json: true } : {},
-    ...opts.top !== void 0 ? { top: requireNonNegativeInt("--top", opts.top) } : {}
+    ...opts.top !== void 0 ? { top: requireNonNegativeInt("--top", opts.top) } : {},
+    ...opts.copilot === true ? { copilot: true } : {}
   });
 }
 async function cmdSessionOutline(sessionIdOrPath, opts = {}) {
@@ -13788,7 +14240,7 @@ ${formatSessionOutline(turns)}`;
 }
 function sessionTranscriptSize(transcriptPath) {
   try {
-    return fs26.statSync(transcriptPath).size;
+    return fs27.statSync(transcriptPath).size;
   } catch {
     return 0;
   }
@@ -13913,7 +14365,7 @@ function _applyFiltersAndPrint(content, opts, fenceUntrusted = false, fenceTag =
 }
 function fileSizeOrZero(filePath) {
   try {
-    return fs26.statSync(filePath).size;
+    return fs27.statSync(filePath).size;
   } catch {
     return 0;
   }
@@ -13928,11 +14380,11 @@ function cmdBashOutput(id, opts) {
     }
     let content;
     try {
-      const st = fs26.statSync(opts.file);
+      const st = fs27.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(fs26.readFileSync(opts.file)));
+      content = redactIfDotenv(opts.file, decodeSource(fs27.readFileSync(opts.file)));
     } catch (e) {
       if (e instanceof CliError) throw e;
       throw new CliError(`cannot read file: ${opts.file}`);
@@ -14325,7 +14777,7 @@ function emitExtraFileArgsNote(command, first, extras, opts = {}) {
 }
 async function cmdCompress(opts) {
   try {
-    const bashRunner = await import("./token-goat-chunk-CNDOJ3ZP.mjs");
+    const bashRunner = await import("./token-goat-chunk-4KZILRZN.mjs");
     if (opts.compress === false) {
       process.exitCode = bashRunner.runRaw(opts.cmd, parseTimeout(opts.timeout, bashRunner.DEFAULT_TIMEOUT_SECONDS));
       return;
@@ -14351,7 +14803,7 @@ async function cmdSkillBody(name, opts) {
   if (filePath === null) {
     throw new CliError(`skill '${name}' not found`);
   }
-  const body = decodeSource(fs26.readFileSync(filePath));
+  const body = decodeSource(fs27.readFileSync(filePath));
   if (opts.compact === true) {
     out(extractCompactFromMarker(body) ?? body);
   } else {
@@ -14368,7 +14820,7 @@ async function cmdSkillCompact(name, opts) {
     for (const skill of skills) {
       const filePath = await getSkillFilePath(skill.name);
       if (!filePath) continue;
-      const body2 = decodeSource(fs26.readFileSync(filePath));
+      const body2 = decodeSource(fs27.readFileSync(filePath));
       const compact2 = extractCompactFromMarker(body2);
       if (compact2 === null) continue;
       const sourceSha2 = contentHash(body2);
@@ -14389,19 +14841,19 @@ async function cmdSkillCompact(name, opts) {
     if (!opts.path.trim()) {
       throw new CliError("--path cannot be empty");
     }
-    if (!fs26.existsSync(opts.path)) {
+    if (!fs27.existsSync(opts.path)) {
       throw new CliError(`skill file not found: ${opts.path}`);
     }
     try {
-      body = fs26.readFileSync(opts.path, "utf-8");
+      body = fs27.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 ?? path26.basename(path26.dirname(path26.resolve(opts.path)));
-    sourcePath = path26.resolve(opts.path);
+    cacheName = name ?? path27.basename(path27.dirname(path27.resolve(opts.path)));
+    sourcePath = path27.resolve(opts.path);
   } else {
     if (name === void 0 || !name.trim()) {
       throw new CliError("skill-compact requires a <name> or --path <file>");
@@ -14410,7 +14862,7 @@ async function cmdSkillCompact(name, opts) {
     if (filePath === null) {
       throw new CliError(`skill '${name}' not found`);
     }
-    body = fs26.readFileSync(filePath, "utf-8");
+    body = fs27.readFileSync(filePath, "utf-8");
     cacheName = name;
     sourcePath = filePath;
   }
@@ -14542,8 +14994,8 @@ async function cmdSkillDiff(name) {
   }
   const newer = versions[0];
   const older = versions[1];
-  const newerBody = await fs26.promises.readFile(path26.resolve(dir, `${newer.outputId}.txt`), "utf-8").catch(() => null);
-  const olderBody = await fs26.promises.readFile(path26.resolve(dir, `${older.outputId}.txt`), "utf-8").catch(() => null);
+  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);
   if (newerBody === null || olderBody === null) {
     out(`a cached version of '${name}' was evicted while diffing -- try again`);
     return;
@@ -14572,7 +15024,7 @@ async function cmdSkillSection(nameHeading, headingArg) {
   if (!filePath) {
     throw new CliError(`skill '${skillName}' not found`);
   }
-  const body = decodeSource(fs26.readFileSync(filePath));
+  const body = decodeSource(fs27.readFileSync(filePath));
   const extracted = extractNamedSection(body, heading);
   if (!extracted) {
     process.exitCode = 1;
@@ -14582,7 +15034,7 @@ async function cmdSkillSection(nameHeading, headingArg) {
 }
 function atomicWriteBuffer(dest, data) {
   try {
-    if (fs26.statSync(dest).isDirectory()) {
+    if (fs27.statSync(dest).isDirectory()) {
       const e = Object.assign(new Error(`EISDIR: illegal operation on a directory, open '${dest}'`), { code: "EISDIR", path: dest });
       throw e;
     }
@@ -14590,23 +15042,23 @@ function atomicWriteBuffer(dest, data) {
     if (e.code !== "ENOENT") throw e;
   }
   const rnd = Math.random().toString(36).slice(2, 8);
-  const tmp = path26.join(path26.dirname(path26.resolve(dest)), `.tmp.${process.pid}.${rnd}`);
+  const tmp = path27.join(path27.dirname(path27.resolve(dest)), `.tmp.${process.pid}.${rnd}`);
   try {
-    fs26.writeFileSync(tmp, data, { mode: 384 });
+    fs27.writeFileSync(tmp, data, { mode: 384 });
     try {
-      const destMode = fs26.statSync(dest).mode;
-      fs26.chmodSync(tmp, destMode);
+      const destMode = fs27.statSync(dest).mode;
+      fs27.chmodSync(tmp, destMode);
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
     }
     withRetryOnLock(() => {
       try {
-        fs26.renameSync(tmp, dest);
+        fs27.renameSync(tmp, dest);
       } catch (e) {
         if (e.code === "EXDEV") {
-          fs26.copyFileSync(tmp, dest);
+          fs27.copyFileSync(tmp, dest);
           try {
-            fs26.unlinkSync(tmp);
+            fs27.unlinkSync(tmp);
           } catch (ue) {
             process.stderr.write(`token-goat write-file: warning: could not remove temp file ${tmp}: ${ue.message}
 `);
@@ -14618,7 +15070,7 @@ function atomicWriteBuffer(dest, data) {
     });
   } catch (e) {
     try {
-      fs26.unlinkSync(tmp);
+      fs27.unlinkSync(tmp);
     } catch {
     }
     throw e;
@@ -14628,9 +15080,9 @@ function mapFsError(e, src, dest, srcLabel = "source") {
   const fe = e;
   if (fe.code === "ENOENT") {
     const errPath = fe.path ?? "";
-    const isSource = src !== void 0 && path26.resolve(errPath) === path26.resolve(src);
+    const isSource = src !== void 0 && path27.resolve(errPath) === path27.resolve(src);
     if (isSource) throw new CliError(`${srcLabel} file not found: ${src}`);
-    const destDir = dest ? path26.dirname(path26.resolve(dest)) : path26.dirname(path26.resolve(errPath || "."));
+    const destDir = dest ? path27.dirname(path27.resolve(dest)) : path27.dirname(path27.resolve(errPath || "."));
     throw new CliError(`destination directory does not exist: ${destDir}`);
   }
   if (fe.code === "ENOTDIR") {
@@ -14641,7 +15093,7 @@ function mapFsError(e, src, dest, srcLabel = "source") {
   }
   if (fe.code === "EISDIR") {
     const errPath = fe.path ?? "";
-    const isSource = src !== void 0 && (errPath === "" || path26.resolve(errPath) === path26.resolve(src));
+    const isSource = src !== void 0 && (errPath === "" || path27.resolve(errPath) === path27.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)")}`);
   }
@@ -14710,7 +15162,7 @@ function validateWritablePath(dest, label) {
     throw new CliError(`${label} path contains a null byte`);
   }
   if (isWindows()) {
-    const base = path26.basename(dest);
+    const base = path27.basename(dest);
     const stem = base.replace(/\.[^.]*$/, "").toUpperCase();
     if (WIN_RESERVED.has(stem)) {
       throw new CliError(`${label} '${base}' is a reserved Windows device name`);
@@ -14740,7 +15192,7 @@ function readFileBoundedRaw(filePath, label, allowStdIn = false) {
     throw new CliError(`${label} ${filePath} requires piped input; use ${altLabel} for interactive use`);
   }
   try {
-    const st = fs26.statSync(filePath);
+    const st = fs27.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`);
     }
@@ -14748,7 +15200,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 fs26.readFileSync(filePath);
+    return fs27.readFileSync(filePath);
   } catch (e) {
     if (e instanceof CliError) throw e;
     mapFsError(e, filePath, void 0, label);
@@ -14792,7 +15244,7 @@ function cmdNoteAdd(file, opts) {
     throw new CliError("note content must be valid UTF-8 text");
   }
   const resolvedPath = resolveIndexPath(file);
-  if (!fs26.existsSync(resolvedPath)) {
+  if (!fs27.existsSync(resolvedPath)) {
     throw new CliError(`File not found: '${resolvedPath}'`);
   }
   healStaleIndex(resolvedPath);
@@ -15006,14 +15458,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 && !fs26.existsSync(until)) sleepSync(5);
+        while (Date.now() < deadline && !fs27.existsSync(until)) sleepSync(5);
       } else {
         sleepSync(testDelayMs);
       }
     }
     let preRenameStat;
     try {
-      preRenameStat = fs26.statSync(file);
+      preRenameStat = fs27.statSync(file);
     } catch {
     }
     if (preRenameStat !== void 0 && (preRenameStat.mtimeMs !== preWriteStat.mtimeMs || preRenameStat.size !== preWriteStat.size)) {
@@ -15054,7 +15506,7 @@ function cmdReplace(file, opts) {
   const targetBuf = readFileBoundedRaw(file, "target file", true);
   let preWriteStat;
   try {
-    preWriteStat = fs26.statSync(file);
+    preWriteStat = fs27.statSync(file);
   } catch {
   }
   const usingFrom = opts.oldFrom !== void 0 || opts.newFrom !== void 0;
@@ -15148,7 +15600,7 @@ function cmdInsertSection(file, opts) {
   }
   let preWriteStat;
   try {
-    preWriteStat = fs26.statSync(file);
+    preWriteStat = fs27.statSync(file);
   } catch {
   }
   const result = readSection(file, opts.after);
@@ -15162,7 +15614,7 @@ function cmdInsertSection(file, opts) {
   }
   let rawBytes;
   try {
-    rawBytes = fs26.readFileSync(file);
+    rawBytes = fs27.readFileSync(file);
   } catch (e) {
     mapFsError(e, void 0, file);
   }
@@ -15178,7 +15630,7 @@ function cmdInsertSection(file, opts) {
   if (preWriteStat !== void 0) {
     let preRenameStat;
     try {
-      preRenameStat = fs26.statSync(file);
+      preRenameStat = fs27.statSync(file);
     } catch {
     }
     if (preRenameStat !== void 0 && (preRenameStat.mtimeMs !== preWriteStat.mtimeMs || preRenameStat.size !== preWriteStat.size)) {
@@ -15219,25 +15671,25 @@ ${content}`;
 }
 function expandGlobs(root, patterns, globFnOverride) {
   const out2 = [];
-  const globFn = globFnOverride ?? fs26["globSync"];
+  const globFn = globFnOverride ?? fs27["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(path26.isAbsolute(h) ? h : path26.join(root, h));
+        for (const h of hits) out2.push(path27.isAbsolute(h) ? h : path27.join(root, h));
         continue;
       } catch {
       }
     }
-    out2.push(path26.isAbsolute(p) ? p : path26.join(root, p));
+    out2.push(path27.isAbsolute(p) ? p : path27.join(root, p));
   }
   return out2;
 }
 function readIgnoreFile(root) {
-  const ignorePath = path26.join(root, ".tokengoatignore");
+  const ignorePath = path27.join(root, ".tokengoatignore");
   let raw;
   try {
-    raw = fs26.readFileSync(ignorePath, "utf8");
+    raw = fs27.readFileSync(ignorePath, "utf8");
   } catch {
     return void 0;
   }
@@ -15278,14 +15730,14 @@ function cmdPack(patterns, opts) {
   }
   let instruction;
   if (opts.instructionFile !== void 0) {
-    instruction = fs26.readFileSync(opts.instructionFile, "utf8");
+    instruction = fs27.readFileSync(opts.instructionFile, "utf8");
   }
   const formatted = formatPack(result, style, {
     ...opts.lineNumbers === true ? { line_numbers: true } : {},
     ...instruction !== void 0 ? { instruction } : {}
   });
   if (opts.output !== void 0) {
-    fs26.writeFileSync(opts.output, formatted, "utf8");
+    fs27.writeFileSync(opts.output, formatted, "utf8");
   } else {
     out(formatted);
   }
@@ -15303,7 +15755,7 @@ function cmdTokens(patterns, opts) {
   if (opts.tree === true) {
     const dirs = /* @__PURE__ */ new Map();
     for (const e of entries) {
-      const dir = path26.dirname(e.rel_path);
+      const dir = path27.dirname(e.rel_path);
       if (!dirs.has(dir)) dirs.set(dir, []);
       dirs.get(dir).push(e);
     }
@@ -15313,7 +15765,7 @@ function cmdTokens(patterns, opts) {
       const pct = result.total_tokens > 0 ? Math.round(dirTokens / result.total_tokens * 100) : 0;
       lines2.push(`${dir}/ (${dirTokens} tokens, ${pct}%)`);
       for (const e of dirEntries) {
-        lines2.push(`  ${path26.basename(e.rel_path).padEnd(30)}  ${String(e.tokens).padStart(8)} tokens`);
+        lines2.push(`  ${path27.basename(e.rel_path).padEnd(30)}  ${String(e.tokens).padStart(8)} tokens`);
       }
     }
     out(lines2.join("\n"));
@@ -15344,7 +15796,7 @@ function cmdBudget(patterns, opts) {
   }
 }
 function cmdFailures(src, opts) {
-  const text = src !== void 0 ? fs26.readFileSync(src, "utf8") : fs26.readFileSync(0, "utf8");
+  const text = src !== void 0 ? fs27.readFileSync(src, "utf8") : fs27.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));
@@ -15474,39 +15926,34 @@ function buildProgram() {
     )
   );
   program2.command("semantic <query>").description("semantic search (falls back to full-text search)").option("-l, --limit <n>", "max results").option("-j, --json", "output as JSON").option("--grep <pattern>", "filter to hits whose file path matches this regex (literal substring if it is not valid regex); matched against the path as rendered").option("--exclude-tests", "hide hits whose file is a test file (opt-in; default output is unchanged)").action(guard(cmdSemantic));
-  program2.command("skeleton <file> [more...]").description('list all symbols in a file without bodies (also accepts a comma-separated file list "a,b,c" for one headed block per file)').option("-j, --json", "output as JSON").option("--min-lines <n>", "only show symbols at least N lines long").option("--grep <pattern>", "only show symbols whose name matches this regex (literal substring if it is not valid regex)").option("--force-refresh", "reparse file from disk before querying (ignore stale index)").option("--stats", "add per-symbol reference count and doc-coverage flag").action(
-    (file, more, opts) => runExitText(
-      () => noteExtraFileArgs(
-        "skeleton",
-        file,
-        more,
-        () => runSkeleton({
+  const registerSymbolListing = (name, description, run2) => {
+    program2.command(`${name} <file> [more...]`).description(description).option("-j, --json", "output as JSON").option("--min-lines <n>", "only show symbols at least N lines long").option("--grep <pattern>", "only show symbols whose name matches this regex (literal substring if it is not valid regex)").option("--force-refresh", "reparse file from disk before querying (ignore stale index)").option("--stats", "add per-symbol reference count and doc-coverage flag").action(
+      (file, more, opts) => runExitText(
+        () => noteExtraFileArgs(
+          name,
           file,
-          ...opts.json === true ? { json: true } : {},
-          ...opts.minLines !== void 0 ? { minLines: requireNonNegativeInt("--min-lines", opts.minLines) } : {},
-          ...opts.grep !== void 0 ? { grep: opts.grep } : {},
-          ...opts.forceRefresh === true ? { forceRefresh: true } : {},
-          ...opts.stats === true ? { stats: true } : {}
-        })
+          more,
+          () => run2({
+            file,
+            ...opts.json === true ? { json: true } : {},
+            ...opts.minLines !== void 0 ? { minLines: requireNonNegativeInt("--min-lines", opts.minLines) } : {},
+            ...opts.grep !== void 0 ? { grep: opts.grep } : {},
+            ...opts.forceRefresh === true ? { forceRefresh: true } : {},
+            ...opts.stats === true ? { stats: true } : {}
+          })
+        )
       )
-    )
+    );
+  };
+  registerSymbolListing(
+    "skeleton",
+    'list all symbols in a file without bodies (also accepts a comma-separated file list "a,b,c" for one headed block per file)',
+    runSkeleton
   );
-  program2.command("outline <file> [more...]").description('list symbols with line ranges and docstrings (also accepts a comma-separated file list "a,b,c" for one headed block per file)').option("-j, --json", "output as JSON").option("--min-lines <n>", "only show symbols at least N lines long").option("--grep <pattern>", "only show symbols whose name matches this regex (literal substring if it is not valid regex)").option("--force-refresh", "reparse file from disk before querying (ignore stale index)").option("--stats", "add per-symbol reference count and doc-coverage flag").action(
-    (file, more, opts) => runExitText(
-      () => noteExtraFileArgs(
-        "outline",
-        file,
-        more,
-        () => runOutline({
-          file,
-          ...opts.json === true ? { json: true } : {},
-          ...opts.minLines !== void 0 ? { minLines: requireNonNegativeInt("--min-lines", opts.minLines) } : {},
-          ...opts.grep !== void 0 ? { grep: opts.grep } : {},
-          ...opts.forceRefresh === true ? { forceRefresh: true } : {},
-          ...opts.stats === true ? { stats: true } : {}
-        })
-      )
-    )
+  registerSymbolListing(
+    "outline",
+    'list symbols with line ranges and docstrings (also accepts a comma-separated file list "a,b,c" for one headed block per file)',
+    runOutline
   );
   program2.command("refs <spec> [more...]").description("find references to one or more symbols (spec: file::symbol, symbol, or comma-separated a,b,c / file::a,b for a merged multi-symbol view; cross-file a.ts::x,b.ts::y is also supported). For an unambiguous TypeScript symbol, automatically type-resolves candidates via the TypeScript compiler API to drop same-named-different-symbol false positives; falls back to name-based matching when that is not possible.").option("--callers", "group references by their enclosing caller symbol").option("-l, --limit <n>", "max results").option(
     "--top <n>",
@@ -15548,7 +15995,7 @@ function buildProgram() {
   program2.command("context-stats").description("show context statistics").option("--project <path>", "project root to analyze").option("-j, --json", "output as JSON").option("--fix", "apply automatic fixes (confirm-gated; shows a diff before writing)").option("-y, --yes", "with --fix, apply without prompting (non-interactive / scripted use)").action(guard(cmdContextStats));
   program2.command("bootstrap-audit").description("audit Claude Code startup-context contributors without reading prompt bodies").option("--project <path>", "project root to analyze").option("--home <path>", "home directory override (for CI/testing)").option("--follow-links", "follow external symlink/junction roots and direct children").option("-j, --json", "output as JSON").option("--top <n>", "largest metadata entries to show (default 10)", "10").option("--warn-tokens <n>", "warn when total estimated startup tokens exceed n").option("--fail-tokens <n>", "fail when total estimated startup tokens exceed n").option("--warn-bytes <n>", "warn when agent/skill metadata bytes exceed n").option("--fail-bytes <n>", "fail when agent/skill metadata bytes exceed n").action(guard(cmdBootstrapAudit));
   program2.command("memory").description("analyze CLAUDE.md files for duplicate/overlapping content (--fix to apply safe mechanical fixes)").option("--project <path>", "project root to analyze").option("--analyze", "report-only analysis (default)").option("--fix", "remove exact-duplicate lines (confirm-gated; shows a diff before writing)").option("--yes", "apply --fix changes without prompting (non-interactive)").action(guard(cmdMemory));
-  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("--json", "output JSON").action(guard(cmdWaste));
+  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("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));