token-goat 2.8.4 → 2.9.1

package/dist/{token-goat-chunk-ZQ3PUOP3.mjs → token-goat-chunk-RRNRPCLX.mjs}

@@ -1,32 +1,26 @@
 import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
-  BASH_OUTPUT_SUBDIR,
+  DEFAULT_RECONCILE_BUDGET_MS,
   HOOK_EVENTS,
   accumulateResidentLines,
   buildCommandManifest,
   checkSymbolBodySize,
-  commandHash,
   flattenCommandNames,
-  getBashOutput,
   getWebOutput,
-  indexRecallEntry,
-  isBashEntryStale,
-  isScopedGitStatusOrDiffStatCommand,
+  isReconcileClean,
   lineMayCarryResidentSignal,
   normalizePayload,
   readStdinJson,
   readTranscriptTail,
+  reconcileProject,
   repeatedSkillBodyHint,
-  storeBashOutput,
   storeWebOutput,
-  summarizeOutputDelta,
   summarizeResidentContext,
   taskListPruneHint
-} from "./token-goat-chunk-IZRXU64B.mjs";
+} from "./token-goat-chunk-MR7MNSDR.mjs";
 import {
-  BODY_FIRST_TOOL_RESPONSE_KEYS,
-  OUTPUT_FIRST_TOOL_RESPONSE_KEYS,
+  BASH_OUTPUT_SUBDIR,
   UNTRUSTED_TOOL_TAG,
   WEB_FETCH_KEY_SEP,
   appendDirtyPath,
@@ -36,27 +30,23 @@ import {
   classifyBashHint,
   classifyEditHint,
   clearCurlDownload,
+  commandHash,
   compactPathFor,
   computeAdaptiveBudget,
-  contextOutput,
   countSymbols,
-  denyOutput,
-  emitRewrite,
   enqueueDirtyPathSafe,
   ensureWorkerAlive,
   estimateTokens,
   extractCompactFromMarker,
-  extractToolResponseField,
-  extractToolResultText,
-  fenceUntrustedContent,
+  fenceWithMatches,
   formatProjectMap,
   formatShrinkSummary,
+  getBashOutput,
   getBashOutputId,
   getContextPressure,
   getCurlDownloadPath,
-  getCwd,
   getFileLineRanges,
-  getFilePath,
+  getFileServedOutputs,
   getGlobMatchCount,
   getGrepMatchCount,
   getLastTabContext,
@@ -66,20 +56,19 @@ import {
   getSessionBashReruns,
   getSessionFiles,
   getSessionWebFetches,
-  getToolInput,
-  getToolName,
   hasSeenImage,
   hasSessionOutput,
   imageQualifiesForShrink,
   incrementSkillHit,
+  indexRecallEntry,
   installedSkillPath,
+  isBashEntryStale,
   isBuildCommand,
-  isMcpErrorResponse,
+  isScopedGitStatusOrDiffStatCommand,
   isTestRunnerCommand,
   listSiblingSessionStates,
   loadSessionCache,
   loadSessionState,
-  makeDedupHintHandlers,
   markCompactStale,
   markCompacted,
   markFileTruncated,
@@ -87,7 +76,6 @@ import {
   matchesAllowPattern,
   matchesDenyPattern,
   meetsSavingsFloor,
-  passOutput,
   probeImageMeta,
   recordBashOutput,
   recordBashRerun,
@@ -96,6 +84,7 @@ import {
   recordFileEdit,
   recordFileLineRange,
   recordFileRead,
+  recordFileServedOutput,
   recordGlobQuery,
   recordGrepQuery,
   recordKnownRootThrottled,
@@ -104,58 +93,84 @@ import {
   recordSeenImage,
   recordSymbolRead,
   recordWebFetch,
-  registerHook,
   removeOutstandingAgentSpawn,
-  runHook,
   saveSessionState,
-  scanForInjectionPatterns,
-  serializeOutput,
+  scanAndRecord,
   sessionOutputBodyBytes,
   sessionSidecarPath,
   setLastTabContext,
   shrinkImage,
+  storeBashOutput,
   storeBlob,
   storeOutput,
+  summarizeOutputDelta,
   takePendingLargeFileHint,
   visionTokens,
   visionTokensSaved,
   wasCliReadThisSession,
   wasFileReadThisSession,
   wasHintShown
-} from "./token-goat-chunk-4OTIB7SB.mjs";
+} from "./token-goat-chunk-FDXINYK4.mjs";
 import {
   canRunWrappedShell,
-  compressOutput,
-  dedupeConsecutive,
-  detectFromCommand,
-  filterByName,
-  hasBareBackgroundOrNewline,
-  isRewriteWorthwhile,
-  resolveMinNetSavingsBytes,
-  shlexSplit
-} from "./token-goat-chunk-CZALRRGN.mjs";
+  deliveredOutputBytes
+} from "./token-goat-chunk-LHMC5ENL.mjs";
 import {
+  BODY_FIRST_TOOL_RESPONSE_KEYS,
+  ENV_KEYS,
+  IDENTICAL_READ_MIN_BODY_BYTES,
+  OUTPUT_FIRST_TOOL_RESPONSE_KEYS,
   PER_FILE_COUNTERFACTUAL_CEILING,
   VERSION,
+  compressOutput,
+  containsLineRun,
+  contextOutput,
+  countNoun,
+  dedupeConsecutive,
+  denyOutput,
+  detectFromCommand,
   detectHarness,
   detectLanguage,
   displaySafePath,
+  emitRewrite,
+  emitRewriteIfChanged,
+  envBool,
+  envInt,
   extractErrorMessage,
+  extractToolResponseField,
+  extractToolResultText,
+  filterByName,
   foldPath,
+  getCwd,
   getDb,
+  getFilePath,
   getHarnessName,
+  getToolInput,
+  getToolName,
   globalDbPath,
+  hasBareBackgroundOrNewline,
+  isMcpErrorResponse,
+  isRewriteWorthwhile,
   isUnderSystemTemp,
   loadConfig,
+  makeDedupHintHandlers,
   normalizePath,
+  passOutput,
   recordStat,
   redactSecrets,
+  registerHook,
   resolveIndexPath,
+  resolveMinNetSavingsBytes,
   runGit,
+  runHook,
   savedTokensFromBytes,
+  serializeOutput,
+  sessionStateKey,
+  shlexSplit,
   shortFingerprint,
+  stripAnsiEscapes,
   toKB
-} from "./token-goat-chunk-E76UNTVK.mjs";
+} from "./token-goat-chunk-4ZDRTNGV.mjs";
 
 // src/hooks_grep.ts
 function grepIntInput(toolInput, key) {
@@ -630,7 +645,7 @@ import crypto from "node:crypto";
 var TRACKED_SKILL = "token-goat";
 var MAX_COMMANDS_SHOWN = 8;
 async function currentCommandNames() {
-  const { buildProgram } = await import("./token-goat-chunk-HNODKNWO.mjs");
+  const { buildProgram } = await import("./token-goat-chunk-V5T3YNYR.mjs");
   return flattenCommandNames(buildCommandManifest(buildProgram()));
 }
 async function recordSkillVersionSnapshot(sessionId, skillName) {
@@ -886,23 +901,47 @@ registerHook("post_tool_use", pendingContextHandler, { advisory: true, followsMa
 // src/hooks_session_start.ts
 var GENERIC_REMINDER = 'token-goat: prefer surgical reads over the Read/Grep tools on this codebase; shell commands like `rg`, `grep`, `fd`, `sed`, `cat`, `find`, and `ls` are just commands, not tool names -- `token-goat symbol <name>`, `token-goat read "file::symbol"`, `token-goat section "file::Heading"`, `token-goat semantic "description"`, `token-goat outline <file>`. Run `token-goat index .` if this project is not indexed yet.';
 var INDEXED_REMINDER = 'token-goat: this project is indexed. Prefer `symbol <name>`, `read "file::symbol"`, `section "file::Heading"`, `semantic "description"`, or `outline <file>` over a full Read/Grep tool call; for JSON/YAML use `json-query file \'a.b.c\'` or `yaml-query` (nested keys are not symbols); shell commands like `rg`, `grep`, `fd`, `sed`, `cat`, `find`, and `ls` are still just commands.';
-function buildReminder(cwd) {
-  if (cwd === void 0) return GENERIC_REMINDER;
-  let symbolCount;
+function isIndexedProject(cwd) {
+  if (cwd === void 0) return false;
   try {
-    symbolCount = countSymbols({ rootDir: cwd }, globalDbPath());
+    return countSymbols({ rootDir: cwd }, globalDbPath()) > 0;
   } catch {
-    return GENERIC_REMINDER;
+    return false;
+  }
+}
+function buildReminder(indexed) {
+  return indexed ? INDEXED_REMINDER : GENERIC_REMINDER;
+}
+function reconcileNote(cwd, indexed) {
+  if (!indexed) return null;
+  if (!envBool(ENV_KEYS.RECONCILE, true)) return null;
+  try {
+    const budgetMs = envInt(ENV_KEYS.RECONCILE_BUDGET_MS, DEFAULT_RECONCILE_BUDGET_MS, 0, 6e4);
+    const result = reconcileProject({ cwd, budgetMs });
+    if (isReconcileClean(result)) return null;
+    const parts = [];
+    if (result.changed.length > 0) parts.push(`${result.changed.length} changed`);
+    if (result.added.length > 0) parts.push(`${result.added.length} new`);
+    if (result.removed.length > 0) parts.push(`${result.removed.length} removed`);
+    const breakdown = parts.length > 1 ? ` (${parts.join(", ")})` : "";
+    const truncated = result.budgetExhausted ? ` (sweep stopped at its time budget with ${countNoun(result.unscanned, "file")} unchecked, so there may be more)` : "";
+    const total = result.changed.length + result.added.length + result.removed.length;
+    return `token-goat: reindexing ${countNoun(total, "file")} that changed outside this session${breakdown}${truncated}. Symbol lookups may be briefly stale.`;
+  } catch {
+    return null;
   }
-  if (symbolCount <= 0) return GENERIC_REMINDER;
-  return INDEXED_REMINDER;
 }
 function sessionStartHandler(event) {
   try {
     if (!loadConfig().hints.session_start_reminder) return passOutput();
     const cwd = getCwd(event);
-    let context = buildReminder(cwd);
+    const indexed = isIndexedProject(cwd);
+    let context = buildReminder(indexed);
     if (cwd !== void 0) {
+      const drift = reconcileNote(cwd, indexed);
+      if (drift !== null) context += `
+
+${drift}`;
       const capsule = buildDeltaCapsule(cwd);
       if (capsule !== null) context += `
 
@@ -7035,29 +7074,13 @@ function postFetchHandler(event) {
     const { toolInput, url } = urlCtx;
     recordStat("web_fetch");
     const body = extractToolResponse(event.raw);
-    const injCfg = loadConfig().injection;
-    const injectionMatches = injCfg.enabled && body ? scanForInjectionPatterns(body) : [];
-    if (injectionMatches.length > 0) {
-      recordStat("injection_detected", 0, 0, void 0, injectionMatches.join(","));
-    }
+    const injectionMatches = body ? scanAndRecord(body) : [];
     const bodyRedacted = body ? redactSecrets(body) : { text: body, count: 0 };
     if (!event.sessionId) {
-      if (injectionMatches.length > 0) {
-        return emitRewrite(fenceUntrustedContent(bodyRedacted.text, injectionMatches), "fetch");
-      }
-      if (bodyRedacted.count > 0) {
-        return emitRewrite(bodyRedacted.text, "fetch");
-      }
-      return passOutput();
+      return emitRewriteIfChanged(body, fenceWithMatches(bodyRedacted.text, injectionMatches), "fetch");
     }
     if (!body || body.length < 1024) {
-      if (injectionMatches.length > 0) {
-        return emitRewrite(fenceUntrustedContent(bodyRedacted.text, injectionMatches), "fetch");
-      }
-      if (bodyRedacted.count > 0) {
-        return emitRewrite(bodyRedacted.text, "fetch");
-      }
-      return passOutput();
+      return emitRewriteIfChanged(body, fenceWithMatches(bodyRedacted.text, injectionMatches), "fetch");
     }
     const prompt = typeof toolInput["prompt"] === "string" ? toolInput["prompt"] : "";
     let storedBody = body;
@@ -7072,29 +7095,24 @@ function postFetchHandler(event) {
     const cacheId = storeWebOutput(url, storedBody, `${url}\0${prompt}`, storedBody !== body ? body : void 0);
     recordWebFetch(url, prompt, cacheId);
     const storedRedacted = storedBody === body ? bodyRedacted : redactSecrets(storedBody);
-    if (injectionMatches.length > 0) {
-      return emitRewrite(fenceUntrustedContent(storedRedacted.text, injectionMatches), "fetch");
-    }
+    const fencedStored = fenceWithMatches(storedRedacted.text, injectionMatches);
     if (storedBody !== body) {
       const noticeFor = (id) => `
 [token-goat: WebFetch body compressed via extractCleanText; use \`token-goat web-output ${id} --raw\` to recall it]`;
       const notice = noticeFor(cacheId);
       const noticeBytes = Buffer.byteLength(notice, "utf-8");
       const originalBytes = Buffer.byteLength(body, "utf-8");
-      const rewrittenBytes = Buffer.byteLength(storedBody, "utf-8");
+      const rewrittenBytes = Buffer.byteLength(fencedStored, "utf-8");
       if (isRewriteWorthwhile({
         originalBytes,
         rewrittenBytes,
         noticeBytes,
         minNetSavingsBytes: resolveMinNetSavingsBytes()
       })) {
-        return emitRewrite(storedRedacted.text + notice, "fetch", { kind: "webfetch:compress", originalBytes });
+        return emitRewrite(fencedStored + notice, "fetch", { kind: "webfetch:compress", originalBytes });
       }
     }
-    if (storedRedacted.count > 0) {
-      return emitRewrite(storedRedacted.text, "fetch");
-    }
-    return passOutput();
+    return emitRewriteIfChanged(body, fencedStored, "fetch");
   } catch {
     return passOutput();
   }
@@ -7150,7 +7168,7 @@ async function preSkillHandler(event) {
       const denyCredit = cachedBytes !== null ? Math.min(cachedBytes, PER_FILE_COUNTERFACTUAL_CEILING) : 0;
       recordStat("session_hint", denyCredit, savedTokensFromBytes(denyCredit));
       return denyOutput(
-        "Skill `" + skillName + "` was already loaded this session and is cached. Use `token-goat skill-body " + skillName + " --compact` to recall the compact slice (or `token-goat skill-body " + skillName + "` for the full body) instead of re-loading it."
+        "Skill `" + skillName + "` was already loaded this session and is cached. Use `token-goat skill-section " + skillName + " '<heading>'` to recall a section, `token-goat skill-body " + skillName + " --compact` to recall the compact slice, or `token-goat skill-body " + skillName + "` for the full body instead of re-loading it."
       );
     }
     const sourcePath = await installedSkillPath(skillName);
@@ -7165,12 +7183,12 @@ async function preSkillHandler(event) {
             const savedBytes = bodyBytes - compactBytes;
             recordStat("skill_compact_inlined", savedBytes, savedTokensFromBytes(savedBytes));
             return denyOutput(
-              "Skill `" + skillName + "` is large (" + bodyBytes + " bytes); its compact slice (" + compactBytes + " bytes) is inlined below instead of the full body. Run `token-goat skill-body " + skillName + "` if you need the full body.\n\n" + compact
+              "Skill `" + skillName + "` is large (" + bodyBytes + " bytes); its compact slice (" + compactBytes + " bytes) is inlined below instead of the full body. For a specific section, run `token-goat skill-section " + skillName + " '<heading>'`, or `token-goat skill-body " + skillName + "` if you need the full body.\n\n" + compact
             );
           }
           recordStat("skill_oversized_first_load");
           return denyOutput(
-            "Skill `" + skillName + "` is large (" + bodyBytes + " bytes) and has a compact slice available. Use `token-goat skill-body " + skillName + " --compact` to load the compact slice instead of the full body."
+            "Skill `" + skillName + "` is large (" + bodyBytes + " bytes) and has a compact slice available. Use `token-goat skill-section " + skillName + " '<heading>'` to load a specific section, `token-goat skill-body " + skillName + " --compact` to load the compact slice, or `token-goat skill-body " + skillName + "` for the full body."
           );
         }
       } catch {
@@ -8403,6 +8421,40 @@ function maybeCompressRewrite(event, rawCmd, cmd) {
   const wrapped = `token-goat compress -f ${filterName} --timeout ${cfg.timeout_seconds} -c ${shellQuoteSingle(rawCmd)}`;
   return { hookType: "rewriteInput", updatedInput: { ...event.toolInput, command: wrapped } };
 }
+function pureFileReadPath(cmd) {
+  return extractCatFile(cmd)?.filePath ?? extractHeadFile(cmd)?.filePath ?? extractTailFile(cmd)?.filePath ?? extractLineRangeRead(cmd)?.filePath ?? null;
+}
+async function maybeCollapseIdenticalRead(cmd, output, exitCode, cwd, cacheMinBytes) {
+  if (process.env["TOKEN_GOAT_BASH_COMPRESS"] === "0") return null;
+  if (exitCode !== null && exitCode !== 0) return null;
+  const filePath = pureFileReadPath(cmd);
+  if (filePath === null) return null;
+  const originalBytes = Buffer.byteLength(output, "utf-8");
+  if (originalBytes < Math.max(cacheMinBytes, IDENTICAL_READ_MIN_BODY_BYTES)) return null;
+  const fileKey = resolveIndexPath(filePath, cwd ?? process.cwd());
+  const priorIds = getFileServedOutputs(fileKey);
+  let containerId = null;
+  let identical = false;
+  for (let i = priorIds.length - 1; i >= 0; i--) {
+    const id = priorIds[i];
+    if (id === void 0) continue;
+    const prior = getBashOutput(id);
+    if (prior === null || !containsLineRun(prior.output, output)) continue;
+    containerId = id;
+    identical = prior.output === output;
+    break;
+  }
+  const sessionKey = shortFingerprint(stripOutputPipeline(cmd));
+  if (containerId === null) {
+    const storedId = await storeBashOutput(cmd, output, exitCode ?? 0, cwd);
+    recordBashOutput(sessionKey, storedId, originalBytes);
+    recordFileServedOutput(fileKey, storedId);
+    return null;
+  }
+  const pointer = identical ? "[token-goat] Identical to an earlier run of this command in this session; the file has not changed since. " + originalBytes + " bytes withheld -- recall them with `token-goat bash-output " + containerId + "`." : "[token-goat] These " + originalBytes + " bytes already appear verbatim inside a wider read of " + filePath + " served earlier in this session. Withheld -- recall the full earlier output with `token-goat bash-output " + containerId + "`.";
+  if (!isRewriteWorthwhile({ originalBytes, rewrittenBytes: Buffer.byteLength(pointer, "utf-8"), noticeBytes: 0, minNetSavingsBytes: resolveMinNetSavingsBytes() })) return null;
+  return emitRewrite(pointer, identical ? "identical file re-read collapsed" : "already-served file lines collapsed", { kind: identical ? "bash_compress:identical-reread" : "bash_compress:contained-reread", originalBytes: deliveredOutputBytes(originalBytes) });
+}
 async function maybeCompressCompoundOutput(cmd, output, exitCode, cwd, cacheMinBytes) {
   if (process.env["TOKEN_GOAT_BASH_COMPRESS"] === "0") return null;
   if (isCompressibleSingleCommand(cmd)) return null;
@@ -8435,7 +8487,28 @@ async function maybeCompressCompoundOutput(cmd, output, exitCode, cwd, cacheMinB
     return null;
   }
   await storeBashOutput(cmd, output, exitCode ?? 0, cwd);
-  return emitRewrite(body, "bash", { kind: "bash_compress:generic", originalBytes: compressed.originalBytes });
+  return emitRewrite(body, "bash", { kind: "bash_compress:generic", originalBytes: deliveredOutputBytes(compressed.originalBytes) });
+}
+function maybeStripAnsiOnly(output) {
+  if (!output.includes("\x1B")) return null;
+  let cfg;
+  try {
+    cfg = loadConfig().bash_compress;
+  } catch {
+    return null;
+  }
+  if (!cfg.enabled || cfg.disabled_filters.includes("ansi")) return null;
+  const stripped = stripAnsiEscapes(output);
+  const originalBytes = Buffer.byteLength(output, "utf-8");
+  if (!isRewriteWorthwhile({
+    originalBytes,
+    rewrittenBytes: Buffer.byteLength(stripped, "utf-8"),
+    noticeBytes: 0,
+    minNetSavingsBytes: resolveMinNetSavingsBytes()
+  })) {
+    return null;
+  }
+  return emitRewrite(stripped, "ansi escapes stripped", { kind: "bash_compress:ansi", originalBytes: deliveredOutputBytes(originalBytes) }, "counted-elsewhere");
 }
 function unwrapCompressCommand(executed) {
   const t = executed.trim();
@@ -9122,9 +9195,11 @@ async function postBashHandler(event) {
     }
     const isMonitoring = getMonitoringRecallHint(cmd) !== null;
     if (!isMonitoring && !isBuildCommand(cmd) && !isCurlGetCommand(cmd)) {
+      const identical = await maybeCollapseIdenticalRead(cmd, output, exitCode, cwd, cacheMinBytes);
+      if (identical !== null) return identical;
       const compound = await maybeCompressCompoundOutput(cmd, output, exitCode, cwd, cacheMinBytes);
       if (compound !== null) return compound;
-      return passOutput();
+      return maybeStripAnsiOnly(output) ?? passOutput();
     }
     if (Buffer.byteLength(output, "utf-8") < cacheMinBytes) return passOutput();
     const cacheKey = isCurlGetCommand(cmd) ? extractCurlUrl(cmd) ?? cmd : stripOutputPipeline(cmd);
@@ -9141,6 +9216,8 @@ async function postBashHandler(event) {
         return contextOutput(delta + " \u2014 full output: bash-output " + id);
       }
     }
+    const ansiOnly = maybeStripAnsiOnly(output);
+    if (ansiOnly !== null) return ansiOnly;
   } catch {
   }
   return passOutput();
@@ -9839,23 +9916,14 @@ function postMcpHandler(event) {
   const toolInput = getToolInput(event);
   const resultText = extractToolResultText(event.raw);
   if (!resultText) return passOutput();
-  let injectionMatches = [];
-  try {
-    if (loadConfig().injection.enabled) injectionMatches = scanForInjectionPatterns(resultText);
-  } catch {
-    injectionMatches = [];
-  }
-  if (injectionMatches.length > 0) recordStat("injection_detected", 0, 0, void 0, injectionMatches.join(","));
+  const injectionMatches = scanAndRecord(resultText);
   const redactedResult = redactSecrets(resultText);
-  const fenced = () => emitRewrite(
-    fenceUntrustedContent(redactedResult.text, injectionMatches, UNTRUSTED_TOOL_TAG),
+  const fenced = () => emitRewriteIfChanged(
+    resultText,
+    fenceWithMatches(redactedResult.text, injectionMatches, UNTRUSTED_TOOL_TAG),
     "mcp"
   );
-  const passOrFence = () => {
-    if (injectionMatches.length > 0) return fenced();
-    if (redactedResult.count > 0) return emitRewrite(redactedResult.text, "mcp");
-    return passOutput();
-  };
+  const passOrFence = () => fenced();
   if (!event.sessionId) return passOrFence();
   if (isMcpErrorResponse(event.raw)) return passOrFence();
   const readOnly = isMcpReadOnly(toolName, toolInput);
@@ -9882,7 +9950,7 @@ function postMcpHandler(event) {
         });
         if (worthwhile) {
           return emitRewrite(
-            injectionMatches.length > 0 ? `${notice}${fenceUntrustedContent(redactedBody, injectionMatches, UNTRUSTED_TOOL_TAG)}` : `${notice}${redactedBody}`,
+            `${notice}${fenceWithMatches(redactedBody, injectionMatches, UNTRUSTED_TOOL_TAG)}`,
             "mcp",
             { kind: "mcp:compress", originalBytes }
           );
@@ -9934,23 +10002,9 @@ function postWebSearchHandler(event) {
     if (getToolName(event) !== "WebSearch") return passOutput();
     const resultText = extractToolResultText(event.raw);
     if (!resultText) return passOutput();
-    let injectionMatches = [];
-    try {
-      if (loadConfig().injection.enabled) injectionMatches = scanForInjectionPatterns(resultText);
-    } catch {
-      injectionMatches = [];
-    }
-    if (injectionMatches.length > 0) recordStat("injection_detected", 0, 0, void 0, injectionMatches.join(","));
+    const injectionMatches = scanAndRecord(resultText);
     const redacted = redactSecrets(resultText);
-    const passOrFence = () => {
-      if (injectionMatches.length > 0) {
-        return emitRewrite(fenceUntrustedContent(redacted.text, injectionMatches), "websearch");
-      }
-      if (redacted.count > 0) {
-        return emitRewrite(redacted.text, "websearch");
-      }
-      return passOutput();
-    };
+    const passOrFence = () => emitRewriteIfChanged(resultText, fenceWithMatches(redacted.text, injectionMatches), "websearch");
     if (!event.sessionId) return passOrFence();
     const signature = webSearchSignatureInput(getToolInput(event));
     if (signature === null) return passOrFence();
@@ -10470,9 +10524,6 @@ function buildEvent(eventName, payload) {
   const tracestate = typeof rawTracestate === "string" && rawTracestate.trim() !== "" ? rawTracestate.trim() : void 0;
   return { eventName, toolName, toolInput, sessionId, agentId, traceparent, tracestate, raw: obj };
 }
-function sessionStateKey(event) {
-  return event.agentId !== void 0 ? `${event.sessionId}:agent:${event.agentId}` : event.sessionId;
-}
 function harnessForNormalization() {
   const detected = detectHarness();
   if (detected === "codex") return "codex";
@@ -10510,7 +10561,7 @@ async function relayInProcess(eventName, rawPayload) {
       saveSessionState(stateKey);
     } catch {
     }
-    return serializeOutput(output, event.eventName, harness);
+    return serializeOutput(output, event.eventName, harness, event);
   } catch {
     return "{}";
   }