token-goat 2.6.36 → 2.8.1

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

@@ -2,6 +2,7 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   ALL_SYMBOLS_IN_FILE_LIMIT,
+  AMBIGUOUS_HEADING_LIMIT,
   CONTENT_MAX_INPUT_CHARS,
   WHOLE_FILE_NOTE_SYMBOL,
   compressText,
@@ -16,7 +17,7 @@ import {
   findSpecSeparator,
   getTrackedFiles,
   healStaleIndex,
-  isAvailable,
+  isAvailable as isAvailable2,
   listSections,
   load,
   loadError,
@@ -60,6 +61,7 @@ import {
   runOpenApiOutline,
   runOutline,
   runPdfExtractText,
+  runPdfLocate,
   runPdfMeta,
   runPdfOutline,
   runPrSlice,
@@ -84,17 +86,21 @@ import {
   runZipRead,
   symbolNamesInFile,
   upsertNote
-} from "./token-goat-chunk-IYTVE6KN.mjs";
+} from "./token-goat-chunk-RMDQFTQD.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 +108,12 @@ import {
   isRecallCacheType,
   listRecentRecall,
   normalizeCommandForCacheKey,
+  readCopilotMcpTools,
   readStdinJson,
   searchRecall,
-  storeWebOutput
-} from "./token-goat-chunk-VYMGEVZS.mjs";
+  storeWebOutput,
+  summarizeResidentContext
+} from "./token-goat-chunk-XEDQH5DA.mjs";
 import {
   AGENT_SALT_MARKER,
   CONTEXT_AUTOCOMPACT_TOKENS,
@@ -132,16 +140,20 @@ import {
   confirmAndApply,
   contentHash,
   copilotCliConfigPath,
+  copilotCliMcpToolsDir,
   copilotCliScriptPath,
+  copilotCliUserRoot,
   detectWalkMode,
   dirtyQueuePathFor,
   docxOutline,
   docxText,
   drainHeartbeatPathFor,
+  embeddingBackendLoadError,
   embeddingsDepsAvailable,
   emptyIndexMessage,
   enqueueDirtyPathSafe,
   estimateTokens,
+  estimateTokensFromLength,
   extractChecklistSection,
   extractCompactFromMarker,
   extractNamedSection,
@@ -182,6 +194,7 @@ import {
   installKimi,
   installSkill,
   installVscode,
+  isAvailable,
   isCodexInstalled,
   isCompactFresh,
   isCopilotCliInstalled,
@@ -243,7 +256,7 @@ import {
   vscodeDecoderConfigured,
   walkProject,
   writeCompact
-} from "./token-goat-chunk-UFOVM7ZN.mjs";
+} from "./token-goat-chunk-2G6RAB4G.mjs";
 import {
   C,
   CONFIG_KEY_ENV_OVERRIDES,
@@ -296,6 +309,7 @@ import {
   parse,
   pushAll,
   readConfigSource,
+  readUnmappedTools,
   recordStat,
   redactIfDotenv,
   redactUrlQuery,
@@ -324,7 +338,7 @@ import {
   withFileLock,
   withRetryOnLock,
   writeJsonSettings
-} from "./token-goat-chunk-V465YKOR.mjs";
+} from "./token-goat-chunk-ELDJRLHZ.mjs";
 import {
   __export
 } from "./token-goat-chunk-AEX54RUZ.mjs";
@@ -3440,9 +3454,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 +3755,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,20 +5012,42 @@ 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 VERIFICATION_RANK = {
+  dogfooded: 0,
+  sourced: 1,
+  documented: 2
+};
+var VERIFICATION_BLURB = {
+  dogfooded: "driven against the real harness binary",
+  sourced: "wire format read from the harness's own source or declarations, never driven against it",
+  documented: "wired from the harness's documentation only, never driven against it"
+};
 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 }]
+    verification: "dogfooded",
+    verificationNote: "The harness this repo is developed and released under; CLAUDE.md requires every CLI/hook change be run against the built binary here before it ships.",
+    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",
     label: "Codex CLI",
     sourceFile: "src/bridges/codex_install.ts (CODEX_HOOK_EVENTS, CODEX_GLOBAL_HOOK_EVENTS)",
+    verification: "sourced",
+    verificationNote: "Wire format pinned to Codex 0.137.0+'s declared hookSpecificOutput schema (src/bridges/codex.ts); no run against a Codex binary is recorded here.",
     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"],
@@ -5023,8 +5059,12 @@ var BRIDGE_CAPABILITY_MATRIX = [
     harness: "grok",
     label: "Grok CLI",
     sourceFile: "src/bridges/grok_install.ts (GROK_HOOK_EVENTS)",
+    verification: "dogfooded",
+    verificationNote: "grok 0.2.93, 2026-07-09: observed executing the global settings.json hooks config unmodified and setting GROK_SESSION_ID on every hook subprocess (src/bridges/registry.ts, src/hooks_cli.ts).",
     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,10 +5072,61 @@ 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",
     sourceFile: "src/bridges/copilot_cli_install.ts (COPILOT_CLI_HOOK_EVENTS), src/bridges/copilot_cli.ts (COPILOT_TO_TG_EVENT)",
+    verification: "dogfooded",
+    verificationNote: "doctor's checkCopilotCli drives the installed shim end to end, and every hook payload field is cross-checked against Copilot's own declarations pinned at 1.0.80 (schemas/copilot_cli.hooks.json).",
     implemented: /* @__PURE__ */ new Set([
       "session_start",
       "pre_tool_use",
@@ -5043,12 +5134,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"
       }
     ]
   },
@@ -5056,8 +5149,12 @@ var BRIDGE_CAPABILITY_MATRIX = [
     harness: "gemini",
     label: "Gemini CLI",
     sourceFile: "src/bridges/gemini_install.ts (GEMINI_HOOK_EVENTS)",
+    verification: "sourced",
+    verificationNote: "Verified against Gemini CLI's published hooks reference (src/bridges/gemini_install.ts); no run against a Gemini binary is recorded here.",
     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")`
@@ -5068,8 +5165,12 @@ var BRIDGE_CAPABILITY_MATRIX = [
     harness: "qwen",
     label: "Qwen Code",
     sourceFile: "src/bridges/qwen_install.ts (QWEN_HOOK_EVENTS)",
+    verification: "documented",
+    verificationNote: "Wired from QwenLM/qwen-code's hooks.md, which src/bridges/qwen_install.ts states was not live-tested against a running install.",
     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)"
@@ -5085,15 +5186,25 @@ var BRIDGE_CAPABILITY_MATRIX = [
     harness: "kimi",
     label: "Kimi Code CLI",
     sourceFile: "src/bridges/kimi_install.ts (KIMI_EVENT_ARG), src/bridges/kimi.ts (KIMI_HOOK_SCRIPT)",
+    verification: "sourced",
+    verificationNote: "Payload keys and response contract read from MoonshotAI/kimi-code's own source (externalHooksRunner/runner.ts, externalHooksService.ts); no run against a Kimi binary is recorded here.",
     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",
     label: "opencode",
     sourceFile: "src/bridges/opencode.ts",
+    verification: "sourced",
+    verificationNote: "Tool ids, parameter keys and handler behavior read directly from opencode's own source (src/bridges/opencode.ts); no run against a running gateway is recorded here.",
     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)"
@@ -5104,8 +5215,12 @@ var BRIDGE_CAPABILITY_MATRIX = [
     harness: "openclaw",
     label: "OpenClaw",
     sourceFile: "src/bridges/openclaw.ts",
+    verification: "sourced",
+    verificationNote: "Verified against the live plugin docs and OpenClaw's aristotle-agent/types.ts; the bridge's own note lists what stays unverified without a live instance (built-in tool names, session id).",
     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"
@@ -5116,8 +5231,12 @@ var BRIDGE_CAPABILITY_MATRIX = [
     harness: "pi",
     label: "pi (pi-coding-agent)",
     sourceFile: "src/bridges/pi.ts",
+    verification: "sourced",
+    verificationNote: "Response shape verified against pi's own TextContent/ImageContent types (src/bridges/pi.ts); no run against a pi binary is recorded here.",
     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()"
@@ -5137,7 +5256,15 @@ function bridgesStatusToJson(matrix = BRIDGE_CAPABILITY_MATRIX) {
         reasons[event] = reason;
       }
     }
-    return { harness: row.harness, label: row.label, sourceFile: row.sourceFile, events, reasons };
+    return {
+      harness: row.harness,
+      label: row.label,
+      sourceFile: row.sourceFile,
+      verification: row.verification,
+      verificationNote: row.verificationNote,
+      events,
+      reasons
+    };
   });
 }
 function formatBridgesStatus(matrix = BRIDGE_CAPABILITY_MATRIX) {
@@ -5148,7 +5275,8 @@ function formatBridgesStatus(matrix = BRIDGE_CAPABILITY_MATRIX) {
   lines.push("Read-only static analysis of src/bridges/*_install.ts and *.ts -- never invokes a real harness binary.");
   lines.push("");
   const harnessWidth = Math.max(...matrix.map((r) => r.harness.length), "harness".length);
-  const header = ["harness".padEnd(harnessWidth), ...HOOK_EVENTS.map((e) => e), "score"].join("  ");
+  const verifyWidth = Math.max(...matrix.map((r) => r.verification.length), "verified".length);
+  const header = ["harness".padEnd(harnessWidth), ...HOOK_EVENTS.map((e) => e), "score", "verified".padEnd(verifyWidth)].join("  ");
   lines.push(header);
   for (const row of matrix) {
     const cells = HOOK_EVENTS.map((event) => {
@@ -5156,7 +5284,16 @@ function formatBridgesStatus(matrix = BRIDGE_CAPABILITY_MATRIX) {
       return cell.padEnd(event.length);
     });
     const score = `${row.implemented.size}/${HOOK_EVENTS.length}`;
-    lines.push([row.harness.padEnd(harnessWidth), ...cells, score].join("  "));
+    lines.push([row.harness.padEnd(harnessWidth), ...cells, score, row.verification.padEnd(verifyWidth)].join("  "));
+  }
+  lines.push("");
+  lines.push("## How each row was established");
+  for (const level of Object.keys(VERIFICATION_RANK)) {
+    lines.push(`- ${level}: ${VERIFICATION_BLURB[level]}`);
+  }
+  lines.push("");
+  for (const row of [...matrix].sort((a, b) => VERIFICATION_RANK[a.verification] - VERIFICATION_RANK[b.verification])) {
+    lines.push(`- ${row.harness} (${row.verification}): ${row.verificationNote}`);
   }
   const gapRows = matrix.filter((r) => r.reasons.length > 0);
   if (gapRows.length > 0) {
@@ -5170,6 +5307,11 @@ function formatBridgesStatus(matrix = BRIDGE_CAPABILITY_MATRIX) {
   }
   return lines.join("\n");
 }
+function installVerificationNotice(harness) {
+  const row = BRIDGE_CAPABILITY_MATRIX.find((r) => r.harness === harness);
+  if (row === void 0 || row.verification === "dogfooded") return null;
+  return `NOTE: the ${row.label} bridge is ${row.verification} -- ${VERIFICATION_BLURB[row.verification]}. If a token-goat feature seems to do nothing here, run \`token-goat doctor\` (its "Tool names" check reports what ${row.label} actually sent) and please open an issue. Details: token-goat bridges-status.`;
+}
 
 // src/sharepoint_resolve.ts
 import * as fs8 from "node:fs";
@@ -5484,7 +5626,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 +5647,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");
 }
@@ -5587,6 +5729,7 @@ function runStats(opts = {}) {
       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");
@@ -5681,7 +5824,9 @@ function checkMcpProcessHealth(processes) {
   const nodeProcesses = processes.filter((process3) => process3.name.toLowerCase() === "node.exe");
   const chromeLaunchers = nodeProcesses.filter((process3) => /npx-cli\.js.*chrome-devtools-mcp/i.test(process3.commandLine));
   const playwrightLaunchers = nodeProcesses.filter((process3) => /npx-cli\.js.*@playwright[\\/]mcp/i.test(process3.commandLine));
-  const orphanedNodeProcesses = nodeProcesses.filter((process3) => !byPid.has(process3.parentProcessId));
+  const orphanedNodeProcesses = nodeProcesses.filter(
+    (process3) => !byPid.has(process3.parentProcessId) && !/--worker-daemon\b/.test(process3.commandLine)
+  );
   const launchers = chromeLaunchers.length + playwrightLaunchers.length;
   if (launchers > 2 || orphanedNodeProcesses.length > 0) {
     const details = [];
@@ -5856,7 +6001,7 @@ function checkInstall() {
   }
 }
 function checkTsCompiler() {
-  if (isAvailable()) {
+  if (isAvailable2()) {
     return { name: "TypeScript compiler", status: "ok", message: "available" };
   }
   const err2 = loadError();
@@ -5866,6 +6011,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 +6230,78 @@ 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)}` };
+  }
+}
+var UNMAPPED_TOOL_SAMPLE = 5;
+function checkUnmappedTools(dbPath) {
+  const name = "Tool names";
+  if (!fs12.existsSync(dbPath)) {
+    return { name, status: "ok", message: "no database yet" };
+  }
+  try {
+    const rows = readUnmappedTools(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);
+    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)` : "";
+      return {
+        name,
+        status: "warn",
+        message: `${shown2.join("; ")}${more2} -- these differ only by case or separators, so that bridge's tool-rename step is very likely not being applied and every handler behind those names is inert`
+      };
+    }
+    const shown = rows.slice(0, UNMAPPED_TOOL_SAMPLE).map((r) => `${r.tool_name} (${r.hits}x)`);
+    const more = rows.length > UNMAPPED_TOOL_SAMPLE ? `, +${rows.length - UNMAPPED_TOOL_SAMPLE} more` : "";
+    return {
+      name,
+      status: "ok",
+      message: `${rows.length} tool name(s) seen with no handler, none resembling one token-goat handles: ${shown.join(", ")}${more}`
+    };
+  } catch (e) {
+    return { name, status: "warn", message: `could not read the tool-name histogram: ${extractErrorMessage(e)}` };
+  }
+}
 function runDoctor(dataDir2, configPath2, rootDir, processes) {
   const results = [];
   const actualDataDir = dataDir2 || dataDir();
@@ -6075,8 +6313,11 @@ 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")));
+  results.push(checkUnmappedTools(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());
@@ -8969,6 +9210,10 @@ var GO_FAIL = /^--- FAIL:\s+(\S+)/;
 var CARGO_FAIL = /^test (\S+) \.\.\. FAILED/;
 var CARGO_SECTION = /^---- (\S+) (?:stdout|stderr) ----$/;
 var CARGO_RESULT = /^test result:/;
+var VITEST_FAIL_HEADER = /^\s+FAIL\s+(.+?)\s*$/;
+var VITEST_BANNER = /⎯+\s*Failed Tests\s+\d+\s*⎯+/;
+var VITEST_SEPARATOR = /^⎯+.*⎯+$/;
+var VITEST_SUMMARY = /^\s*(Test Files|Tests|Start at|Duration)\s/;
 function detectRunner(text) {
   if (text.includes("=== FAILURES ===") || text.includes("=== ERRORS ===")) {
     return "pytest";
@@ -8976,6 +9221,9 @@ function detectRunner(text) {
   if (/\bFAILED\b.+::test_/.test(text) || /short test summary/i.test(text)) {
     return "pytest";
   }
+  if (VITEST_BANNER.test(text) || /^\s*Test Files\s+/m.test(text) && /^\s*Tests\s+\d+\s+(failed|passed)/m.test(text)) {
+    return "vitest";
+  }
   if (/^\s+●\s/m.test(text) || /^FAIL\s+\S+\.test\b/m.test(text)) {
     return "jest";
   }
@@ -9100,6 +9348,44 @@ function extractJest(lines) {
   }
   return result;
 }
+function extractVitest(lines) {
+  const result = { runner: "vitest", blocks: [], summaryLines: [], statsLine: "" };
+  let inBlock = false;
+  let currentName = "";
+  let currentBody = [];
+  const flush = () => {
+    if (inBlock && currentName) result.blocks.push({ name: currentName, body: currentBody.join("\n").trimEnd() });
+    inBlock = false;
+    currentName = "";
+    currentBody = [];
+  };
+  for (const line of lines) {
+    const s = line.trimEnd();
+    const header = VITEST_FAIL_HEADER.exec(s);
+    if (header) {
+      flush();
+      currentName = header[1] ?? "";
+      currentBody = [];
+      inBlock = true;
+      result.summaryLines.push(currentName);
+      continue;
+    }
+    if (VITEST_SUMMARY.test(s)) {
+      if (/^\s*Tests\s/.test(s)) result.statsLine = s.trim();
+      flush();
+      continue;
+    }
+    if (inBlock) {
+      if (VITEST_SEPARATOR.test(s)) {
+        flush();
+        continue;
+      }
+      currentBody.push(s);
+    }
+  }
+  flush();
+  return result;
+}
 function extractGo(lines) {
   const result = {
     runner: "go",
@@ -9222,6 +9508,9 @@ function extractFailures(text, options) {
   if (detected === "pytest") {
     return extractPytest(lines);
   }
+  if (detected === "vitest") {
+    return extractVitest(lines);
+  }
   if (detected === "jest") {
     return extractJest(lines);
   }
@@ -12408,8 +12697,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 +12783,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 +12796,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 +12836,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 +12942,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 +13238,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 +13316,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 +13332,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 +13400,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 +13498,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 +13812,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 +13952,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 +13978,7 @@ async function cmdIndex(pathArg, opts = {}) {
         }
         continue;
       }
-      if (!fs26.existsSync(key)) continue;
+      if (!fs27.existsSync(key)) continue;
     }
     if (!embedUnchanged) {
       paintProgress("embedding");
@@ -13447,11 +14038,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-73MF6YWW.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 +14052,18 @@ async function cmdMcpServe() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
   await new Promise((resolve12) => {
-    server.server.onclose = resolve12;
+    server.onclose = resolve12;
   });
 }
+function printBridgeVerificationNotice(harness) {
+  const notice = installVerificationNotice(harness);
+  if (notice !== null) out(notice);
+}
 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-YUGNM3KL.mjs");
   await relay(event);
 }
 async function cmdInstall(opts) {
@@ -13495,6 +14090,7 @@ async function cmdInstall(opts) {
     } else {
       out(`Installed token-goat Codex CLI integration \u2192 ${codexResult.configPath}, ${codexResult.agentsPath}`);
     }
+    printBridgeVerificationNotice("codex");
   }
   if (opts.gemini === true) {
     const geminiResult = installGemini();
@@ -13503,6 +14099,7 @@ async function cmdInstall(opts) {
     } else {
       out(`Installed token-goat Gemini CLI integration \u2192 ${geminiResult.settingsPath}`);
     }
+    printBridgeVerificationNotice("gemini");
   }
   if (opts.qwen === true) {
     const qwenResult = installQwen();
@@ -13511,6 +14108,7 @@ async function cmdInstall(opts) {
     } else {
       out(`Installed token-goat Qwen Code integration \u2192 ${qwenResult.settingsPath}`);
     }
+    printBridgeVerificationNotice("qwen");
   }
   if (opts.kimi === true) {
     const kimiResult = installKimi();
@@ -13519,6 +14117,7 @@ async function cmdInstall(opts) {
     } else {
       out(`Installed token-goat Kimi Code integration \u2192 ${kimiResult.configPath}, ${kimiResult.hookScriptPath}, ${kimiResult.agentsPath}, ${kimiResult.skillPath}`);
     }
+    printBridgeVerificationNotice("kimi");
   }
   if (opts.pi === true) {
     const piResult = installPi({ local: opts.local === true });
@@ -13527,6 +14126,7 @@ async function cmdInstall(opts) {
     } else {
       out(`Installed token-goat pi extension \u2192 ${piResult.extensionPath}`);
     }
+    printBridgeVerificationNotice("pi");
   }
   if (opts.openclaw === true) {
     const openclawResult = installOpenclaw();
@@ -13535,6 +14135,7 @@ async function cmdInstall(opts) {
     } else {
       out(`Installed token-goat OpenClaw integration \u2192 ${openclawResult.configPath}, ${openclawResult.pluginPath}`);
     }
+    printBridgeVerificationNotice("openclaw");
   }
   if (opts.copilot === true) {
     const copilotResult = installCopilotCli({ local: opts.local === true });
@@ -13543,6 +14144,7 @@ async function cmdInstall(opts) {
     } else {
       out(`Installed token-goat Copilot CLI integration \u2192 ${copilotResult.configPath}, ${copilotResult.scriptPath}, ${copilotResult.instructionsPath}`);
     }
+    printBridgeVerificationNotice("copilot_cli");
   }
   if (opts.opencode === true) {
     const opencodeResult = installOpencode();
@@ -13551,6 +14153,7 @@ async function cmdInstall(opts) {
     } else {
       out(`Installed token-goat opencode plugin \u2192 ${opencodeResult.pluginPath}`);
     }
+    printBridgeVerificationNotice("opencode");
   }
   if (opts.grok === true) {
     const grokResult = installGrok();
@@ -13559,6 +14162,7 @@ async function cmdInstall(opts) {
     } else {
       out(`Installed token-goat Grok CLI integration \u2192 ${grokResult.configPath}, ${grokResult.hookScriptPath}`);
     }
+    printBridgeVerificationNotice("grok");
   }
   if (opts.vscode === true) {
     const vscodeResult = installVscode({ project: opts.project === true });
@@ -13572,16 +14176,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 +14195,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 +14286,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 +14372,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 +14393,7 @@ ${formatSessionOutline(turns)}`;
 }
 function sessionTranscriptSize(transcriptPath) {
   try {
-    return fs26.statSync(transcriptPath).size;
+    return fs27.statSync(transcriptPath).size;
   } catch {
     return 0;
   }
@@ -13892,10 +14497,11 @@ function _applyFiltersAndPrint(content, opts, fenceUntrusted = false, fenceTag =
       content = [...matched.slice(0, cap), "[token-goat: showing first " + cap + " of " + matched.length + " matching lines; raise --max-matches for more]"].join("\n");
     }
   }
-  const lines = content.split(/\r?\n/);
+  const rawLines = content.split(/\r?\n/);
   if (opts.full === true) {
-    return emit2(lines.join("\n"));
+    return emit2(rawLines.join("\n"));
   }
+  const lines = rawLines.length > 1 && rawLines[rawLines.length - 1] === "" ? rawLines.slice(0, -1) : rawLines;
   const headN = opts.head !== void 0 ? requireNonNegativeInt("--head", opts.head) : 30;
   const tailN = opts.tail !== void 0 ? requireNonNegativeInt("--tail", opts.tail) : 80;
   const applyElision = (lines2, headN2, tailN2) => lines2.length > headN2 + tailN2 + 1 ? [...lines2.slice(0, headN2), "...(elided)...", ...lines2.slice(lines2.length - tailN2)] : lines2;
@@ -13913,7 +14519,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 +14534,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}`);
@@ -13979,6 +14585,33 @@ async function cmdPdfExtract(file, opts) {
   const bytesSaved = Math.max(1, fullSourceBytes - Buffer.byteLength(printed, "utf8"));
   recordStat("pdf_extract", bytesSaved, Math.round(bytesSaved / 4));
 }
+async function cmdPdfLocate(file, pattern, opts) {
+  const locateOpts = {
+    ignoreCase: opts.ignoreCase === true
+  };
+  if (opts.maxMatches !== void 0) locateOpts.maxMatches = requirePositiveInt("--max-matches", opts.maxMatches);
+  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);
+  let printed;
+  if (opts.json === true) {
+    printed = JSON.stringify({ file, pattern, matchCount: matches2.length, pages, matches: matches2 }, null, 2);
+    out(printed);
+  } else if (matches2.length === 0) {
+    printed = "(no matches)";
+    out(printed);
+  } else {
+    const lines = matches2.map((m) => `p${m.page}: ${m.snippet}`);
+    printed = `${lines.join("\n")}
+
+${countNoun(matches2.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));
+}
 async function cmdPdfOutline(file, opts) {
   const entries = await runPdfOutline(file);
   if (entries.length === 0) {
@@ -14325,7 +14958,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-I6TOUPLP.mjs");
     if (opts.compress === false) {
       process.exitCode = bashRunner.runRaw(opts.cmd, parseTimeout(opts.timeout, bashRunner.DEFAULT_TIMEOUT_SECONDS));
       return;
@@ -14351,7 +14984,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 +15001,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 +15022,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 +15043,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 +15175,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,17 +15205,22 @@ 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;
-    return;
+    const messages = [`Section '${heading}' not found in skill '${skillName}'`];
+    const allHeadings = listSections(filePath);
+    const available = filterSimilarHeadings(allHeadings, heading);
+    if (available.length > 0) messages.push(didYouMean(available));
+    else if (allHeadings.length === 0) messages.push(`skill '${skillName}' has no headings`);
+    else messages.push(`Try: token-goat outline ${filePath}`);
+    throw new CliError(messages.join("\n"));
   }
   out(extracted);
 }
 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 +15228,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 +15256,7 @@ function atomicWriteBuffer(dest, data) {
     });
   } catch (e) {
     try {
-      fs26.unlinkSync(tmp);
+      fs27.unlinkSync(tmp);
     } catch {
     }
     throw e;
@@ -14628,9 +15266,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);
-    if (isSource) throw new CliError(`${srcLabel} file not found: ${src}`);
-    const destDir = dest ? path26.dirname(path26.resolve(dest)) : path26.dirname(path26.resolve(errPath || "."));
+    const isSource = src !== void 0 && path27.resolve(errPath) === path27.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 || "."));
     throw new CliError(`destination directory does not exist: ${destDir}`);
   }
   if (fe.code === "ENOTDIR") {
@@ -14641,7 +15279,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 +15348,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 +15378,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 +15386,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 +15430,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 +15644,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 +15692,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 +15786,7 @@ function cmdInsertSection(file, opts) {
   }
   let preWriteStat;
   try {
-    preWriteStat = fs26.statSync(file);
+    preWriteStat = fs27.statSync(file);
   } catch {
   }
   const result = readSection(file, opts.after);
@@ -15160,9 +15798,21 @@ function cmdInsertSection(file, opts) {
     else if (allHeadings.length > 0) messages.push(`Try: token-goat outline ${file}`);
     throw new CliError(messages.join("\n"));
   }
+  if (result.occurrences !== void 0) {
+    const lines = [
+      `Ambiguous heading '${opts.after}' in '${file}': ${countNoun(result.occurrences.length, "heading")} match. Retry with one of the qualified forms below to pick one:`
+    ];
+    for (const [i, line] of result.occurrences.slice(0, AMBIGUOUS_HEADING_LIMIT).entries()) {
+      lines.push(`  - line ${line}  ->  --after "${opts.after}#${i + 1}"`);
+    }
+    if (result.occurrences.length > AMBIGUOUS_HEADING_LIMIT) {
+      lines.push(`  (${result.occurrences.length - AMBIGUOUS_HEADING_LIMIT} more not shown)`);
+    }
+    throw new CliError(lines.join("\n"));
+  }
   let rawBytes;
   try {
-    rawBytes = fs26.readFileSync(file);
+    rawBytes = fs27.readFileSync(file);
   } catch (e) {
     mapFsError(e, void 0, file);
   }
@@ -15178,7 +15828,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 +15869,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 +15928,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 +15953,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 +15963,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 +15994,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 +16124,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 +16193,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));
@@ -15819,6 +16464,9 @@ function buildProgram() {
   );
   program2.command("config-get <file> <key>").description("read one value from a config file (TOML/JSON/YAML/INI)").action((file, key) => runExit(() => runConfigGet({ file, key })));
   program2.command("pdf-extract <file>").description("extract plain text from a PDF (optionally --pages N or N-M) instead of a raw Read").option("--pages <spec>", "page range to extract, e.g. 1-5 or 3 (default: all pages)").option("--layout", "heuristic column-aware reading-order reconstruction from text-item coordinates (imperfect on rotated/overlapping text)").option("--head <n>", "show only the first N lines").option("--tail <n>", "show only the last N lines").option("--grep <pattern>", "filter to lines matching this regex").option("--section <heading>", "extract one markdown section by heading").option("--max-matches <n>", "cap the number of --grep matches shown").action(guard(cmdPdfExtract));
+  program2.command("pdf-locate <file> <pattern>").description(
+    "find which pages of a PDF match a regex, with a snippet per match, so you can pdf-extract only those pages instead of the whole document"
+  ).option("-i, --ignore-case", "case-insensitive matching").option("--max-matches <n>", "stop after this many page matches (default: 50)").option("--context <n>", "snippet length in characters around each match (default: 80)").option("--pages <spec>", "page range to scan, e.g. 1-5 or 3 (default: all pages)").option("-j, --json", "output as JSON").action(guard(cmdPdfLocate));
   program2.command("pdf-outline <file>").description("list a PDF's bookmark/outline tree with page numbers instead of a raw Read").option("-j, --json", "output as JSON").action(guard(cmdPdfOutline));
   program2.command("pdf-meta <file>").description("page count, title/author, and whether a PDF has an extractable text layer").option("-j, --json", "output as JSON").action(guard(cmdPdfMeta));
   program2.command("image-meta <file>").description("dimensions, byte size, format, and what a shrink would cost -- sharp metadata only, never runs OCR").option("-j, --json", "output as JSON").action(guard(cmdImageMeta));