token-goat 2.9.29 → 2.9.31

package/dist/token-goat-chunk-D735C4QM.mjs

@@ -0,0 +1,603 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  buildProjectMap,
+  formatProjectMap
+} from "./token-goat-chunk-ZNMNUPAZ.mjs";
+import {
+  mcpHash,
+  mcpOutputId,
+  storeMcpOutput
+} from "./token-goat-chunk-Z7N5OMMP.mjs";
+import {
+  isRewriteWorthwhile,
+  resolveMinNetSavingsBytes
+} from "./token-goat-chunk-INNPTRUX.mjs";
+import {
+  agentTypeOf,
+  permissionNeutralRewrite
+} from "./token-goat-chunk-QH7YVYOY.mjs";
+import "./token-goat-chunk-NOSS5VWY.mjs";
+import "./token-goat-chunk-NMD42SFQ.mjs";
+import "./token-goat-chunk-SAMFDIS2.mjs";
+import "./token-goat-chunk-4SMRO4TO.mjs";
+import "./token-goat-chunk-WBA5SKT4.mjs";
+import "./token-goat-chunk-MNWKPRAL.mjs";
+import "./token-goat-chunk-CIMQ2BB3.mjs";
+import "./token-goat-chunk-WDH44VAU.mjs";
+import {
+  claudeConfigDir
+} from "./token-goat-chunk-BPGCUMR7.mjs";
+import {
+  getBashOutput
+} from "./token-goat-chunk-KQBLRPBN.mjs";
+import "./token-goat-chunk-4ZBFWLXF.mjs";
+import "./token-goat-chunk-C75NA7PL.mjs";
+import "./token-goat-chunk-P6VGNTQT.mjs";
+import {
+  contextOutput,
+  denyOutput,
+  dropsResultRewrite,
+  emitRewrite,
+  extractToolResultText,
+  getCwd,
+  passOutput
+} from "./token-goat-chunk-76FGDLRO.mjs";
+import {
+  getOutstandingAgentSpawns,
+  getSessionBashOutputs,
+  markHintShown,
+  recordOutstandingAgentSpawn,
+  removeOutstandingAgentSpawn,
+  wasHintShown
+} from "./token-goat-chunk-GL3ETKSC.mjs";
+import "./token-goat-chunk-OXFMP75N.mjs";
+import "./token-goat-chunk-NISNMD7T.mjs";
+import "./token-goat-chunk-EVMZJ27Z.mjs";
+import "./token-goat-chunk-IK2DRMFX.mjs";
+import "./token-goat-chunk-5Y6ZYL6U.mjs";
+import {
+  recordStat,
+  savedTokensFromBytes
+} from "./token-goat-chunk-U4WHMG6Y.mjs";
+import "./token-goat-chunk-GVB2MUST.mjs";
+import "./token-goat-chunk-XB5KKOCG.mjs";
+import "./token-goat-chunk-OUKDTVNU.mjs";
+import "./token-goat-chunk-3BTK54F3.mjs";
+import "./token-goat-chunk-4GILLLWY.mjs";
+import {
+  estimateTokens,
+  sliceToEstimatedTokens
+} from "./token-goat-chunk-BFCWY73P.mjs";
+import "./token-goat-chunk-KGEFFSHD.mjs";
+import "./token-goat-chunk-XX6O25RN.mjs";
+import "./token-goat-chunk-HAVAOB3S.mjs";
+import "./token-goat-chunk-F6PAUIEK.mjs";
+import "./token-goat-chunk-65N4RHP4.mjs";
+import "./token-goat-chunk-X2SUP3EI.mjs";
+import {
+  redactSecrets
+} from "./token-goat-chunk-T5P5ACNQ.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import {
+  getHarnessName
+} from "./token-goat-chunk-QYHO5CPH.mjs";
+import "./token-goat-chunk-4GBVPH3D.mjs";
+import "./token-goat-chunk-YZAAZU2S.mjs";
+import "./token-goat-chunk-IVE6U7KV.mjs";
+import "./token-goat-chunk-Y4AFKTHK.mjs";
+import {
+  toKB
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  echoedValue
+} from "./token-goat-chunk-GGGG7RWB.mjs";
+import {
+  isInsideRoot
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  neutralizeSpokenMarkers
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/hooks_agent_spawn.ts
+init_define_import_meta_env();
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+var loadAgentReceipt = () => import("./token-goat-chunk-CETM74KC.mjs");
+var BRIEFING_TARGET_TOKENS = 550;
+var CACHED_IDS_LISTED = 3;
+var CACHED_COMMAND_PREVIEW_CHARS = 60;
+function describeCachedOutput(entry) {
+  const ageMin = Math.max(0, Math.round((Date.now() - entry.storedAt) / 6e4));
+  const age = ageMin < 60 ? `${ageMin}m` : ageMin < 60 * 48 ? `${Math.round(ageMin / 60)}h` : `${Math.round(ageMin / 1440)}d`;
+  const flat = neutralizeSpokenMarkers(entry.command.replace(/\s+/g, " ").trim());
+  const preview = flat.length > CACHED_COMMAND_PREVIEW_CHARS ? flat.slice(0, CACHED_COMMAND_PREVIEW_CHARS) + "..." : flat;
+  return ` (~${toKB(entry.output.length)}KB, ${age} ago, ${"`"}${preview.replace(/`/g, "'")}${"`"})`;
+}
+function buildSubagentBriefing(projectRoot) {
+  try {
+    const head = [];
+    head.push("");
+    head.push("## Session briefing (for context)");
+    try {
+      if (projectRoot === null) throw new Error("no project root");
+      const map = buildProjectMap(projectRoot, { compact: true });
+      const mapText = formatProjectMap(map, map.compact);
+      head.push(mapText);
+    } catch {
+    }
+    let cacheIdsBlock = "";
+    try {
+      const outputs = getSessionBashOutputs();
+      if (outputs.length > 0) {
+        const live = [];
+        for (const [, id] of [...outputs].reverse()) {
+          const entry = getBashOutput(id);
+          if (entry === null) continue;
+          live.push("`token-goat bash-output " + id + "`" + describeCachedOutput(entry));
+          if (live.length === CACHED_IDS_LISTED) break;
+        }
+        if (live.length > 0) cacheIdsBlock = "\n\nCached outputs this session: " + live.join(", ");
+      }
+    } catch {
+    }
+    const tail = [];
+    tail.push("");
+    tail.push('Before your first read of any file, check for a token-goat command that returns just what you need and run it instead of a full-file read or wide grep: `token-goat symbol <name>`, `token-goat read "file::symbol"`, `token-goat section "file::<heading>"`, `token-goat json-query file \'a.b.c\'`. Skipping that check is a violation, not an oversight; the only exemptions are a file under ~200 lines you need whole, a never-indexed file, or an image.');
+    tail.push("");
+    tail.push('Report contract: cite evidence as `file::symbol` or a token-goat recall id (`token-goat mcp-output <id> --full`) rather than pasting bodies; paste a fenced block only when the exact bytes are load-bearing; state every unverified claim explicitly (e.g. "not verified: ...") rather than omitting it.');
+    const withCacheIds = head.join("\n") + cacheIdsBlock + "\n" + tail.join("\n");
+    if (estimateTokens(withCacheIds) <= BRIEFING_TARGET_TOKENS) {
+      return withCacheIds;
+    }
+    const withoutCacheIds = head.join("\n") + "\n" + tail.join("\n");
+    const tokens = estimateTokens(withoutCacheIds);
+    if (tokens <= BRIEFING_TARGET_TOKENS) {
+      return withoutCacheIds;
+    }
+    return sliceToEstimatedTokens(withoutCacheIds, BRIEFING_TARGET_TOKENS);
+  } catch {
+    return "";
+  }
+}
+var DUPLICATE_PROMPT_JACCARD_THRESHOLD = 0.75;
+function promptWordSet(text) {
+  const words = text.toLowerCase().replace(/[^\p{L}\p{N}\s]+/gu, " ").split(/\s+/).filter((w) => w.length > 0);
+  return new Set(words);
+}
+function jaccardSimilarity(a, b) {
+  if (a.size === 0 || b.size === 0) return 0;
+  let intersection = 0;
+  for (const word of a) {
+    if (b.has(word)) intersection++;
+  }
+  const union = a.size + b.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+function findDuplicateOutstandingPrompt(prompt) {
+  const words = promptWordSet(prompt);
+  for (const entry of getOutstandingAgentSpawns()) {
+    if (jaccardSimilarity(words, promptWordSet(entry.prompt)) >= DUPLICATE_PROMPT_JACCARD_THRESHOLD) {
+      return entry.prompt;
+    }
+  }
+  return null;
+}
+function truncateForWarning(text, max) {
+  return text.length > max ? text.slice(0, max) + "..." : text;
+}
+function briefingRoot(event) {
+  if (getHarnessName() === "vscode") return getCwd(event) ?? null;
+  return process.cwd();
+}
+function subagentStartWired() {
+  const harness = getHarnessName();
+  const dirVar = harness === "copilot_cli" ? "TOKEN_GOAT_COPILOT_HOOKS_DIR" : harness === "vscode" ? "TOKEN_GOAT_VSCODE_HOOKS_DIR" : void 0;
+  const dir = dirVar === void 0 ? void 0 : process.env[dirVar];
+  if (dir === void 0 || dir === "") return false;
+  try {
+    const config = JSON.parse(fs.readFileSync(path.join(dir, "token-goat.json"), "utf8"));
+    const entries = config.hooks?.[harness === "vscode" ? "SubagentStart" : "subagentStart"];
+    return Array.isArray(entries) && entries.length > 0;
+  } catch {
+    return false;
+  }
+}
+function subagentStartHandler(event) {
+  try {
+    const root = getCwd(event) ?? (getHarnessName() === "vscode" ? null : process.cwd());
+    const briefing = buildSubagentBriefing(root).trim();
+    return briefing ? contextOutput(briefing) : passOutput();
+  } catch {
+    return passOutput();
+  }
+}
+var SPAWN_TOOL_BRIEF_FIELD = { Agent: "prompt", task: "prompt", Task: "prompt", spawn_agent: "message" };
+function isAgentTool(toolName) {
+  return toolName !== void 0 && Object.hasOwn(SPAWN_TOOL_BRIEF_FIELD, toolName);
+}
+function readSpawnBrief(toolName, toolInput) {
+  const field = SPAWN_TOOL_BRIEF_FIELD[toolName ?? ""];
+  if (field === void 0) return null;
+  const written = toolInput[field];
+  if (typeof written === "string" && written.trim()) return { text: written, withSuffix: (suffix) => ({ ...toolInput, [field]: written + suffix }) };
+  const items = toolInput["items"];
+  if (toolName !== "spawn_agent" || !Array.isArray(items)) return null;
+  const joined = items.flatMap((item) => item?.type === "text" && typeof item.text === "string" ? [item.text] : []).join(" ");
+  if (!joined.trim()) return null;
+  return { text: joined, withSuffix: (suffix) => ({ ...toolInput, items: [...items, { type: "text", text: suffix }] }) };
+}
+function preAgentHandler(event) {
+  if (!isAgentTool(event.toolName)) return passOutput();
+  const toolInput = event.toolInput;
+  const brief = readSpawnBrief(event.toolName, toolInput);
+  if (brief === null) return passOutput();
+  const prompt = brief.text;
+  try {
+    const scopedDeny = buildScopedSpawnDeny(toolInput);
+    if (scopedDeny) return scopedDeny;
+    const duplicateOf = findDuplicateOutstandingPrompt(prompt);
+    recordOutstandingAgentSpawn(prompt);
+    const briefing = subagentStartWired() ? "" : buildSubagentBriefing(briefingRoot(event));
+    const advisory = duplicateOf ? `
+
+&#91;token-goat] A similar subagent spawn already appears to be outstanding this session (prompt starts: ${echoedValue(neutralizeSpokenMarkers(truncateForWarning(duplicateOf, 80)))}). This is advisory only -- proceeding is fine if intentional.` : "";
+    if (!briefing && !advisory) return passOutput();
+    const updatedPrompt = prompt + briefing + advisory;
+    const updatedInput = brief.withSuffix(briefing + advisory);
+    return permissionNeutralRewrite(updatedInput, { kind: "agent", harness: getHarnessName(), mode: event.raw["permission_mode"], cwd: getCwd(event) ?? process.cwd(), original: prompt, rewritten: updatedPrompt, agentType: agentTypeOf(event.raw) }) ?? passOutput();
+  } catch {
+    return passOutput();
+  }
+}
+var FENCE_LINE_RE = /^ {0,3}(`{3,}|~{3,})([^\n]*)$/;
+function findFencedBlockLines(lines) {
+  const blocks = [];
+  let fenceStart = -1;
+  let openMarker = "";
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const match = FENCE_LINE_RE.exec(line);
+    if (fenceStart === -1) {
+      if (match !== null) {
+        fenceStart = i;
+        openMarker = match[1];
+      }
+      continue;
+    }
+    const isCloser = match !== null && match[1][0] === openMarker[0] && match[1].length >= openMarker.length && match[2].trim() === "";
+    if (!isCloser) continue;
+    blocks.push({ fenceStart, closerIndex: i });
+    fenceStart = -1;
+  }
+  return blocks;
+}
+function collapseFencedBlocks(text, recallHint, minLines, keepLines) {
+  const lines = text.split("\n");
+  const blocks = findFencedBlockLines(lines);
+  const out = [];
+  let cursor = 0;
+  for (const { fenceStart, closerIndex } of blocks) {
+    out.push(...lines.slice(cursor, fenceStart));
+    const bodyLines = closerIndex - fenceStart - 1;
+    if (bodyLines > minLines) {
+      out.push(...lines.slice(fenceStart, fenceStart + 1 + keepLines));
+      out.push(`[token-goat: ${bodyLines - keepLines * 2} lines elided -- full report via ${recallHint}]`);
+      out.push(...lines.slice(closerIndex - keepLines, closerIndex + 1));
+    } else {
+      out.push(...lines.slice(fenceStart, closerIndex + 1));
+    }
+    cursor = closerIndex + 1;
+  }
+  out.push(...lines.slice(cursor));
+  return out.join("\n");
+}
+function dedupeFencedBlocks(collapsed, original, recallHint) {
+  const originalLines = original.split("\n");
+  const originalBlocks = findFencedBlockLines(originalLines);
+  if (originalBlocks.length < 2) return collapsed;
+  const collapsedLines = collapsed.split("\n");
+  const collapsedBlocks = findFencedBlockLines(collapsedLines);
+  if (collapsedBlocks.length !== originalBlocks.length) return collapsed;
+  const bodyHashes = originalBlocks.map(
+    ({ fenceStart, closerIndex }) => createHash("sha256").update(originalLines.slice(fenceStart + 1, closerIndex).join("\n")).digest("hex")
+  );
+  const firstOccurrenceOf = /* @__PURE__ */ new Map();
+  const out = [];
+  let cursor = 0;
+  let dedupedAny = false;
+  for (let i = 0; i < collapsedBlocks.length; i++) {
+    const { fenceStart, closerIndex } = collapsedBlocks[i];
+    const hash = bodyHashes[i];
+    if (!firstOccurrenceOf.has(hash)) {
+      firstOccurrenceOf.set(hash, i);
+      out.push(...collapsedLines.slice(cursor, closerIndex + 1));
+    } else {
+      out.push(...collapsedLines.slice(cursor, fenceStart));
+      out.push(`[token-goat: identical bytes to an earlier block in this report -- full report via ${recallHint}]`);
+      dedupedAny = true;
+    }
+    cursor = closerIndex + 1;
+  }
+  out.push(...collapsedLines.slice(cursor));
+  return dedupedAny ? out.join("\n") : collapsed;
+}
+var BLANK_RUN_KEEP = 2;
+function collapseBlankRunsInFences(text) {
+  const lines = text.split("\n");
+  const blocks = findFencedBlockLines(lines);
+  if (blocks.length === 0) return text;
+  const out = [];
+  let cursor = 0;
+  let changedAny = false;
+  for (const { fenceStart, closerIndex } of blocks) {
+    out.push(...lines.slice(cursor, fenceStart + 1));
+    let blankRun = 0;
+    for (let i = fenceStart + 1; i < closerIndex; i++) {
+      const line = lines[i];
+      if (line === "") {
+        blankRun++;
+        if (blankRun <= BLANK_RUN_KEEP) out.push(line);
+        else changedAny = true;
+      } else {
+        blankRun = 0;
+        out.push(line);
+      }
+    }
+    out.push(lines[closerIndex]);
+    cursor = closerIndex + 1;
+  }
+  out.push(...lines.slice(cursor));
+  return changedAny ? out.join("\n") : text;
+}
+var SPAWN_RESTRICT_HINT_KEY = "agent-spawn-restrict-hint";
+var SPAWN_RESTRICT_MAX_NAMES = 3;
+var ROSTER_WALK_MAX_DEPTH = 4;
+var ROSTER_WALK_MAX_FILES = 400;
+var AGENT_NAME_RE = /^[A-Za-z0-9._:-]{1,64}$/;
+function parseAgentDefinition(text, fallbackName) {
+  const fmMatch = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(text);
+  if (!fmMatch) return null;
+  const fm = fmMatch[1];
+  const nameMatch = /^name:(.*)$/m.exec(fm);
+  const rawName = nameMatch ? nameMatch[1].trim().replace(/^["']|["']$/g, "") : "";
+  const resolved = AGENT_NAME_RE.test(rawName) ? rawName : fallbackName;
+  if (!AGENT_NAME_RE.test(resolved)) return null;
+  const name = resolved;
+  const toolsMatch = /^tools:(.*)$/m.exec(fm);
+  if (!toolsMatch) return { name, restricted: false };
+  const inline = toolsMatch[1].trim();
+  if (inline === "*" || inline === '"*"' || inline === "'*'") return { name, restricted: false };
+  if (inline !== "") return { name, restricted: true };
+  const after = fm.slice(toolsMatch.index + toolsMatch[0].length);
+  for (const line of after.split(/\r?\n/)) {
+    if (/^\s+-\s*\S/.test(line)) return { name, restricted: true };
+    if (/^\S/.test(line)) break;
+  }
+  return { name, restricted: false };
+}
+function findRestrictedAgentNames(roots) {
+  const projectAgentsRoot = path.join(process.cwd(), ".claude", "agents");
+  const scanRoots = roots ?? [path.join(claudeConfigDir(), "agents"), projectAgentsRoot];
+  const names = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  let filesSeen = 0;
+  const walk = (dir, depth, confineTo) => {
+    if (depth > ROSTER_WALK_MAX_DEPTH || filesSeen >= ROSTER_WALK_MAX_FILES) return;
+    let real;
+    try {
+      real = fs.realpathSync(dir);
+    } catch {
+      return;
+    }
+    if (confineTo !== null && !isInsideRoot(real, confineTo)) return;
+    const key = process.platform === "win32" ? real.toLocaleLowerCase() : real;
+    if (visited.has(key)) return;
+    visited.add(key);
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (filesSeen >= ROSTER_WALK_MAX_FILES) return;
+      const full = path.join(dir, entry.name);
+      let stat;
+      try {
+        stat = fs.statSync(full);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        walk(full, depth + 1, confineTo);
+        continue;
+      }
+      if (!stat.isFile() || !entry.name.toLowerCase().endsWith(".md")) continue;
+      filesSeen++;
+      let text;
+      try {
+        text = fs.readFileSync(full, "utf-8");
+      } catch {
+        continue;
+      }
+      const parsed = parseAgentDefinition(text, path.basename(entry.name, path.extname(entry.name)));
+      if (parsed !== null && parsed.restricted) names.add(parsed.name);
+    }
+  };
+  for (const root of scanRoots) {
+    const isProjectRoot = roots === void 0 && path.resolve(root) === path.resolve(projectAgentsRoot);
+    if (!isProjectRoot) {
+      walk(root, 0, null);
+      continue;
+    }
+    let rootIsLink;
+    try {
+      rootIsLink = fs.lstatSync(root).isSymbolicLink();
+    } catch {
+      continue;
+    }
+    if (rootIsLink) continue;
+    let confineTo;
+    try {
+      confineTo = fs.realpathSync(root);
+    } catch {
+      continue;
+    }
+    walk(root, 0, confineTo);
+  }
+  return Array.from(names).sort();
+}
+function buildUnrestrictedSpawnAdvisory(toolInput) {
+  try {
+    const harness = getHarnessName();
+    if (harness === "copilot_cli" || harness === "vscode") return "";
+    const rawType = toolInput["subagent_type"];
+    const spawnType = typeof rawType === "string" ? rawType.trim() : "";
+    if (spawnType !== "" && spawnType !== "general-purpose") return "";
+    if (wasHintShown(SPAWN_RESTRICT_HINT_KEY)) return "";
+    const names = findRestrictedAgentNames();
+    if (names.length === 0) return "";
+    markHintShown(SPAWN_RESTRICT_HINT_KEY);
+    recordStat("session_hint", 0, 0, void 0, "agent-spawn-restrict");
+    const shown = neutralizeSpokenMarkers(names.slice(0, SPAWN_RESTRICT_MAX_NAMES).join(", "));
+    const more = names.length > SPAWN_RESTRICT_MAX_NAMES ? ` and ${names.length - SPAWN_RESTRICT_MAX_NAMES} more` : "";
+    return `[token-goat] This spawn ran as general-purpose (the default when subagent_type is omitted), which is unrestricted: its lane starts by paying for every tool and MCP schema on the machine. Tools-restricted agent definitions exist here: ${shown}${more}. A future spawn that fits one of them can pass that name as subagent_type to start with a much smaller prefix. Advisory only: this spawn has already run, and this notice saved nothing.`;
+  } catch {
+    return "";
+  }
+}
+var SCOPED_SPAWN_DENY_KEY = "agent-scoped-spawn-deny";
+function buildScopedSpawnDeny(toolInput) {
+  if (!loadConfig().hints.agent_scoped_spawn_deny) return null;
+  const harness = getHarnessName();
+  if (harness === "copilot_cli" || harness === "vscode") return null;
+  const rawType = toolInput["subagent_type"];
+  if (typeof rawType === "string" && rawType.trim() !== "") return null;
+  if (wasHintShown(SCOPED_SPAWN_DENY_KEY)) return null;
+  const names = findRestrictedAgentNames();
+  if (names.length === 0) return null;
+  markHintShown(SCOPED_SPAWN_DENY_KEY);
+  markHintShown(SPAWN_RESTRICT_HINT_KEY);
+  recordStat("agent_scoped_spawn_deny", 0, 0);
+  const shown = neutralizeSpokenMarkers(names.slice(0, SPAWN_RESTRICT_MAX_NAMES).join(", "));
+  const more = names.length > SPAWN_RESTRICT_MAX_NAMES ? ` and ${names.length - SPAWN_RESTRICT_MAX_NAMES} more` : "";
+  return denyOutput(`This Agent call omits subagent_type, so it would run as general-purpose, which is unrestricted: its lane starts by paying for every tool and MCP schema on the machine. Tools-restricted agent definitions exist here: ${shown}${more}. Re-issue the call with one of them as subagent_type if it fits the task. If none fits, re-issue it unchanged and it will run: this refusal fires once per session.`);
+}
+function reportNotice(resultText, recallHint, spawnAdvisory) {
+  return `[token-goat] This subagent report (${toKB(resultText.length)}KB) is cached for later recall: ${recallHint}${spawnAdvisory === "" ? "" : `
+${spawnAdvisory}`}`;
+}
+var REWRITTEN_REPORT_RE = /\n\n\[token-goat\] This subagent report \([0-9.]+KB\) is cached for later recall: token-goat mcp-output mcp_[0-9a-f]{16} --full(?:\ntoken-goat: [^\n]*)*$/;
+function planReportCompaction(resultText, recallHint, notice) {
+  const cfg = loadConfig().agent_report;
+  const collapsed = collapseFencedBlocks(resultText, recallHint, cfg.fence_collapse_min_lines, cfg.fence_collapse_keep_lines);
+  const deduped = dedupeFencedBlocks(collapsed, resultText, recallHint);
+  const final = collapseBlankRunsInFences(deduped);
+  if (final === resultText) return { final, worthwhile: false };
+  const worthwhile = isRewriteWorthwhile({
+    originalBytes: Buffer.byteLength(resultText, "utf-8"),
+    rewrittenBytes: Buffer.byteLength(final, "utf-8"),
+    noticeBytes: Buffer.byteLength(notice, "utf-8"),
+    minNetSavingsBytes: resolveMinNetSavingsBytes()
+  });
+  return { final, worthwhile };
+}
+function recordReportCompaction(resultText, updatedOutput) {
+  const savedBytes = Buffer.byteLength(resultText, "utf-8") - Buffer.byteLength(updatedOutput, "utf-8");
+  if (savedBytes > 0) recordStat("agent_report_compact", savedBytes, savedTokensFromBytes(savedBytes));
+}
+function receiptRewrite(resultText, receipt) {
+  recordStat("agent_receipt", 0, 0, void 0, "agent");
+  return emitRewrite(`${resultText}
+
+${receipt}`, "agent");
+}
+async function subagentReportRewriteHandler(event) {
+  try {
+    if (getHarnessName() !== "copilot_cli" || !event.sessionId) return passOutput();
+    const raw = event.raw["last_assistant_message"];
+    if (typeof raw !== "string" || raw === "") return passOutput();
+    const redactedReport = redactSecrets(raw);
+    const resultText = redactedReport.text;
+    const receipt = (await loadAgentReceipt()).receiptForStoppedAgent(event, resultText);
+    const receiptOnly = () => receipt === null ? passOutput() : receiptRewrite(resultText, receipt);
+    if (resultText.length < loadConfig().agent_report.min_bytes) return receiptOnly();
+    const toolInput = { agent_id: event.agentId ?? "" };
+    const id = mcpOutputId(event.sessionId, mcpHash("task", toolInput));
+    const recallHint = `token-goat mcp-output ${id} --full`;
+    const notice = reportNotice(resultText, recallHint, receipt ?? "");
+    const { final, worthwhile } = planReportCompaction(resultText, recallHint, notice);
+    if (!worthwhile) return receiptOnly();
+    if (storeMcpOutput(event.sessionId, "task", toolInput, resultText) !== id) return receiptOnly();
+    if (redactedReport.count > 0) recordStat("secret_redacted", 0, redactedReport.count, void 0, "agent");
+    if (receipt !== null) recordStat("agent_receipt", 0, 0, void 0, "agent");
+    const updatedOutput = `${final}
+
+${notice}`;
+    recordReportCompaction(resultText, updatedOutput);
+    return emitRewrite(updatedOutput, "agent", void 0, "counted-elsewhere");
+  } catch {
+    return passOutput();
+  }
+}
+async function postAgentHandler(event) {
+  try {
+    if (!isAgentTool(event.toolName) || !event.sessionId) return passOutput();
+    const finished = readSpawnBrief(event.toolName, event.toolInput);
+    if (finished !== null) removeOutstandingAgentSpawn(finished.text);
+    if (event.toolName === "spawn_agent") return passOutput();
+    const redactedReport = redactSecrets(extractToolResultText(event.raw));
+    const resultText = redactedReport.text;
+    if (REWRITTEN_REPORT_RE.test(resultText)) return passOutput();
+    const agentReportCfg = loadConfig().agent_report;
+    const receipt = (await loadAgentReceipt()).takeAgentReceipt(event.sessionId, resultText);
+    if (receipt !== null) recordStat("agent_receipt", 0, 0, void 0, "agent");
+    const spawnAdvisory = [buildUnrestrictedSpawnAdvisory(event.toolInput), receipt ?? ""].filter((part) => part !== "").join("\n");
+    if (!resultText || resultText.length < agentReportCfg.min_bytes) {
+      return spawnAdvisory === "" ? passOutput() : contextOutput(spawnAdvisory);
+    }
+    const id = storeMcpOutput(event.sessionId, event.toolName ?? "Agent", event.toolInput, resultText);
+    if (id === null) return spawnAdvisory === "" ? passOutput() : contextOutput(spawnAdvisory);
+    if (redactedReport.count > 0) recordStat("secret_redacted", 0, redactedReport.count, void 0, "agent");
+    recordStat("session_hint", 0, 0);
+    const recallHint = `token-goat mcp-output ${id} --full`;
+    const notice = reportNotice(resultText, recallHint, spawnAdvisory);
+    const { final, worthwhile } = planReportCompaction(resultText, recallHint, notice);
+    if (final !== resultText && !dropsResultRewrite()) {
+      if (worthwhile) {
+        const updatedOutput = `${final}
+
+${notice}`;
+        recordReportCompaction(resultText, updatedOutput);
+        return emitRewrite(updatedOutput, "agent", void 0, "counted-elsewhere");
+      }
+      recordStat("agent_report_compact_declined", 0, 0);
+    } else if (final !== resultText && worthwhile && spawnAdvisory === "") {
+      return passOutput();
+    }
+    return contextOutput(notice);
+  } catch {
+    return passOutput();
+  }
+}
+export {
+  buildUnrestrictedSpawnAdvisory,
+  collapseBlankRunsInFences,
+  collapseFencedBlocks,
+  dedupeFencedBlocks,
+  findRestrictedAgentNames,
+  parseAgentDefinition,
+  postAgentHandler,
+  preAgentHandler,
+  subagentReportRewriteHandler,
+  subagentStartHandler,
+  subagentStartWired
+};