token-goat 2.9.28 → 2.9.30

package/dist/{token-goat-chunk-EL7M26WP.mjs → token-goat-chunk-SQSSNQPE.mjs}

@@ -1,19 +1,159 @@
 import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
+import {
+  applyProbeMarker
+} from "./token-goat-chunk-ZEJVMUQH.mjs";
+import {
+  MCP_TOOL_PATTERN,
+  buildCommandManifest,
+  buildReminder,
+  checkSymbolBodySize,
+  diagnoseSqlFailure,
+  flattenCommandNames,
+  isIndexedProject,
+  readStdinJson
+} from "./token-goat-chunk-GFBSN7BD.mjs";
+import {
+  commentSyntaxFor,
+  foldDetail,
+  mergeFolds,
+  planBodyFolds,
+  planCommentFolds,
+  planProseFolds
+} from "./token-goat-chunk-5RG5SBL6.mjs";
+import {
+  HOOK_EVENTS
+} from "./token-goat-chunk-KKUFXAPD.mjs";
 import {
   MAX_CAPTURE_BYTES,
   canRunPowerShell,
-  canRunWrappedShell,
+  canRunWrappedShell
+} from "./token-goat-chunk-7F2UBPD3.mjs";
+import {
   clipToDeliveryCap,
   deliveredOutputBytes
-} from "./token-goat-chunk-F7QZRIWM.mjs";
+} from "./token-goat-chunk-54K3EUV3.mjs";
+import {
+  DEFAULT_RECONCILE_BUDGET_MS,
+  isReconcileClean,
+  reconcileProject
+} from "./token-goat-chunk-7BXSNBY5.mjs";
+import {
+  readCopilotHooksOwners
+} from "./token-goat-chunk-G5PJ7AGM.mjs";
+import {
+  matchesAllowPattern,
+  matchesDenyPattern,
+  metadataEndpointRefusal,
+  recordKnownRootThrottled,
+  resolveLineRegions
+} from "./token-goat-chunk-YARZFCZS.mjs";
+import {
+  SLICE_ESTIMATE_SCAN_CAP_BYTES,
+  applyHintTracking,
+  buildDeltaCapsule,
+  buildProjectMap,
+  classifyBashHint,
+  classifyEditHint,
+  classifyReadHint,
+  compactPathFor,
+  countTextLines,
+  formatProjectMap,
+  formatShrinkSummary,
+  harnessNumbersReadContent,
+  headingTreeParts,
+  hintTarget,
+  imageQualifiesForShrink,
+  indexMatchesDisk,
+  isDiffableSource,
+  isSessionArtifactFile,
+  isSourceExtension,
+  isTruncatedReadDelivery,
+  isVirtualIndexedPath,
+  logSuppressedDetection,
+  markCompactStale,
+  meetsSavingsFloor,
+  numberedRenderBytes,
+  parseReadDelivery,
+  probeImageMeta,
+  quietContextOutput,
+  readEvidenceFileText,
+  readRequestedSliceWindow,
+  readStartLine,
+  readWindowFromDisk,
+  recordActualSlice,
+  recordEvidence,
+  relPathWithinRoot,
+  settleSelfScoredHints,
+  sharpenRepeatedDeny,
+  shrinkImage,
+  sliceCommand,
+  sliceForPath,
+  store,
+  uncorrelatedHint,
+  visionTokens,
+  visionTokensSaved
+} from "./token-goat-chunk-FBNQNSJK.mjs";
 import {
-  GH_VIEW_BATCH_HINT_KEY,
   SEARCH_COMMAND_RE,
+  classifyToolError
+} from "./token-goat-chunk-PEPTHRFF.mjs";
+import {
+  ORIG_HEAD_ELIGIBLE_GIT_RE,
+  ORIG_HEAD_REFLOG_MSG_RE,
+  PIPELINE_PASSTHROUGH_HEADS,
+  bashRecallKey,
+  cachedRunCoversCommand,
+  cdPrefixCwd,
+  commandRunDir,
+  deliveredLineNumbers,
+  detectUnbalancedShellSyntax,
+  enqueueNonHeadMovingRewrites,
+  extractCommand,
+  gitRepoRoot,
+  hasTestRunScopeOrBudget,
+  isDirectTestRunnerCommand,
+  isFullRecallCommand,
+  isHeadMovingGitCommand,
+  isRecallCommand,
+  isTokenGoatOwnCommand,
+  isWholeFileDump,
+  pipelineDivergenceNote,
+  pipelineShapeFilter,
+  pureFileReadPath,
+  resolveBashCall,
+  resolveCdHintPath,
+  stripCdPrefix,
+  stripCommandPrefix,
+  stripSubshellGroup,
+  stripTrailingStderrRedirect,
+  unwrapCompressCommand
+} from "./token-goat-chunk-JTQQGXZH.mjs";
+import {
+  fenceUntrusted,
+  fenceUntrustedSpans,
+  fenceWithMatches,
+  scanAndRecord
+} from "./token-goat-chunk-67TQJ76B.mjs";
+import {
+  appendDirtyPath,
+  enqueueDirtyPathSafe
+} from "./token-goat-chunk-H2PHHGM5.mjs";
+import {
+  registerHook,
+  runHook,
+  serializeOutput,
+  sessionStateKey
+} from "./token-goat-chunk-P4QMM4WK.mjs";
+import {
+  ensureWorkerAlive
+} from "./token-goat-chunk-5KDMCMF2.mjs";
+import {
+  GH_VIEW_BATCH_HINT_KEY,
   buildGhViewBatchAdvisory,
   buildRecallHint,
-  classifyToolError,
-  commandOptsOutOfCompression,
+  classifyCatPath,
+  compressionOptedOut,
   extractCatFile,
   extractCatFilesMulti,
   extractCatJsonPipe,
@@ -49,7 +189,6 @@ import {
   isCompressibleSingleCommand,
   isCurlGetCommand,
   isReadOnlyGhApi,
-  isTscCommand,
   leadingLinesHint,
   sedOverlapHint,
   sedRangeHint,
@@ -60,142 +199,112 @@ import {
   surgicalHintFor,
   surgicalHintForConfigDoc,
   taskOutputIsJsonlTranscript
-} from "./token-goat-chunk-I7CB3X4K.mjs";
+} from "./token-goat-chunk-APGZXSPS.mjs";
 import {
-  DEFAULT_RECONCILE_BUDGET_MS,
-  HOOK_EVENTS,
-  MCP_TOOL_PATTERN,
-  RECALL_COMMAND,
-  buildCommandManifest,
-  checkSymbolBodySize,
-  diagnoseSqlFailure,
-  flattenCommandNames,
-  getWebOutput,
-  isReconcileClean,
-  readStdinJson,
-  reconcileProject,
-  storeWebOutput
-} from "./token-goat-chunk-VE27HPIF.mjs";
+  compressOutput,
+  detectFromCommand,
+  filterByName,
+  isRewriteWorthwhile,
+  looksLikePytestOutput,
+  pytestFilter,
+  resolveMinNetSavingsBytes
+} from "./token-goat-chunk-COBQGL5S.mjs";
 import {
-  OUTLINE_MAX_REPLACEMENT_RATIO,
-  OUTLINE_MIN_HEADINGS,
-  appendDirtyPath,
-  applyHintTracking,
-  buildDeltaCapsule,
-  buildProjectMap,
-  classifyBashHint,
-  classifyEditHint,
-  compactPathFor,
-  enqueueDirtyPathSafe,
-  ensureWorkerAlive,
-  fenceUntrusted,
-  fenceUntrustedSpans,
-  fenceWithMatches,
-  foldDelivery,
-  foldDetail,
-  foldingEnabled,
-  formatProjectMap,
-  formatShrinkSummary,
-  hintTarget,
-  imageQualifiesForShrink,
-  indexMatchesDisk,
-  indexServedBody,
-  isStructuralRewriteAccepted,
-  logSuppressedDetection,
-  markCompactStale,
-  matchesAllowPattern,
-  matchesDenyPattern,
-  meetsSavingsFloor,
-  metadataEndpointRefusal,
-  planMarkdownOutline,
-  planServedElisions,
-  planSourceSkeleton,
-  probeImageMeta,
-  recordKnownRootThrottled,
-  registerHook,
-  resolveLineRegions,
-  runHook,
-  scanAndRecord,
-  serializeOutput,
-  servedRunNotice,
-  sessionStateKey,
-  settleSelfScoredHints,
-  sharpenRepeatedDeny,
-  shrinkImage,
-  sliceCommand,
-  sliceForPath,
-  uncorrelatedHint,
-  visionTokens,
-  visionTokensSaved
-} from "./token-goat-chunk-6Z5ULNE5.mjs";
+  commandPathIsTouchable,
+  docNavigation,
+  docSectionHint,
+  leadWithCommand,
+  preToolPathDeclined,
+  stripUnsafeSuggestions,
+  vscodePathAllowed
+} from "./token-goat-chunk-ATCPY7EQ.mjs";
 import {
   BODY_FIRST_TOOL_RESPONSE_KEYS,
   OUTPUT_FIRST_TOOL_RESPONSE_KEYS,
-  commandPathIsTouchable,
   contextOutput,
+  copilotCliUserRoot,
   denyOutput,
   emitRewrite,
   emitRewriteIfChanged,
+  emitRewriteWithContext,
   estimateResultCount,
   extractToolResponseField,
   extractToolResultText,
   getCwd,
   getFilePath,
+  getFilePaths,
   getToolInput,
   getToolName,
   getTranscriptPath,
   isMcpErrorResponse,
   isTextualContentBlock,
-  leadWithCommand,
   makeDedupHintHandlers,
   mcpContentBlocks,
   normalizePayload,
   passOutput,
-  preToolPathDeclined,
-  stripUnsafeSuggestions,
+  resolveEventPath,
   structuredResultCount,
-  vscodePathAllowed,
   withPreservedBlocks
-} from "./token-goat-chunk-IZXKVT4A.mjs";
-import {
-  compressOutput,
-  detectFromCommand,
-  filterByName,
-  isRewriteWorthwhile,
-  looksLikePytestOutput,
-  pytestFilter,
-  resolveMinNetSavingsBytes
-} from "./token-goat-chunk-RJH64KQH.mjs";
-import {
-  projectTranscriptsDir
-} from "./token-goat-chunk-6DQNNFJ6.mjs";
-import {
-  readCopilotHooksOwners
-} from "./token-goat-chunk-MMLMALWK.mjs";
+} from "./token-goat-chunk-VPBBTSJR.mjs";
 import {
   BUDGET_ESCALATION_MARKER,
   MANIFEST_PREAMBLE,
   MANIFEST_RECOVERY_PREAMBLE,
   buildManifest,
+  getWebOutput,
   manifestPrintedPaths,
   projectNotesFor,
+  recordCompactDroppedPaths,
+  storeWebOutput,
   summaryBudgetDirective
-} from "./token-goat-chunk-L7SDVGBT.mjs";
+} from "./token-goat-chunk-Q5VTGRH7.mjs";
 import {
+  COMPACTED_AT_SUFFIX,
   extractCompactFromMarker,
   hasSessionOutput,
   incrementSkillHit,
   installedSkillPath,
   loadSessionState,
+  safeSkillName,
   saveSessionState,
   sessionOutputBodyBytes,
   sessionSidecarPath,
-  storeOutput
-} from "./token-goat-chunk-6CCQDAYY.mjs";
+  storeOutput,
+  writeSessionManifest
+} from "./token-goat-chunk-Y776AENC.mjs";
+import {
+  accumulateResidentLines,
+  lineMayCarryResidentSignal,
+  readTranscriptTail,
+  repeatedSkillBodyHint,
+  summarizeResidentContext,
+  taskListPruneHint
+} from "./token-goat-chunk-SJHWVNDQ.mjs";
+import {
+  BASH_OUTPUT_SUBDIR,
+  bashOutputIdSync,
+  commandHash,
+  getBashOutput,
+  getMonitoringRecallHint,
+  indexRecallEntry,
+  isBashEntryStale,
+  isBuildCommand,
+  isScopedGitStatusOrDiffStatCommand,
+  isTestRunnerCommand,
+  storeBashOutput,
+  storeBashOutputSync,
+  summarizeOutputDelta
+} from "./token-goat-chunk-AFLYLHDH.mjs";
+import {
+  claudeConfigDir,
+  projectTranscriptsDir
+} from "./token-goat-chunk-BPGCUMR7.mjs";
 import {
   GENERIC_SERVED_OUTPUT_KEY,
   clearCurlDownload,
+  exportSessionState,
   getBashOutputId,
+  getCompactedAt,
   getCurlDownloadPath,
   getFileLineRanges,
   getFileServedOutputs,
@@ -210,6 +319,7 @@ import {
   markHintShown,
   recordBashOutput,
   recordBashRerun,
+  recordBashStartCwd,
   recordCliRead,
   recordCurlDownload,
   recordFileEdit,
@@ -227,108 +337,114 @@ import {
   resetFileLineRanges,
   setLastTabContext,
   setTranscriptPath,
+  takeBashStartCwd,
   takePendingLargeFileHint,
   wasCliReadThisSession,
   wasFileReadThisSession,
   wasHintShown
-} from "./token-goat-chunk-GGLEE35R.mjs";
-import {
-  accumulateResidentLines,
-  claudeConfigDir,
-  lineMayCarryResidentSignal,
-  readTranscriptTail,
-  repeatedSkillBodyHint,
-  summarizeResidentContext,
-  taskListPruneHint
-} from "./token-goat-chunk-MAMQPC43.mjs";
-import {
-  BASH_OUTPUT_SUBDIR,
-  bashOutputIdSync,
-  commandHash,
-  getBashOutput,
-  getMonitoringRecallHint,
-  indexRecallEntry,
-  isBashEntryStale,
-  isBuildCommand,
-  isScopedGitStatusOrDiffStatCommand,
-  isTestRunnerCommand,
-  storeBashOutput,
-  summarizeOutputDelta
-} from "./token-goat-chunk-HXNAC4ZF.mjs";
-import {
-  storeBlob
-} from "./token-goat-chunk-BJBRGPBX.mjs";
+} from "./token-goat-chunk-C63JQV5K.mjs";
 import {
   estimateTokens
-} from "./token-goat-chunk-4JMWPWCS.mjs";
-import {
-  dedupeConsecutive,
-  hasBareBackground,
-  hasBareBackgroundOrNewline,
-  hasUnquotedOperator,
-  pathStem,
-  shlexSplit,
-  splitOwnTrailingNotices
-} from "./token-goat-chunk-4RN64ZND.mjs";
-import {
-  recordStat,
-  redactSecrets,
-  savedTokensFromBytes,
-  stripAnsiEscapes
-} from "./token-goat-chunk-MVSWBNMD.mjs";
+} from "./token-goat-chunk-JB6QN6VF.mjs";
 import {
   extractMarkdownHeadings,
-  formatHeadingTreeParts
-} from "./token-goat-chunk-D5ICEPSB.mjs";
+  findContainingSection,
+  formatHeadingTreeParts,
+  isImagePath,
+  isTreeSitterAvailable,
+  parseSourceSymbolsTreeSitterOnly,
+  parserFingerprintForLanguage
+} from "./token-goat-chunk-RHXKCZX3.mjs";
 import {
-  countSymbols,
+  getFileEntry,
   querySymbols
-} from "./token-goat-chunk-HUDC5GS5.mjs";
+} from "./token-goat-chunk-HYBFA5X3.mjs";
+import {
+  storeBlob
+} from "./token-goat-chunk-ARDNEC2U.mjs";
+import {
+  HOOK_PROBE_ENV,
+  claimFirstSavingsReceipt,
+  recordStat,
+  savedTokensFromBytes
+} from "./token-goat-chunk-3Z5S4KGM.mjs";
 import {
   buildLineIndex,
   detectLanguage,
   getDb,
   languageHasFlag,
   offsetToLine
-} from "./token-goat-chunk-M56BWPBN.mjs";
+} from "./token-goat-chunk-VL3YIFHZ.mjs";
+import {
+  hasPreciseSecret,
+  redactSecrets,
+  redactSerializedJson
+} from "./token-goat-chunk-4FVIAHSI.mjs";
 import {
-  detectHarness,
-  envBool,
-  envInt,
   findProject,
-  getHarnessName,
+  fingerprintFile,
   isUnderSystemTemp,
   loadConfig,
+  makeProjectAt,
   shortFingerprint
-} from "./token-goat-chunk-CC2PYJM7.mjs";
+} from "./token-goat-chunk-7IN2MKDS.mjs";
+import {
+  detectHarness,
+  getHarnessName,
+  relaySeededSessionId,
+  setRelaySeededSessionId
+} from "./token-goat-chunk-U4N3BN2W.mjs";
+import {
+  envBool,
+  envInt
+} from "./token-goat-chunk-IVE6U7KV.mjs";
 import {
-  ENV_KEYS,
   IDENTICAL_READ_MIN_BODY_BYTES,
   PER_FILE_COUNTERFACTUAL_CEILING,
-  VERSION,
   atomicWriteText,
   containsLineRun,
   countNoun,
-  dataDir,
   ensureDirSync,
   extractErrorMessage,
-  foldPath,
-  globalDbPath,
   hasCreatedConfig,
-  isInsideRoot,
   runGit,
+  statSize,
   toKB
-} from "./token-goat-chunk-L45ZQRT7.mjs";
+} from "./token-goat-chunk-GOLEOXZP.mjs";
+import {
+  foldPath,
+  isInsideRoot
+} from "./token-goat-chunk-AM5V6GSX.mjs";
 import {
   UNTRUSTED_TOOL_TAG,
+  dirAtIndexKey,
   displaySafePath,
   displaySafeText,
+  fenceNumberedFileContent,
   fenceUntrustedFileContent,
+  hostPathOfIndexKey,
+  hostPathOfTypedPath,
+  isFileAtIndexKey,
   neutralizeSpokenMarkers,
   normalizePath,
   resolveIndexPath,
   toDisplayPath
-} from "./token-goat-chunk-NMTKNYGF.mjs";
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  ENV_KEYS,
+  VERSION,
+  dataDir,
+  globalDbPath
+} from "./token-goat-chunk-VES7EL7O.mjs";
+import {
+  dedupeConsecutive,
+  hasBareBackground,
+  pathStem,
+  splitOwnTrailingNotices
+} from "./token-goat-chunk-KWPNJBDH.mjs";
+import {
+  stripAnsiEscapes
+} from "./token-goat-chunk-HAVAOB3S.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -340,535 +456,37 @@ init_define_import_meta_env();
 init_define_import_meta_env();
 import { readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
-
-// src/hooks_bash_commands.ts
-init_define_import_meta_env();
-import { statSync } from "node:fs";
-var CD_PREFIX_RE = /^(?:cd\s+(?:"[^"]*"|'[^']*'|\S+)[ \t]*(?:&&|;|\r?\n)\s*)+/;
-function stripCdPrefix(cmd) {
-  const stripped = cmd.replace(CD_PREFIX_RE, "");
-  return stripped.trim() || cmd;
-}
-function stripCommandPrefix(rawCmd) {
-  return stripLeadingAssignments(stripCdPrefix(rawCmd));
-}
-function stripTrailingStderrRedirect(cmd) {
-  const stripped = cmd.replace(/\s*2>&1\s*$/, "");
-  return stripped.trim() || cmd;
-}
-function hasTestRunScopeOrBudget(cmd) {
-  const hasTimeout = /(?:^|\s)(?:timeout(?:\.exe)?\s+\S+|--(?:test)?timeout(?:=|\s)\S+)/i.test(cmd);
-  const hasSelector = /(?:\s::\S+|\s(?:-k|-t|-run|--(?:testNamePattern|last-failed|test|project))(?:=|\s)|\b(?:tests?|spec)\S*\.(?:[cm]?[jt]sx?|py|go|rs)\b|(?:^|\s)\.\/\S+)/i.test(cmd);
-  return hasTimeout || hasSelector;
-}
-function isDirectTestRunnerCommand(cmd) {
-  return /^(?:pytest|(?:npx\s+)?(?:jest|vitest)|go\s+test|cargo\s+test)\b/i.test(cmd);
-}
-function extractCdPrefixDirs(rawCmd) {
-  const prefixMatch = rawCmd.match(CD_PREFIX_RE);
-  if (prefixMatch === null) return [];
-  const dirs = [];
-  const segmentPattern = /cd\s+(?:"([^"]*)"|'([^']*)'|(\S+))[ \t]*(?:&&|;|\r?\n)/g;
-  let match;
-  while ((match = segmentPattern.exec(prefixMatch[0])) !== null) {
-    const dir = match[1] ?? match[2] ?? match[3];
-    if (dir !== void 0) dirs.push(dir);
-  }
-  return dirs;
-}
-function resolveCdHintPath(rawCmd, filePath, cwd) {
-  if (extractCdPrefixDirs(rawCmd).length === 0) return filePath;
-  return resolveIndexPath(filePath, cdPrefixCwd(rawCmd, cwd));
-}
-function cdPrefixCwd(rawCmd, cwd) {
-  let dir = cwd;
-  for (const target of extractCdPrefixDirs(rawCmd)) dir = resolveIndexPath(target, dir);
-  return dir;
-}
-function stripOutputPipeline(cmd) {
-  let inSingle = false;
-  let inDouble = false;
-  let cut = cmd.length;
-  let backslashes = 0;
-  for (let i = 0; i < cmd.length; i++) {
-    const ch = cmd[i];
-    if (ch === "\\") {
-      backslashes++;
-      continue;
-    }
-    const escaped = backslashes % 2 === 1;
-    backslashes = 0;
-    if (ch === "'" && !inDouble) {
-      if (!escaped) inSingle = !inSingle;
-    } else if (ch === '"' && !inSingle) {
-      if (!escaped) inDouble = !inDouble;
-    } else if (ch === "|" && !inSingle && !inDouble) {
-      if (cmd[i + 1] === "|") {
-        i++;
-        continue;
-      }
-      cut = i;
-      break;
+var SERIAL_GAP_MS = 1e3;
+var SERIAL_READS_BEFORE_HINT = 3;
+var ZERO_HIT_SEARCHES_BEFORE_BRAKE = 3;
+var MAX_BATCH_HINTS_PER_SESSION = 2;
+var MAX_SEARCH_BRAKES_PER_SESSION = 2;
+var STREAK_SUFFIX = ".call-streak";
+var TG_SEARCH_RE = /^(?:token-goat|tg)\s+(?:answer|semantic|symbol|refs|locate)\b/;
+var TG_MEANING_SEARCH_RE = /^(?:token-goat|tg)\s+(?:answer|semantic)\b/;
+var TG_READ_RE = /^(?:token-goat|tg)\s+(?:read|section|outline|skeleton|brief)\b/;
+var WRITE_REDIRECT_RE = /\d?>>?(?!\s*(?:&\d|\/dev\/null\b))/;
+function freshState() {
+  return { promptId: "", lastReadPostAt: 0, inFlight: false, serialRun: 0, batchShownInRun: false, batchShown: 0, batchVerdict: "none", zeroHits: 0, brakeShownInRun: false, brakeShown: 0, brakeVerdict: false };
+}
+function readState(target) {
+  const state = freshState();
+  try {
+    const parsed = JSON.parse(readFileSync(target, "utf8"));
+    if (parsed === null || typeof parsed !== "object") return state;
+    const p = parsed;
+    for (const key of Object.keys(state)) {
+      if (typeof p[key] === typeof state[key]) state[key] = p[key];
     }
+    if (!["none", "next_turn", "second_call"].includes(state.batchVerdict)) state.batchVerdict = "none";
+  } catch {
   }
-  let base = cmd.slice(0, cut);
-  let prev;
-  do {
-    prev = base;
-    const masked = base.replace(/"((?:[^"\\]|\\.)*)"/g, (_m, inner) => '"' + " ".repeat(inner.length) + '"').replace(/'([^']*)'/g, (_m, inner) => "'" + " ".repeat(inner.length) + "'");
-    const newMasked = masked.replace(/\s*(?:[0-9]*>&[0-9]+|[0-9&]*>>?\s*(?:"[^"]*"|'[^']*'|[^\s|]+))\s*$/, "");
-    if (newMasked.length < masked.length) {
-      base = base.slice(0, newMasked.length);
-    }
-  } while (base !== prev);
-  return base.trim();
-}
-function pipelineDivergenceNote(cmd, entryCommand) {
-  if (entryCommand === cmd) return "";
-  const preview = entryCommand.length > 60 ? entryCommand.slice(0, 57) + "..." : entryCommand;
-  return " (cached from a differently-piped run, `" + preview + "` \u2014 verify it covers what you need before trusting it)";
-}
-function extractCommand(event) {
-  const cmd = event.toolInput["command"];
-  return typeof cmd === "string" && cmd.trim() !== "" ? cmd.trim() : void 0;
-}
-var HEAD_MOVING_GIT_RE = /^\s*git\s+(?:checkout|switch|pull|merge|rebase|reset|cherry-pick)\b/i;
-var PATH_SCOPED_CHECKOUT_RE = /^\s*git\s+checkout\s+(?:\S.*?\s)?--(?:\s|$)/i;
-function isHeadMovingGitCommand(cmd) {
-  if (!HEAD_MOVING_GIT_RE.test(cmd)) return false;
-  if (PATH_SCOPED_CHECKOUT_RE.test(cmd)) return false;
-  return true;
+  return state;
 }
-var ORIG_HEAD_ELIGIBLE_GIT_RE = /^\s*git\s+(?:pull|merge|rebase)\b/i;
-var ORIG_HEAD_REFLOG_MSG_RE = /^(merge\s|rebase\s\(|pull\s)/i;
-var GIT_RESTORE_RE = /^\s*git\s+restore\b/i;
-var GIT_RESTORE_STAGED_ONLY_RE = /(?:^|\s)(?:--staged|-S)(?:\s|$)/;
-var GIT_STASH_APPLY_RE = /^\s*git\s+stash\s+(?:pop|apply)\b/i;
-var PATCH_APPLY_SEGMENT_RE = /^\s*(?:\S*[/\\])?(?:git\s+apply|patch)\b/i;
-var PATCH_APPLY_INSPECT_ONLY_RE = /(?:^|\s)--(?:check|stat|numstat|summary|dry-run)(?:\s|=|$)/i;
-function isFormatterWriteSegment(segment) {
-  return /(?:^|\s|[/\\])(?:prettier|eslint)\b/i.test(segment) && /(?:^|\s)--(?:write|fix)(?:\s|$)/i.test(segment);
-}
-function safeShlexSplit(segment) {
+function writeState(target, state) {
   try {
-    return shlexSplit(segment);
-  } catch {
-    return null;
-  }
-}
-function segmentCommandIs(segment, name2) {
-  return new RegExp("^\\s*(?:\\S*[/\\\\])?" + name2 + "(?:\\.exe)?\\b", "i").test(segment);
-}
-function extractSedInPlaceFiles(segment) {
-  if (!segmentCommandIs(segment, "sed")) return [];
-  const tokens = safeShlexSplit(segment);
-  if (tokens === null) return [];
-  const rest = tokens.slice(1);
-  const inPlaceIdx = rest.findIndex((t) => t === "--in-place" || t.startsWith("--in-place=") || /^-[a-zA-Z]*i/.test(t));
-  if (inPlaceIdx === -1) return [];
-  const files = [];
-  let scriptTaken = rest.some((t) => t === "-e" || t === "-f" || t.startsWith("--expression") || t.startsWith("--file"));
-  for (let i = 0; i < rest.length; i++) {
-    const t = rest[i];
-    if (i === inPlaceIdx) {
-      if (t === "-i" && rest[i + 1] === "") i++;
-      continue;
-    }
-    if (t === "-e" || t === "-f" || t === "--expression" || t === "--file") {
-      i++;
-      continue;
-    }
-    if (t.length > 1 && t.startsWith("-")) continue;
-    if (!scriptTaken) {
-      scriptTaken = true;
-      continue;
-    }
-    files.push(t);
-  }
-  return files;
-}
-function extractTeeFiles(segment) {
-  if (!segmentCommandIs(segment, "tee")) return [];
-  const tokens = safeShlexSplit(segment);
-  if (tokens === null) return [];
-  return tokens.slice(1).filter((t) => t.length > 0 && !t.startsWith("-"));
-}
-function extractRedirectTargets(segment) {
-  const targets = [];
-  const re = /(?:^|\s)[0-9]?>>?\s*("[^"]*"|'[^']*'|[^\s|&<>]+)/g;
-  let m;
-  while ((m = re.exec(segment)) !== null) {
-    const raw = m[1];
-    targets.push(raw.length >= 2 && (raw[0] === '"' || raw[0] === "'") ? raw.slice(1, -1) : raw);
-  }
-  return targets;
-}
-function extractGitRestorePathspecs(cmd) {
-  const m = /^\s*git\s+restore\b(.*)$/i.exec(cmd);
-  if (m === null) return [];
-  const tokens = safeShlexSplit(m[1] ?? "");
-  if (tokens === null) return [];
-  const dashDash = tokens.indexOf("--");
-  if (dashDash !== -1) return tokens.slice(dashDash + 1);
-  const specs = [];
-  let skipNext = false;
-  for (const t of tokens) {
-    if (skipNext) {
-      skipNext = false;
-      continue;
-    }
-    if (t === "-s" || t === "--source") {
-      skipNext = true;
-      continue;
-    }
-    if (t.startsWith("-")) continue;
-    specs.push(t);
-  }
-  return specs;
-}
-function gitRepoRoot(gitDir) {
-  const toplevel = runGit(["rev-parse", "--show-toplevel"], { cwd: gitDir, timeoutMs: 5e3 });
-  return toplevel.exitCode === 0 && toplevel.stdout.trim() !== "" ? toplevel.stdout.trim() : gitDir;
-}
-function expandGitPathspecs(specs, gitDir) {
-  if (specs.length === 0) return [];
-  const listed = runGit(["ls-files", "--full-name", "--", ...specs], { cwd: gitDir, timeoutMs: 5e3 });
-  if (listed.exitCode !== 0) return [];
-  const repoRoot = gitRepoRoot(gitDir);
-  return listed.stdout.split("\n").map((l) => l.trim()).filter((l) => l.length > 0).map((rel) => resolveIndexPath(rel, repoRoot));
-}
-function workingTreeStatusPaths(gitDir) {
-  const status = runGit(["status", "--porcelain"], { cwd: gitDir, timeoutMs: 5e3 });
-  if (status.exitCode !== 0) return [];
-  const repoRoot = gitRepoRoot(gitDir);
-  const out = [];
-  for (const line of status.stdout.split("\n")) {
-    if (line.length < 4) continue;
-    let rel = line.slice(3).trim();
-    if (rel.length === 0) continue;
-    const arrow = rel.lastIndexOf(" -> ");
-    if (arrow !== -1) rel = rel.slice(arrow + 4);
-    if (rel.startsWith('"')) {
-      try {
-        rel = JSON.parse(rel);
-      } catch {
-        continue;
-      }
-    }
-    out.push(resolveIndexPath(rel, repoRoot));
-  }
-  return out;
-}
-function enqueueRewrittenPath(absPath) {
-  if (/(?:^|[/\\])(?:NUL|nul)$/.test(absPath) || absPath.replace(/\\/g, "/").endsWith("/dev/null")) return;
-  try {
-    if (!statSync(absPath).isFile()) return;
-  } catch {
-    return;
-  }
-  enqueueDirtyPathSafe(absPath, { alreadyResolved: true });
-}
-function enqueueNonHeadMovingRewrites(cmd, rawCmd, cwd) {
-  const atCwd = (f) => resolveIndexPath(resolveCdHintPath(rawCmd, f, cwd), cwd);
-  const paths = [];
-  let needsStatusSweep = GIT_STASH_APPLY_RE.test(cmd);
-  if (GIT_RESTORE_RE.test(cmd) && !GIT_RESTORE_STAGED_ONLY_RE.test(cmd)) {
-    paths.push(...expandGitPathspecs(extractGitRestorePathspecs(cmd), cwd));
-  }
-  for (const segment of splitShellSegments(cmd)) {
-    if (PATCH_APPLY_SEGMENT_RE.test(segment) && !PATCH_APPLY_INSPECT_ONLY_RE.test(segment)) needsStatusSweep = true;
-    if (isFormatterWriteSegment(segment)) needsStatusSweep = true;
-    for (const f of extractSedInPlaceFiles(segment)) paths.push(atCwd(f));
-    for (const f of extractTeeFiles(segment)) paths.push(atCwd(f));
-    for (const f of extractRedirectTargets(segment)) paths.push(atCwd(f));
-  }
-  if (needsStatusSweep) paths.push(...workingTreeStatusPaths(cwd));
-  for (const p of paths) enqueueRewrittenPath(p);
-}
-var PIPELINE_PASSTHROUGH_HEADS = /* @__PURE__ */ new Set(["head", "tail", "cat", "tee", "less", "more"]);
-var CI_FILTER_NAMES = /^(?:generic-ci|jest|vitest|pytest|go_test|cargo_test|cargo|go|make|cmake|gradle|maven|dotnet|turbo|nx|lerna|webpack|eslint|ruff|clippy|flake8|mypy|prettier|tsc)$/;
-function isCiBuildTestSegment(cleaned, cwd) {
-  if (isTestRunnerCommand(cleaned) || isBuildCommand(cleaned) || isTscCommand(cleaned)) return true;
-  if (/^\s*(npm|pnpm|yarn|bun)\s+(run\s+)?(test|build|lint|typecheck|check|ci|guards)\b/i.test(cleaned)) return true;
-  if (/^\s*(cargo|go|dotnet|make|gradle|mvn|pytest|vitest|jest|eslint|ruff)\b/i.test(cleaned)) return true;
-  const detected = detectFromCommand(cleaned, cwd ?? void 0);
-  if (detected !== null && CI_FILTER_NAMES.test(detected.filter.name)) return true;
-  return false;
-}
-function pipelineShapeFilter(cmd, cwd) {
-  if (hasUnquotedOperator(cmd, ["&&", "||", ";"])) {
-    const forSplit2 = cmd.replace(/\s2>(?:&1|\/dev\/null)/g, "");
-    if (hasBareBackgroundOrNewline(forSplit2)) return null;
-    const segments2 = splitShellSegments(forSplit2);
-    if (segments2.length >= 2) {
-      let recognizedCiCount = 0;
-      for (const segment of segments2) {
-        const cleaned = stripOutputPipeline(segment.trim());
-        if (cleaned.length === 0) continue;
-        if (isCiBuildTestSegment(cleaned, cwd)) {
-          recognizedCiCount++;
-        }
-      }
-      if (recognizedCiCount > 0) {
-        const ci = filterByName("generic-ci");
-        return ci === null ? null : { filter: ci, argv: [] };
-      }
-    }
-    return null;
-  }
-  const forSplit = cmd.replace(/\s2>(?:&1|\/dev\/null)/g, "");
-  if (hasBareBackgroundOrNewline(forSplit)) return null;
-  const segments = splitShellSegments(forSplit);
-  if (segments.length < 2) return null;
-  for (const segment of segments.slice(1)) {
-    const head = safeShlexSplit(segment)?.[0];
-    if (head === void 0) return null;
-    if (!PIPELINE_PASSTHROUGH_HEADS.has(head.replace(/^.*[/\\]/, ""))) return null;
-  }
-  const detected = detectFromCommand(stripOutputPipeline(cmd), cwd ?? void 0);
-  return detected === null ? null : { filter: detected.filter, argv: detected.argv };
-}
-function isFullRecallCommand(cmd) {
-  const forSplit = cmd.replace(/\s2>(?:&1|\/dev\/null)/g, "");
-  if (hasBareBackgroundOrNewline(forSplit)) return false;
-  const first2 = splitShellSegments(forSplit)[0];
-  if (first2 === void 0 || !segmentCommandIs(first2, "token-goat")) return false;
-  const tokens = safeShlexSplit(stripOutputPipeline(first2));
-  if (tokens === null) return false;
-  return Object.values(RECALL_COMMAND).includes(tokens[1] ?? "") && tokens.includes("--full");
-}
-function pureFileReadPath(cmd) {
-  const single = extractCatFile(cmd)?.filePath ?? extractHeadFile(cmd)?.filePath ?? extractTailFile(cmd)?.filePath ?? extractLineRangeRead(cmd)?.filePath;
-  if (single !== void 0) return single;
-  return singleFileCompoundReadPath(cmd);
-}
-function singleFileCompoundReadPath(cmd) {
-  const reads = extractLineRangeReadsCompound(cmd);
-  if (reads === null || reads.length !== 1) return null;
-  return reads[0]?.filePath ?? null;
-}
-function deliveredLineNumbers(cmd, lineCount) {
-  const ranged = extractLineRangeRead(cmd);
-  if (ranged !== null) {
-    const nums = [];
-    for (const [lo, hi] of ranged.ranges) for (let n = lo; n <= hi; n++) nums.push(n);
-    if (nums.length === 0) return null;
-    while (nums.length < lineCount) nums.push((nums[nums.length - 1] ?? 0) + 1);
-    return nums;
-  }
-  if (extractCatFile(cmd) !== null || extractHeadFile(cmd) !== null) return Array.from({ length: lineCount }, (_, i) => i + 1);
-  if (singleFileCompoundReadPath(cmd) !== null) return Array.from({ length: lineCount }, () => null);
-  return null;
-}
-var WHOLE_FILE_DUMP_RE = /^(?:(?:cat|type|Get-Content|gc)|(?:head|tail)[ \t]+-n[ \t]+\d+)[ \t]+(?:"([A-Za-z0-9._\-/\\:+@ ]+)"|'([A-Za-z0-9._\-/\\:+@ ]+)'|([A-Za-z0-9._\-/\\:+@]+))(?:[ \t]+2>(?:&1|\/dev\/null))?[ \t]*$/i;
-function isWholeFileDump(cmd, extractedPath) {
-  const m = WHOLE_FILE_DUMP_RE.exec(cmd);
-  if (m === null) return false;
-  const shaped = m[1] ?? m[2] ?? m[3];
-  return shaped !== void 0 && shaped === extractedPath;
-}
-function unwrapCompressCommand(executed) {
-  const t = executed.trim();
-  if (!/^(?:token-goat|tg)\s+compress\b/.test(t)) return null;
-  let argv;
-  try {
-    argv = shlexSplit(t);
-  } catch {
-    return null;
-  }
-  for (let i = 0; i + 1 < argv.length; i++) {
-    const tok = argv[i];
-    if (tok === "-c" || tok === "--cmd") return argv[i + 1] ?? null;
-    if (tok === "--cmd-b64") {
-      try {
-        return Buffer.from(argv[i + 1] ?? "", "base64").toString("utf8");
-      } catch {
-        return null;
-      }
-    }
-  }
-  return null;
-}
-function detectUnbalancedShellSyntax(cmd) {
-  let inSingle = false;
-  let inDouble = false;
-  let i = 0;
-  while (i < cmd.length) {
-    const ch = cmd[i];
-    if (inSingle) {
-      if (ch === "'") {
-        inSingle = false;
-      }
-      i++;
-      continue;
-    }
-    if (inDouble) {
-      if (ch === "\\" && i + 1 < cmd.length) {
-        i += 2;
-        continue;
-      }
-      if (ch === '"') {
-        inDouble = false;
-      }
-      i++;
-      continue;
-    }
-    if (ch === "\\" && i + 1 < cmd.length) {
-      i += 2;
-      continue;
-    }
-    if (ch === "$" && cmd[i + 1] === "(" && cmd[i + 2] === "(") {
-      let depth = 2;
-      let j = i + 3;
-      while (j < cmd.length && depth > 0) {
-        if (cmd[j] === "(") depth++;
-        else if (cmd[j] === ")") depth--;
-        j++;
-      }
-      i = j;
-      continue;
-    }
-    if (ch === "$" && cmd[i + 1] === "'") {
-      let j = i + 2;
-      let closed = false;
-      while (j < cmd.length) {
-        if (cmd[j] === "\\") {
-          j += 2;
-          continue;
-        }
-        if (cmd[j] === "'") {
-          j++;
-          closed = true;
-          break;
-        }
-        j++;
-      }
-      if (!closed) {
-        inSingle = true;
-        break;
-      }
-      i = j;
-      continue;
-    }
-    if (ch === "#" && (i === 0 || /\s/.test(cmd[i - 1] ?? ""))) {
-      const nl2 = cmd.indexOf("\n", i);
-      i = nl2 === -1 ? cmd.length : nl2 + 1;
-      continue;
-    }
-    if (ch === "'") {
-      inSingle = true;
-      i++;
-      continue;
-    }
-    if (ch === '"') {
-      inDouble = true;
-      i++;
-      continue;
-    }
-    if (ch === "<" && i + 1 < cmd.length && cmd[i + 1] === "<") {
-      if (i + 2 < cmd.length && cmd[i + 2] === "<") {
-        i += 3;
-        continue;
-      }
-      let j = i + 2;
-      let hasIndentModifier = false;
-      if (j < cmd.length && (cmd[j] === "-" || cmd[j] === "~")) {
-        hasIndentModifier = true;
-        j++;
-      }
-      while (j < cmd.length && cmd[j] === " ") {
-        j++;
-      }
-      if (j < cmd.length) {
-        let delimStart = j;
-        if (cmd[j] === '"' || cmd[j] === "'") {
-          delimStart = j + 1;
-          const quoteChar = cmd[j];
-          let delimEnd = delimStart;
-          while (delimEnd < cmd.length && cmd[delimEnd] !== quoteChar) {
-            delimEnd++;
-          }
-          if (delimEnd >= cmd.length) {
-            return "an unclosed quote in a heredoc opener";
-          }
-          j = delimEnd + 1;
-        } else {
-          let delimEnd = delimStart;
-          while (delimEnd < cmd.length && /\w/.test(cmd.charAt(delimEnd))) {
-            delimEnd++;
-          }
-          j = delimEnd;
-        }
-        const delimiter = cmd.slice(delimStart, j).replace(/["']/g, "");
-        if (delimiter) {
-          let scanPos = j;
-          let terminatorEnd = -1;
-          while (scanPos <= cmd.length) {
-            const nl2 = cmd.indexOf("\n", scanPos);
-            const lineEnd = nl2 === -1 ? cmd.length : nl2;
-            let line = cmd.slice(scanPos, lineEnd);
-            if (line.endsWith("\r")) {
-              line = line.slice(0, -1);
-            }
-            const isMatch = hasIndentModifier ? line.trim() === delimiter : line === delimiter;
-            if (isMatch) {
-              terminatorEnd = nl2 === -1 ? cmd.length : nl2 + 1;
-              break;
-            }
-            if (nl2 === -1) break;
-            scanPos = nl2 + 1;
-          }
-          if (terminatorEnd === -1) {
-            return `an unterminated heredoc (${delimiter} never appears on its own line)`;
-          }
-          i = terminatorEnd;
-          continue;
-        }
-      }
-    }
-    i++;
-  }
-  if (inSingle) {
-    return "an unclosed single quote";
-  }
-  if (inDouble) {
-    return "an unclosed double quote";
-  }
-  return null;
-}
-
-// src/call_streak.ts
-var SERIAL_GAP_MS = 1e3;
-var SERIAL_READS_BEFORE_HINT = 3;
-var ZERO_HIT_SEARCHES_BEFORE_BRAKE = 3;
-var MAX_BATCH_HINTS_PER_SESSION = 2;
-var MAX_SEARCH_BRAKES_PER_SESSION = 2;
-var STREAK_SUFFIX = ".call-streak";
-var TG_SEARCH_RE = /^(?:token-goat|tg)\s+(?:answer|semantic|symbol|refs|locate)\b/;
-var TG_MEANING_SEARCH_RE = /^(?:token-goat|tg)\s+(?:answer|semantic)\b/;
-var TG_READ_RE = /^(?:token-goat|tg)\s+(?:read|section|outline|skeleton|brief)\b/;
-var WRITE_REDIRECT_RE = /\d?>>?(?!\s*(?:&\d|\/dev\/null\b))/;
-function freshState() {
-  return { promptId: "", lastReadPostAt: 0, inFlight: false, serialRun: 0, batchShownInRun: false, batchShown: 0, batchVerdict: "none", zeroHits: 0, brakeShownInRun: false, brakeShown: 0, brakeVerdict: false };
-}
-function readState(target) {
-  const state = freshState();
-  try {
-    const parsed = JSON.parse(readFileSync(target, "utf8"));
-    if (parsed === null || typeof parsed !== "object") return state;
-    const p = parsed;
-    for (const key of Object.keys(state)) {
-      if (typeof p[key] === typeof state[key]) state[key] = p[key];
-    }
-    if (!["none", "next_turn", "second_call"].includes(state.batchVerdict)) state.batchVerdict = "none";
-  } catch {
-  }
-  return state;
-}
-function writeState(target, state) {
-  try {
-    ensureDirSync(dirname(target));
-    writeFileSync(target, JSON.stringify(state), "utf8");
+    ensureDirSync(dirname(target));
+    writeFileSync(target, JSON.stringify(state), "utf8");
   } catch {
   }
 }
@@ -1044,15 +662,27 @@ function queuePendingContext(stateKey, text) {
   const target = sessionSidecarPath(stateKey, PENDING_SUFFIX);
   if (target === null) return;
   try {
-    const existing = readPending(target);
-    const merged = existing === null ? trimmed : `${existing}
-${trimmed}`;
-    const capped = merged.length <= MAX_PENDING_CONTEXT_BYTES ? merged : merged.slice(merged.length - MAX_PENDING_CONTEXT_BYTES);
+    const capped = fitPending(readPending(target), trimmed);
     ensureDirSync(dirname2(target));
     writeFileSync2(target, capped, "utf8");
   } catch {
   }
 }
+function replacePendingContextBlock(stateKey, text, blockStart) {
+  const target = sessionSidecarPath(stateKey, PENDING_SUFFIX);
+  if (target === null) return;
+  try {
+    const existing = readPending(target);
+    const at = existing === null ? -1 : existing.indexOf(blockStart);
+    if (existing !== null && at >= 0) {
+      const kept = existing.slice(0, at).trim();
+      if (kept === "") rmSync(target, { force: true });
+      else writeFileSync2(target, kept, "utf8");
+    }
+  } catch {
+  }
+  queuePendingContext(stateKey, text);
+}
 function peekPendingContext(stateKey) {
   const target = sessionSidecarPath(stateKey, PENDING_SUFFIX);
   return target === null ? null : readPending(target);
@@ -1069,6 +699,18 @@ function commitPendingContext(stateKey, delivered) {
   } catch {
   }
 }
+function fitPending(existing, text) {
+  if (existing !== null) {
+    const merged = `${existing}
+${text}`;
+    if (merged.length <= MAX_PENDING_CONTEXT_BYTES) return merged;
+  }
+  if (text.length <= MAX_PENDING_CONTEXT_BYTES) return text;
+  const head = text.slice(0, MAX_PENDING_CONTEXT_BYTES);
+  const lineEnd = head.lastIndexOf("\n");
+  if (lineEnd > 0) return head.slice(0, lineEnd).trimEnd();
+  return /[\uD800-\uDBFF]$/.test(head) ? head.slice(0, -1) : head;
+}
 function readPending(target) {
   try {
     const raw = readFileSync2(target, "utf8").trim();
@@ -1192,107 +834,847 @@ function shouldSuppressDuplicateVscodeHook(event, harness) {
   }
 }
 
-// src/hooks_grep.ts
+// src/hooks_read_post.ts
 init_define_import_meta_env();
-function grepIntInput(toolInput, key) {
-  const value = toolInput[key];
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  if (typeof value === "string" && value.trim() !== "") {
-    const n = Number(value);
-    if (Number.isFinite(n)) return n;
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+
+// src/served_lines.ts
+init_define_import_meta_env();
+var SERVED_RUN_COMPARISON_BUDGET = 4e5;
+var SERVED_RUN_ANCHORS_PER_LINE = 32;
+function indexServedBody(id, output) {
+  const lines = output.split("\n");
+  const positions = /* @__PURE__ */ new Map();
+  for (let j = 0; j < lines.length; j++) {
+    const key = lines[j] ?? "";
+    let at = positions.get(key);
+    if (at === void 0) {
+      at = [];
+      positions.set(key, at);
+    }
+    if (at.length < SERVED_RUN_ANCHORS_PER_LINE) at.push(j);
+  }
+  return { id, lines, positions };
+}
+function longestServedRun(rows, from, to, bodies, budget) {
+  let best = null;
+  for (const body of bodies) {
+    for (let i = from; i < to; i++) {
+      if (best !== null && to - i <= best.len) break;
+      const anchors = body.positions.get(rows[i]?.text ?? "");
+      if (anchors === void 0) continue;
+      for (const j of anchors) {
+        let k = 0;
+        while (i + k < to && j + k < body.lines.length && rows[i + k]?.text === body.lines[j + k]) {
+          k++;
+          if (--budget.left <= 0) return best !== null && best.len > 0 ? best : null;
+        }
+        if (best === null || k > best.len) best = { start: i, len: k, id: body.id };
+      }
+    }
+  }
+  return best !== null && best.len > 0 ? best : null;
+}
+var MAX_SERVED_ELISIONS = 3;
+function servedRunNotice(firstLine, lastLine, id, len) {
+  const which = firstLine !== null && lastLine !== null ? "lines " + firstLine + "-" + lastLine : len + " lines here";
+  return "[token-goat] " + which + " were already served verbatim in this session; withheld here. Recall them with `token-goat bash-output " + id + " --full`.";
+}
+function renderedRunBytes(rows, start, len) {
+  let bytes = 0;
+  for (let i = start; i < start + len; i++) bytes += Buffer.byteLength(rows[i]?.raw ?? "", "utf-8") + 1;
+  return bytes;
+}
+function planServedElisions(rows, bodies) {
+  if (rows.length === 0 || bodies.length === 0) return [];
+  const budget = { left: SERVED_RUN_COMPARISON_BUDGET };
+  let spans = [[0, rows.length]];
+  const cuts = [];
+  for (let pass = 0; pass < MAX_SERVED_ELISIONS; pass++) {
+    let bestRun = null;
+    let bestSpan = -1;
+    for (let s = 0; s < spans.length; s++) {
+      const span = spans[s];
+      if (span === void 0) continue;
+      const run = longestServedRun(rows, span[0], span[1], bodies, budget);
+      if (run !== null && (bestRun === null || run.len > bestRun.len)) {
+        bestRun = run;
+        bestSpan = s;
+      }
+    }
+    if (bestRun === null || bestSpan < 0) break;
+    const first2 = rows[bestRun.start];
+    const last = rows[bestRun.start + bestRun.len - 1];
+    if (first2 === void 0 || last === void 0) break;
+    const noticeBytes = Buffer.byteLength(servedRunNotice(first2.no, last.no, bestRun.id, bestRun.len), "utf-8") + 1;
+    if (renderedRunBytes(rows, bestRun.start, bestRun.len) <= noticeBytes) break;
+    cuts.push(bestRun);
+    const chosen = spans[bestSpan];
+    if (chosen === void 0) break;
+    const rebuilt = [];
+    for (let s = 0; s < spans.length; s++) {
+      const span = spans[s];
+      if (span === void 0) continue;
+      if (s !== bestSpan) {
+        rebuilt.push(span);
+        continue;
+      }
+      if (bestRun.start > chosen[0]) rebuilt.push([chosen[0], bestRun.start]);
+      if (bestRun.start + bestRun.len < chosen[1]) rebuilt.push([bestRun.start + bestRun.len, chosen[1]]);
+    }
+    spans = rebuilt;
   }
-  return void 0;
+  cuts.sort((a, b) => a.start - b.start);
+  return cuts;
 }
-function grepSignature(toolInput) {
-  const pattern = toolInput["pattern"];
-  if (typeof pattern !== "string" || pattern === "") return null;
-  const path6 = typeof toolInput["path"] === "string" ? toolInput["path"] : "";
-  const outputMode = typeof toolInput["output_mode"] === "string" ? toolInput["output_mode"] : "files_with_matches";
-  const glob = typeof toolInput["glob"] === "string" ? toolInput["glob"] : "";
-  const type = typeof toolInput["type"] === "string" ? toolInput["type"] : "";
-  const caseInsensitive = toolInput["-i"] === true;
-  const onlyMatching = toolInput["-o"] === true;
-  const multiline = toolInput["multiline"] === true;
-  const lineNumbers = toolInput["-n"] !== false;
-  const contextA = grepIntInput(toolInput, "-A");
-  const contextB = grepIntInput(toolInput, "-B");
-  const contextC = grepIntInput(toolInput, "-C") ?? grepIntInput(toolInput, "context");
-  const headLimit = grepIntInput(toolInput, "head_limit");
-  const offset = grepIntInput(toolInput, "offset");
-  return JSON.stringify([
-    pattern,
-    path6,
-    outputMode,
-    glob,
-    type,
-    caseInsensitive,
-    onlyMatching,
-    multiline,
-    lineNumbers,
-    contextA,
-    contextB,
-    contextC,
-    headLimit,
-    offset
-  ]);
+
+// src/read_shape.ts
+init_define_import_meta_env();
+import { readFileSync as readFileSync3, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname3 } from "node:path";
+var SHAPES = /* @__PURE__ */ new Set(["outline", "skeleton", "fold", "truncated", "partial"]);
+var SHAPE_SUFFIX = ".read-shape";
+var MAX_ENTRIES = 512;
+function load(target) {
+  try {
+    const parsed = JSON.parse(readFileSync3(target, "utf8"));
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
 }
-var { post: dedupPostHandler, pre: preGrepDedupHandler } = makeDedupHintHandlers({
-  toolName: "Grep",
-  buildSignature: grepSignature,
-  recordQuery: recordGrepQuery,
-  getMatchCount: getGrepMatchCount,
-  minMatchesConfigKey: "grep_dedup_min_matches",
-  statName: "grep_dedup_hint"
-});
-var CONTENT_LINE_RE = /^(.+?):(\d+):(.*)$/s;
-function foldGrepContentHandler(event) {
+function recordReadShape(stateKey, file, shape) {
+  const target = sessionSidecarPath(stateKey, SHAPE_SUFFIX);
+  if (target === null) return;
   try {
-    if (getToolName(event) !== "Grep") return passOutput();
-    const toolInput = getToolInput(event);
-    if (toolInput["output_mode"] !== "content") return passOutput();
-    if (toolInput["multiline"] === true) return passOutput();
-    if (toolInput["-A"] !== void 0 || toolInput["-B"] !== void 0 || toolInput["-C"] !== void 0 || toolInput["context"] !== void 0) {
-      return passOutput();
-    }
-    if (toolInput["-n"] === false) return passOutput();
-    const rawText = extractToolResponseField(event.raw, OUTPUT_FIRST_TOOL_RESPONSE_KEYS);
-    if (!rawText) return passOutput();
-    const text = redactSecrets(rawText).text;
-    const rawLines = text.split(/\r\n|\r|\n/);
-    const parsed = [];
-    for (const line of rawLines) {
-      if (line.trim() === "") continue;
-      const m = CONTENT_LINE_RE.exec(line);
-      if (!m) return passOutput();
-      parsed.push({ file: m[1], lineNo: m[2], rest: m[3] });
-    }
-    if (parsed.length === 0) return passOutput();
-    const order = [];
-    const groups = /* @__PURE__ */ new Map();
-    for (const p of parsed) {
-      let group = groups.get(p.file);
-      if (group === void 0) {
-        group = [];
-        groups.set(p.file, group);
-        order.push(p.file);
-      }
-      group.push({ lineNo: p.lineNo, rest: p.rest });
+    const shapes = load(target);
+    if (shape === null) {
+      if (!Object.hasOwn(shapes, file)) return;
+      delete shapes[file];
+    } else {
+      delete shapes[file];
+      shapes[file] = shape;
     }
-    const hasSharedFile = order.some((f) => groups.get(f).length >= 2);
-    if (!hasSharedFile) return passOutput();
-    const foldedLines = [];
-    for (const f of order) {
-      foldedLines.push(f);
-      for (const { lineNo, rest } of groups.get(f)) {
-        foldedLines.push(`  ${lineNo}: ${rest}`);
-      }
+    const keys = Object.keys(shapes);
+    if (keys.length === 0) {
+      rmSync3(target, { force: true });
+      return;
     }
-    const rewritten = foldedLines.join("\n");
-    const originalBytes = Buffer.byteLength(text, "utf-8");
-    const rewrittenBytes = Buffer.byteLength(rewritten, "utf-8");
-    if (!isRewriteWorthwhile({
-      originalBytes,
-      rewrittenBytes,
+    for (const k of keys.slice(0, Math.max(0, keys.length - MAX_ENTRIES))) delete shapes[k];
+    ensureDirSync(dirname3(target));
+    writeFileSync3(target, JSON.stringify(shapes), "utf8");
+  } catch {
+  }
+}
+function readShapeOf(stateKey, file) {
+  const target = sessionSidecarPath(stateKey, SHAPE_SUFFIX);
+  if (target === null) return null;
+  const shapes = load(target);
+  const shape = Object.hasOwn(shapes, file) ? shapes[file] : void 0;
+  return shape !== void 0 && SHAPES.has(shape) ? shape : null;
+}
+
+// src/fold_delivery.ts
+init_define_import_meta_env();
+import { readFileSync as readFileSync4, statSync as statSync2 } from "node:fs";
+var BODY_FOLD_KEEP_LINES = 8;
+var BODY_FOLD_MIN_SPAN = 20;
+var COMMENT_FOLD_KEEP_LINES = 2;
+var COMMENT_FOLD_MIN_BLOCK = 12;
+var BODY_FOLD_SYMBOL_LIMIT = 1e4;
+function bodyFoldNotice(name2, firstLine, lastLine, shownPath, declLine) {
+  const n = lastLine - firstLine + 1;
+  const anchor = declLine === void 0 ? "" : `@${declLine}`;
+  const safeName = displaySafeText(name2);
+  return `... ${n} more lines of ${safeName} (${firstLine}-${lastLine}) folded -- token-goat read "${shownPath}::${safeName}${anchor}"`;
+}
+function foldingEnabled() {
+  const hints = loadConfig().hints;
+  return hints.fold_code_bodies || hints.fold_comment_blocks || hints.fold_prose_paragraphs;
+}
+var PROSE_FOLDABLE_EXT_RE = /\.(?:md|mdx|markdown)$/i;
+function isProseFoldablePath(normalizedPath) {
+  return PROSE_FOLDABLE_EXT_RE.test(normalizedPath);
+}
+function proseFoldNotice(keep, line, shownPath, normalizedPath) {
+  const section = findContainingSection(normalizedPath, line, line);
+  if (section === null) return null;
+  return `${displaySafeText(keep)} ... rest of paragraph folded (line ${line}) -- token-goat section "${shownPath}::${displaySafeText(section.heading)}"`;
+}
+function commentFoldNotice(firstLine, lastLine, shownPath) {
+  const n = lastLine - firstLine + 1;
+  return `... ${n} more comment lines (${firstLine}-${lastLine}) folded -- Read "${shownPath}" with offset=${firstLine}, limit=${n}`;
+}
+var ALIGNED_LAYOUT_NOTE = "Every line shows its real line number: each withheld run opens with one notice line on the run's first line (a `...` pointer, or a `[token-goat] lines ... were already served` notice), and the rest of the run is left as empty lines.";
+function pushWithheld(out, notice, len, layout) {
+  if (layout === "compact") {
+    out.push(notice);
+    return;
+  }
+  out.push(notice.replace(/\r?\n/g, " "));
+  for (let i = 1; i < len; i++) out.push("");
+}
+function alignedPaddingBytes(len, layout) {
+  return layout === "aligned" ? Math.max(0, len - 1) : 0;
+}
+var FOLD_SPAN_PARSE_MAX_BYTES = 4e5;
+function parseFoldSpansFromDisk(normalizedPath, rows) {
+  try {
+    const onDisk = hostPathOfIndexKey(normalizedPath);
+    if (statSync2(onDisk).size > FOLD_SPAN_PARSE_MAX_BYTES) return [];
+    const language = detectLanguage(normalizedPath);
+    if (!isTreeSitterAvailable(language)) return [];
+    const fileText = readFileSync4(onDisk, "utf-8");
+    const diskLines = fileText.split("\n");
+    for (const row of rows) {
+      const disk = diskLines[row.no - 1];
+      if (disk === void 0 || disk.replace(/\r$/, "") !== row.text.replace(/\r$/, "")) return [];
+    }
+    const symbols = parseSourceSymbolsTreeSitterOnly(fileText, normalizedPath, language);
+    if (symbols === null) return [];
+    return symbols.slice(0, BODY_FOLD_SYMBOL_LIMIT).map((s) => ({ name: s.name, kind: s.kind, lineStart: s.lineStart, lineEnd: s.lineEnd }));
+  } catch {
+    return [];
+  }
+}
+function resolveFoldSpans(normalizedPath, hasCommentSyntax, rows) {
+  try {
+    const entry = getFileEntry(normalizedPath);
+    if (entry !== null && entry.sha !== "" && !isVirtualIndexedPath(normalizedPath) && entry.sha === fingerprintFile(hostPathOfIndexKey(normalizedPath)) && entry.parserSha === parserFingerprintForLanguage(entry.language)) {
+      return querySymbols({ filePath: normalizedPath, limit: BODY_FOLD_SYMBOL_LIMIT });
+    }
+    if (hasCommentSyntax) enqueueDirtyPathSafe(normalizedPath);
+  } catch {
+  }
+  return parseFoldSpansFromDisk(normalizedPath, rows);
+}
+function strictlyInteriorOnWindow(folds, rowCount, windowed) {
+  if (!windowed) return [...folds];
+  return folds.filter((f) => f.startIdx > 0 && f.startIdx + f.len < rowCount);
+}
+function foldDelivery(rows, normalizedPath, shownPath, windowed = false, layout = "compact") {
+  const syntax = commentSyntaxFor(normalizedPath);
+  const foldBodies = loadConfig().hints.fold_code_bodies;
+  const spans = foldBodies ? resolveFoldSpans(normalizedPath, syntax !== null, rows) : [];
+  const bodyFolds = foldBodies ? planBodyFolds(rows, spans, BODY_FOLD_KEEP_LINES, BODY_FOLD_MIN_SPAN) : [];
+  const claimed = /* @__PURE__ */ new Set();
+  for (const fold of bodyFolds) for (let i = fold.startIdx; i < fold.startIdx + fold.len; i++) claimed.add(i);
+  const commentFolds = loadConfig().hints.fold_comment_blocks ? strictlyInteriorOnWindow(planCommentFolds(rows, syntax, COMMENT_FOLD_KEEP_LINES, COMMENT_FOLD_MIN_BLOCK, claimed), rows.length, windowed) : [];
+  for (const fold of commentFolds) for (let i = fold.startIdx; i < fold.startIdx + fold.len; i++) claimed.add(i);
+  const proseFolds = isProseFoldablePath(normalizedPath) && loadConfig().hints.fold_prose_paragraphs ? strictlyInteriorOnWindow(planProseFolds(rows, claimed), rows.length, windowed).filter((f) => findContainingSection(normalizedPath, f.firstLine, f.firstLine) !== null) : [];
+  const folds = mergeFolds(mergeFolds(bodyFolds, commentFolds), proseFolds);
+  if (folds.length === 0) return null;
+  const numbered = [];
+  const raw = [];
+  let at = 0;
+  for (const fold of folds) {
+    for (let i = at; i < fold.startIdx; i++) {
+      numbered.push(rows[i]?.raw ?? "");
+      raw.push(rows[i]?.text ?? "");
+    }
+    let notice;
+    switch (fold.kind) {
+      case "comment":
+        notice = commentFoldNotice(fold.firstLine, fold.lastLine, shownPath);
+        break;
+      case "prose":
+        notice = proseFoldNotice(fold.keep ?? "", fold.firstLine, shownPath, normalizedPath);
+        break;
+      case "body":
+        notice = bodyFoldNotice(fold.name, fold.firstLine, fold.lastLine, shownPath, fold.declLine);
+        break;
+      default: {
+        const unreachable = fold.kind;
+        throw new Error(`unhandled fold kind: ${String(unreachable)}`);
+      }
+    }
+    if (notice === null) {
+      for (let i = fold.startIdx; i < fold.startIdx + fold.len; i++) {
+        numbered.push(rows[i]?.raw ?? "");
+        raw.push(rows[i]?.text ?? "");
+      }
+      at = fold.startIdx + fold.len;
+      continue;
+    }
+    pushWithheld(numbered, notice, fold.len, layout);
+    at = fold.startIdx + fold.len;
+  }
+  for (let i = at; i < rows.length; i++) {
+    numbered.push(rows[i]?.raw ?? "");
+    raw.push(rows[i]?.text ?? "");
+  }
+  return { numbered, raw, folds };
+}
+
+// src/fold_structure.ts
+init_define_import_meta_env();
+var OUTLINE_MIN_BODY_BYTES = 8e3;
+var OUTLINE_MIN_HEADINGS = 6;
+var OUTLINE_MAX_REPLACEMENT_RATIO = 0.4;
+var SKELETON_MIN_BODY_BYTES = 12e3;
+var SKELETON_MIN_SYMBOLS = 8;
+var SKELETON_MAX_REPLACEMENT_RATIO = 0.4;
+function outlineLeadInRows(rows, headings) {
+  const opensWithH1 = headings[0]?.level === 1;
+  const boundary = opensWithH1 ? headings.find((h, i) => i > 0 && h.level === 2) : headings[0];
+  if (boundary === void 0) return [];
+  const boundaryIdx = rows.findIndex((r) => r.no === boundary.lineNumber);
+  return boundaryIdx > 0 ? rows.slice(0, boundaryIdx) : [];
+}
+function capLeadIn(rows) {
+  return { rows: [...rows], notice: null };
+}
+function planMarkdownOutline(rows, normalizedPath, shownPath, originalBytes, layout = "compact") {
+  if (!loadConfig().hints.outline_large_documents) return null;
+  if (!isProseFoldablePath(normalizedPath)) return null;
+  if (originalBytes < OUTLINE_MIN_BODY_BYTES) return null;
+  const fileText = rows.map((r) => r.text).join("\n");
+  const headings = extractMarkdownHeadings(fileText);
+  if (headings.length < OUTLINE_MIN_HEADINGS) return null;
+  const { guidance, sectionsList } = headingTreeParts(headings, shownPath, fileText);
+  const leadInRows = outlineLeadInRows(rows, headings);
+  const { rows: cappedLeadIn, notice: capNotice } = capLeadIn(leadInRows);
+  const leadInFolded = foldDelivery(cappedLeadIn, normalizedPath, shownPath, false, layout);
+  const leadInNumbered = leadInFolded !== null ? leadInFolded.numbered : cappedLeadIn.map((r) => r.raw);
+  const leadInRaw = leadInFolded !== null ? leadInFolded.raw : cappedLeadIn.map((r) => r.text);
+  const headingCount = `at least ${headings.length} heading${headings.length === 1 ? "" : "s"} found`;
+  const heading = hintTarget(normalizedPath, "section", { headings, content: fileText, placeholder: "<Heading>" }).name;
+  if (layout === "aligned") {
+    const body = fenceNumberedFileContent([...leadInNumbered, ...planOutlineAlignedRows(rows, headings, leadInNumbered.length, shownPath, normalizedPath)].join("\n"), ALIGNED_LAYOUT_NOTE);
+    const alignedNotice = `Partial view: this ${originalBytes.toLocaleString("en-US")} B document was cut down to ${leadInRows.length > 0 ? "its lead-in and " : ""}its headings (${headingCount}), each on its real line, with the text under each heading withheld behind a pointer. Run token-goat section "${shownPath}::${heading}" to read one section verbatim.`;
+    return { numbered: [body.body], raw: leadInRaw, kind: "read:markdown_outline", detail: shownPath, ratioCap: OUTLINE_MAX_REPLACEMENT_RATIO, context: `${body.preamble}
+${alignedNotice}` };
+  }
+  const notice = leadInRows.length > 0 ? `Partial view: this ${originalBytes.toLocaleString("en-US")} B document was replaced with its lead-in (the content before its first section) and a heading tree (${headingCount}). Run token-goat section "${shownPath}::${heading}" to read one section verbatim.` : `Partial view: this ${originalBytes.toLocaleString("en-US")} B document has no lead-in before its first section, so it was replaced with a heading tree alone (${headingCount}). Run token-goat section "${shownPath}::${heading}" to read one section verbatim.`;
+  return {
+    // The notice leads so that token-goat speaks first: emitting the lead-in above it let a document open with forged `[token-goat: ...]` or `[tg]` lines that read as this rewrite's own preamble. The lead-in is file bytes like the heading tree, so it gets its own fence rather than riding in the tree's; both fences are part of `numbered`, so their cost is priced by the ratioCap gate below along with everything else.
+    numbered: [
+      notice,
+      ...leadInNumbered.length > 0 ? [fenceUntrustedFileContent(leadInNumbered.join("\n"))] : [],
+      ...capNotice !== null ? [capNotice] : [],
+      guidance,
+      fenceUntrustedFileContent(sectionsList)
+    ],
+    raw: leadInRaw,
+    kind: "read:markdown_outline",
+    detail: shownPath,
+    ratioCap: OUTLINE_MAX_REPLACEMENT_RATIO
+  };
+}
+function planOutlineAlignedRows(rows, headings, startIdx, shownPath, normalizedPath) {
+  const listedLines = new Set(headings.map((h) => h.lineNumber));
+  const out = [];
+  let i = startIdx;
+  while (i < rows.length) {
+    const row = rows[i];
+    if (row === void 0) break;
+    if (listedLines.has(row.no)) {
+      out.push(row.raw);
+      i++;
+      continue;
+    }
+    let j = i;
+    while (j < rows.length && !listedLines.has(rows[j]?.no ?? -1)) j++;
+    const firstLine = row.no;
+    const lastLine = rows[j - 1]?.no ?? firstLine;
+    const n = j - i;
+    const under = findContainingSection(normalizedPath, firstLine, lastLine)?.heading ?? null;
+    const notice = under !== null && !/["`$\\]/.test(under) && displaySafeText(under) === under ? `... ${n} line${n === 1 ? "" : "s"} (${firstLine}-${lastLine}) under "${under}" withheld -- token-goat section "${shownPath}::${under}"` : null;
+    let runBytes = 0;
+    for (let k = i; k < j; k++) runBytes += Buffer.byteLength(rows[k]?.raw ?? "", "utf-8") + 1;
+    if (notice === null || Buffer.byteLength(notice, "utf-8") + alignedPaddingBytes(n, "aligned") >= runBytes) {
+      for (let k = i; k < j; k++) out.push(rows[k]?.raw ?? "");
+    } else {
+      pushWithheld(out, notice, n, "aligned");
+    }
+    i = j;
+  }
+  return out;
+}
+function skeletonGapNotice(firstLine, lastLine, shownPath) {
+  const n = lastLine - firstLine + 1;
+  return `... ${n} line${n === 1 ? "" : "s"} (${firstLine}-${lastLine}) withheld from the skeleton -- Read "${shownPath}" with offset=${firstLine}, limit=${n}`;
+}
+function planSourceSkeletonRuns(rows, symbols, shownPath, layout) {
+  const base = rows[0]?.no ?? 1;
+  const keep = /* @__PURE__ */ new Set();
+  const firstDeclLine = Math.min(...symbols.map((s) => s.lineStart));
+  for (let n = base; n < firstDeclLine; n++) keep.add(n);
+  for (const sym of symbols) keep.add(sym.lineStart);
+  const bodyRunStart = /* @__PURE__ */ new Map();
+  for (const sym of symbols) if (sym.lineEnd > sym.lineStart) bodyRunStart.set(sym.lineStart + 1, sym);
+  const runEndsAfter = /* @__PURE__ */ new Set();
+  for (const sym of symbols) if (sym.lineEnd > sym.lineStart) runEndsAfter.add(sym.lineEnd);
+  const numbered = [];
+  const raw = [];
+  let withheldLines = 0;
+  let i = 0;
+  while (i < rows.length) {
+    const row = rows[i];
+    if (row === void 0) break;
+    if (keep.has(row.no)) {
+      numbered.push(row.raw);
+      raw.push(row.text);
+      i++;
+      continue;
+    }
+    let j = i;
+    while (j < rows.length && !keep.has(rows[j]?.no ?? -1)) {
+      const stop = runEndsAfter.has(rows[j]?.no ?? -1);
+      j++;
+      if (stop) break;
+    }
+    const firstLine = row.no;
+    const lastLine = rows[j - 1]?.no ?? firstLine;
+    const sym = bodyRunStart.get(firstLine);
+    const notice = sym !== void 0 && sym.lineEnd === lastLine ? bodyFoldNotice(sym.name, firstLine, lastLine, shownPath, sym.lineStart) : skeletonGapNotice(firstLine, lastLine, shownPath);
+    let runBytes = 0;
+    for (let k = i; k < j; k++) runBytes += Buffer.byteLength(rows[k]?.raw ?? "", "utf-8") + 1;
+    if (Buffer.byteLength(notice, "utf-8") + alignedPaddingBytes(j - i, layout) >= runBytes) {
+      for (let k = i; k < j; k++) {
+        const kept = rows[k];
+        if (kept === void 0) continue;
+        numbered.push(kept.raw);
+        raw.push(kept.text);
+      }
+    } else {
+      pushWithheld(numbered, notice, j - i, layout);
+      withheldLines += lastLine - firstLine + 1;
+    }
+    i = j;
+  }
+  return withheldLines === 0 ? null : { numbered, raw, withheldLines };
+}
+function planSourceSkeleton(rows, normalizedPath, shownPath, originalBytes, layout = "compact") {
+  if (!loadConfig().hints.skeleton_large_sources) return null;
+  if (originalBytes < SKELETON_MIN_BODY_BYTES) return null;
+  const language = detectLanguage(normalizedPath);
+  if (!isTreeSitterAvailable(language)) return null;
+  const fileText = rows.map((r) => r.text).join("\n");
+  const symbols = parseSourceSymbolsTreeSitterOnly(fileText, normalizedPath, language);
+  if (symbols === null) return null;
+  if (symbols.length < SKELETON_MIN_SYMBOLS) return null;
+  const plan = planSourceSkeletonRuns(rows, symbols, shownPath, layout);
+  if (plan === null) return null;
+  const notice = `Partial view: this ${originalBytes.toLocaleString("en-US")} B source file was replaced with its structural skeleton, its preamble and one line per declaration, with ${plan.withheldLines.toLocaleString("en-US")} line${plan.withheldLines === 1 ? "" : "s"} of bodies withheld (at least ${symbols.length} declaration${symbols.length === 1 ? "" : "s"} found). Run token-goat read "${shownPath}::SymbolName" for one body verbatim, or Read "${shownPath}" with offset=1, limit=${rows.length} for the whole file.`;
+  if (layout === "aligned") {
+    const body = fenceNumberedFileContent(plan.numbered.join("\n"), ALIGNED_LAYOUT_NOTE);
+    return { numbered: [body.body], raw: plan.raw, kind: "read:source_skeleton", detail: shownPath, ratioCap: SKELETON_MAX_REPLACEMENT_RATIO, context: `${body.preamble}
+${notice}` };
+  }
+  return { numbered: [notice, fenceUntrustedFileContent(plan.numbered.join("\n"))], raw: plan.raw, kind: "read:source_skeleton", detail: shownPath, ratioCap: SKELETON_MAX_REPLACEMENT_RATIO };
+}
+function isStructuralRewriteAccepted(originalBytes, rewrittenBytes, ratioCap) {
+  if (rewrittenBytes > originalBytes * ratioCap) return false;
+  return isRewriteWorthwhile({ originalBytes, rewrittenBytes, noticeBytes: 0, minNetSavingsBytes: resolveMinNetSavingsBytes() });
+}
+
+// src/hooks_read_post.ts
+function extractReadOutput(raw) {
+  return extractToolResponseField(raw, OUTPUT_FIRST_TOOL_RESPONSE_KEYS);
+}
+function readLayout(event) {
+  return harnessNumbersReadContent(event) ? "aligned" : "compact";
+}
+function keepsLineNumbers(original, rewritten) {
+  return original.split("\n").length === rewritten.split("\n").length;
+}
+function postReadHandlerInner(event, suppressStructuralHint) {
+  const filePath = getFilePath(event);
+  if (filePath === void 0) return passOutput();
+  const normalized = normalizePath(filePath);
+  const shown = displaySafePath(normalized);
+  const respText = extractReadOutput(event.raw);
+  if (isTruncatedReadDelivery(event, respText)) {
+    markFileTruncated(normalized, !readRequestedSliceWindow(event).isExplicitSlice);
+  }
+  const postBasename = path2.basename(normalized);
+  const diffSourcesEnabled = loadConfig().hints.serve_diff_on_reread;
+  if (/\.(md|mdx|markdown|rst|txt)$/i.test(postBasename) || isSessionArtifactFile(normalized) || diffSourcesEnabled && isDiffableSource(postBasename)) {
+    try {
+      const onDisk = hostPathOfIndexKey(normalized);
+      const sz = statSize(onDisk);
+      if (sz !== null && sz <= 256 * 1024) {
+        const content = fs2.readFileSync(onDisk);
+        store(sessionStateKey(event), normalized, content);
+      }
+    } catch {
+    }
+  }
+  if (loadConfig().hints.cross_session_read_dedup) {
+    try {
+      const cwd = getCwd(event) ?? process.cwd();
+      const project = findProject(cwd) ?? makeProjectAt(cwd);
+      const source = readEvidenceFileText(normalized);
+      if (source !== null) recordEvidence({ projectRoot: project.root, source: normalized, representation: "file", text: source });
+    } catch {
+    }
+  }
+  if (loadConfig().hints.cross_session_read_dedup) {
+    try {
+      const cwd = getCwd(event) ?? process.cwd();
+      let project = findProject(cwd);
+      if (!project) {
+        project = makeProjectAt(cwd);
+      }
+      const sessionState = exportSessionState();
+      const mappedFiles = [];
+      for (const fileEntry of sessionState.files) {
+        const relPath = relPathWithinRoot(project.root, fileEntry.path);
+        if (relPath !== null) {
+          mappedFiles.push({
+            rel_path: relPath,
+            hit_count: fileEntry.readCount
+          });
+        }
+      }
+      writeSessionManifest(project.hash, sessionStateKey(event), { files: mappedFiles });
+    } catch {
+    }
+  }
+  if (isSourceExtension(postBasename)) {
+    try {
+      const onDisk = hostPathOfIndexKey(normalized);
+      const sz = statSize(onDisk);
+      if (sz !== null && sz <= SLICE_ESTIMATE_SCAN_CAP_BYTES) {
+        const lineCount = countTextLines(fs2.readFileSync(onDisk, "utf8"));
+        const minLines = loadConfig().post_read_code_compress.min_lines;
+        if (lineCount >= minLines && !suppressStructuralHint) {
+          if (!meetsSavingsFloor(sz)) {
+            logSuppressedDetection("read_structural_nav", event.sessionId, normalized);
+          } else {
+            recordStat("session_hint", 0, 0);
+            return quietContextOutput(
+              shown + " is " + lineCount + ' lines. Use `token-goat skeleton "' + shown + '"` or `token-goat outline "' + shown + '"` for structural navigation instead of a future full re-read.'
+            );
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return passOutput();
+}
+function recordReadAsServedOutput(event, deliveredRaw = null) {
+  try {
+    const cfg = loadConfig().bash_compress;
+    if (!cfg.enabled) return;
+    const filePath = getFilePath(event);
+    if (filePath === void 0) return;
+    const normalized = normalizePath(filePath);
+    if (isImagePath(normalized)) return;
+    const respText = extractReadOutput(event.raw);
+    if (isTruncatedReadDelivery(event, respText)) return;
+    if (deliveredRaw === null) recordActualSlice(event, normalized);
+    const served = deliveredRaw ?? readWindowFromDisk(event, normalized);
+    if (served === null) return;
+    if (Buffer.byteLength(served, "utf-8") < Math.max(cfg.cache_min_bytes, IDENTICAL_READ_MIN_BODY_BYTES)) return;
+    const window = readRequestedSliceWindow(event);
+    let syntheticCommand = "Read " + normalized;
+    if (window.isExplicitSlice) {
+      syntheticCommand += " --offset " + window.offset;
+      if (window.limit !== void 0) syntheticCommand += " --limit " + window.limit;
+    }
+    const id = storeBashOutputSync(syntheticCommand, served, 0, getCwd(event) ?? process.cwd());
+    recordFileServedOutput(normalized, id);
+  } catch {
+  }
+}
+function elideAlreadyServedLines(event, respText) {
+  if (!loadConfig().hints.elide_served_lines) return null;
+  const filePath = getFilePath(event);
+  if (filePath === void 0) return null;
+  const normalized = normalizePath(filePath);
+  if (isImagePath(normalized)) return null;
+  if (isTruncatedReadDelivery(event, respText)) return null;
+  const ids = getFileServedOutputs(normalized);
+  if (ids.length === 0) return null;
+  const parsed = parseReadDelivery(event, respText);
+  if (parsed === null) return null;
+  if (hasPreciseSecret(respText)) return null;
+  const bodies = [];
+  for (let i = ids.length - 1; i >= 0; i--) {
+    const id = ids[i];
+    if (id === void 0) continue;
+    const prior = getBashOutput(id);
+    if (prior !== null) bodies.push(indexServedBody(id, prior.output));
+  }
+  if (bodies.length === 0) return null;
+  const cuts = planServedElisions(parsed.rows, bodies);
+  if (cuts.length === 0) return null;
+  const layout = readLayout(event);
+  const bodyRows = [];
+  let at = 0;
+  for (const cut of cuts) {
+    for (let i = at; i < cut.start; i++) bodyRows.push(parsed.rows[i]?.raw ?? "");
+    const first2 = parsed.rows[cut.start];
+    const last = parsed.rows[cut.start + cut.len - 1];
+    if (first2 === void 0 || last === void 0) return null;
+    pushWithheld(bodyRows, servedRunNotice(first2.no, last.no, cut.id, cut.len), cut.len, layout);
+    at = cut.start + cut.len;
+  }
+  for (let i = at; i < parsed.rows.length; i++) bodyRows.push(parsed.rows[i]?.raw ?? "");
+  const fenced = fenceNumberedFileContent(bodyRows.join("\n"), ALIGNED_LAYOUT_NOTE);
+  const rewritten = [...parsed.header, fenced.body, ...parsed.trailer].join("\n");
+  if (layout === "aligned" && !keepsLineNumbers(respText, rewritten)) return null;
+  const originalBytes = Buffer.byteLength(respText, "utf-8");
+  if (layout === "aligned") {
+    if (!isRewriteWorthwhile({
+      originalBytes,
+      rewrittenBytes: Buffer.byteLength(rewritten, "utf-8") + Buffer.byteLength(fenced.preamble, "utf-8"),
+      noticeBytes: 0,
+      minNetSavingsBytes: resolveMinNetSavingsBytes()
+    })) {
+      return null;
+    }
+    return emitRewriteWithContext(rewritten, fenced.preamble, "read", { kind: "read:served_elide", originalBytes });
+  }
+  if (!isRewriteWorthwhile({
+    originalBytes,
+    rewrittenBytes: Buffer.byteLength(rewritten, "utf-8"),
+    noticeBytes: 0,
+    minNetSavingsBytes: resolveMinNetSavingsBytes()
+  })) {
+    return null;
+  }
+  return emitRewrite(rewritten, "read", { kind: "read:served_elide", originalBytes });
+}
+function structuralFoldInputs(event, respText) {
+  const filePath = getFilePath(event);
+  if (filePath === void 0) return null;
+  if (readRequestedSliceWindow(event).isExplicitSlice) return null;
+  if (isTruncatedReadDelivery(event, respText)) return null;
+  if (hasPreciseSecret(respText)) return null;
+  const parsed = parseReadDelivery(event, respText);
+  if (parsed === null) return null;
+  const normalized = normalizePath(filePath);
+  const shown = displaySafePath(toDisplayPath(findProject(getCwd(event) ?? process.cwd())?.root, normalized));
+  return { rows: parsed.rows, header: parsed.header, trailer: parsed.trailer, normalized, shown, originalBytes: Buffer.byteLength(respText, "utf-8"), respText, layout: readLayout(event), startLine: readStartLine(event) };
+}
+function emitStructuralFold(inputs, fold) {
+  const rewritten = [...inputs.header, ...fold.numbered, ...inputs.trailer].join("\n");
+  if (fold.context !== void 0) {
+    if (!keepsLineNumbers(inputs.respText, rewritten)) return null;
+    const renderedOriginal = numberedRenderBytes(inputs.respText, inputs.startLine);
+    const renderedRewrite = numberedRenderBytes(rewritten, inputs.startLine) + Buffer.byteLength(fold.context, "utf-8");
+    if (!isStructuralRewriteAccepted(renderedOriginal, renderedRewrite, fold.ratioCap)) return null;
+    return {
+      output: emitRewriteWithContext(rewritten, fold.context, "read", { kind: fold.kind, originalBytes: inputs.originalBytes, detail: fold.detail }),
+      deliveredRaw: fold.raw.join("\n")
+    };
+  }
+  if (!isStructuralRewriteAccepted(inputs.originalBytes, Buffer.byteLength(rewritten, "utf-8"), fold.ratioCap)) return null;
+  return {
+    output: emitRewrite(rewritten, "read", { kind: fold.kind, originalBytes: inputs.originalBytes, detail: fold.detail }),
+    deliveredRaw: fold.raw.join("\n")
+  };
+}
+function foldMarkdownOutline(event, respText) {
+  const inputs = structuralFoldInputs(event, respText);
+  if (inputs === null) return null;
+  const fold = planMarkdownOutline(inputs.rows, inputs.normalized, inputs.shown, inputs.originalBytes, inputs.layout);
+  return fold === null ? null : emitStructuralFold(inputs, fold);
+}
+function foldSourceSkeleton(event, respText) {
+  const inputs = structuralFoldInputs(event, respText);
+  if (inputs === null) return null;
+  const fold = planSourceSkeleton(inputs.rows, inputs.normalized, inputs.shown, inputs.originalBytes, inputs.layout);
+  return fold === null ? null : emitStructuralFold(inputs, fold);
+}
+function foldCodeBodies(event, respText) {
+  if (!foldingEnabled()) return null;
+  const filePath = getFilePath(event);
+  if (filePath === void 0) return null;
+  const normalized = normalizePath(filePath);
+  if (isImagePath(normalized)) return null;
+  const sliceWin = readRequestedSliceWindow(event);
+  const requestedOffset = sliceWin.offset;
+  if (requestedOffset !== void 0 && readStartLine(event) !== requestedOffset) return null;
+  if (isTruncatedReadDelivery(event, respText)) return null;
+  if (hasPreciseSecret(respText)) return null;
+  const parsed = parseReadDelivery(event, respText);
+  if (parsed === null) return null;
+  const shown = displaySafePath(toDisplayPath(findProject(getCwd(event) ?? process.cwd())?.root, normalized));
+  const layout = readLayout(event);
+  const folded = foldDelivery(parsed.rows, normalized, shown, sliceWin.isExplicitSlice, layout);
+  if (folded === null) return null;
+  const originalBytes = Buffer.byteLength(respText, "utf-8");
+  if (layout === "aligned") {
+    const fenced = fenceNumberedFileContent(folded.numbered.join("\n"), ALIGNED_LAYOUT_NOTE);
+    const rewritten2 = [...parsed.header, fenced.body, ...parsed.trailer].join("\n");
+    if (!keepsLineNumbers(respText, rewritten2)) return null;
+    if (!isRewriteWorthwhile({
+      originalBytes,
+      rewrittenBytes: Buffer.byteLength(rewritten2, "utf-8") + Buffer.byteLength(fenced.preamble, "utf-8"),
+      noticeBytes: 0,
+      minNetSavingsBytes: resolveMinNetSavingsBytes()
+    })) {
+      return null;
+    }
+    return {
+      output: emitRewriteWithContext(rewritten2, fenced.preamble, "read", { kind: "read:body_fold", originalBytes, detail: foldDetail(normalized, folded.folds) }),
+      deliveredRaw: folded.raw.join("\n")
+    };
+  }
+  const rewritten = [...parsed.header, fenceUntrustedFileContent(folded.numbered.join("\n")), ...parsed.trailer].join("\n");
+  if (!isRewriteWorthwhile({
+    originalBytes,
+    rewrittenBytes: Buffer.byteLength(rewritten, "utf-8"),
+    noticeBytes: 0,
+    minNetSavingsBytes: resolveMinNetSavingsBytes()
+  })) {
+    return null;
+  }
+  return {
+    output: emitRewrite(rewritten, "read", { kind: "read:body_fold", originalBytes, detail: foldDetail(normalized, folded.folds) }),
+    deliveredRaw: folded.raw.join("\n")
+  };
+}
+function postReadHandler(event) {
+  const respText = extractReadOutput(event.raw);
+  const elided = elideAlreadyServedLines(event, respText);
+  const outlined = elided === null ? foldMarkdownOutline(event, respText) : null;
+  const skeletoned = elided === null && outlined === null ? foldSourceSkeleton(event, respText) : null;
+  const folded = elided === null && outlined === null && skeletoned === null ? foldCodeBodies(event, respText) : null;
+  const rewrite = elided ?? outlined?.output ?? skeletoned?.output ?? folded?.output ?? null;
+  const out = applyHintTracking(event, postReadHandlerInner(event, rewrite !== null), classifyReadHint);
+  const deliveredRaw = outlined?.deliveredRaw ?? skeletoned?.deliveredRaw ?? folded?.deliveredRaw ?? null;
+  if (deliveredRaw !== null) forgetFoldedWindow(event);
+  recordReadAsServedOutput(event, deliveredRaw);
+  recordLastReadShape(event, respText, outlined !== null ? "outline" : skeletoned !== null ? "skeleton" : folded !== null ? "fold" : null);
+  return rewrite ?? out;
+}
+function recordLastReadShape(event, respText, rewrite) {
+  try {
+    const filePath = getFilePath(event);
+    if (filePath === void 0) return;
+    const normalized = normalizePath(filePath);
+    if (isImagePath(normalized)) return;
+    let shape = rewrite;
+    if (shape === null && isTruncatedReadDelivery(event, respText)) shape = "truncated";
+    if (shape === null && readRequestedSliceWindow(event).isExplicitSlice && windowCoversFile(event) !== true) shape = "partial";
+    recordReadShape(sessionStateKey(event), normalized, shape);
+  } catch {
+  }
+}
+function windowCoversFile(event) {
+  const resp = event.raw["tool_response"];
+  const file = resp?.["file"];
+  const start = file?.["startLine"];
+  const num = file?.["numLines"];
+  const total = file?.["totalLines"];
+  if (typeof start !== "number" || typeof num !== "number" || typeof total !== "number") return void 0;
+  return start <= 1 && start + num - 1 >= total;
+}
+function forgetFoldedWindow(event) {
+  if (!readRequestedSliceWindow(event).isExplicitSlice) return;
+  const filePath = getFilePath(event);
+  if (filePath !== void 0) resetFileLineRanges(normalizePath(filePath));
+}
+registerHook("post_tool_use", postReadHandler, { toolName: "Read" });
+
+// src/hooks_grep.ts
+init_define_import_meta_env();
+function grepIntInput(toolInput, key) {
+  const value = toolInput[key];
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim() !== "") {
+    const n = Number(value);
+    if (Number.isFinite(n)) return n;
+  }
+  return void 0;
+}
+function grepSignature(toolInput) {
+  const pattern = toolInput["pattern"];
+  if (typeof pattern !== "string" || pattern === "") return null;
+  const path8 = typeof toolInput["path"] === "string" ? toolInput["path"] : "";
+  const outputMode = typeof toolInput["output_mode"] === "string" ? toolInput["output_mode"] : "files_with_matches";
+  const glob = typeof toolInput["glob"] === "string" ? toolInput["glob"] : "";
+  const type = typeof toolInput["type"] === "string" ? toolInput["type"] : "";
+  const caseInsensitive = toolInput["-i"] === true;
+  const onlyMatching = toolInput["-o"] === true;
+  const multiline = toolInput["multiline"] === true;
+  const lineNumbers = toolInput["-n"] !== false;
+  const contextA = grepIntInput(toolInput, "-A");
+  const contextB = grepIntInput(toolInput, "-B");
+  const contextC = grepIntInput(toolInput, "-C") ?? grepIntInput(toolInput, "context");
+  const headLimit = grepIntInput(toolInput, "head_limit");
+  const offset = grepIntInput(toolInput, "offset");
+  return JSON.stringify([
+    pattern,
+    path8,
+    outputMode,
+    glob,
+    type,
+    caseInsensitive,
+    onlyMatching,
+    multiline,
+    lineNumbers,
+    contextA,
+    contextB,
+    contextC,
+    headLimit,
+    offset
+  ]);
+}
+var { post: dedupPostHandler, pre: preGrepDedupHandler } = makeDedupHintHandlers({
+  toolName: "Grep",
+  buildSignature: grepSignature,
+  recordQuery: recordGrepQuery,
+  getMatchCount: getGrepMatchCount,
+  minMatchesConfigKey: "grep_dedup_min_matches",
+  statName: "grep_dedup_hint"
+});
+var CONTENT_LINE_RE = /^(.+?):(\d+):(.*)$/s;
+function foldGrepContentHandler(event) {
+  try {
+    if (getToolName(event) !== "Grep") return passOutput();
+    const toolInput = getToolInput(event);
+    if (toolInput["output_mode"] !== "content") return passOutput();
+    if (toolInput["multiline"] === true) return passOutput();
+    if (toolInput["-A"] !== void 0 || toolInput["-B"] !== void 0 || toolInput["-C"] !== void 0 || toolInput["context"] !== void 0) {
+      return passOutput();
+    }
+    if (toolInput["-n"] === false) return passOutput();
+    const rawText = extractToolResponseField(event.raw, OUTPUT_FIRST_TOOL_RESPONSE_KEYS);
+    if (!rawText) return passOutput();
+    const text = redactSecrets(rawText).text;
+    const rawLines = text.split(/\r\n|\r|\n/);
+    const parsed = [];
+    for (const line of rawLines) {
+      if (line.trim() === "") continue;
+      const m = CONTENT_LINE_RE.exec(line);
+      if (!m) return passOutput();
+      parsed.push({ file: m[1], lineNo: m[2], rest: m[3] });
+    }
+    if (parsed.length === 0) return passOutput();
+    const order = [];
+    const groups = /* @__PURE__ */ new Map();
+    for (const p of parsed) {
+      let group = groups.get(p.file);
+      if (group === void 0) {
+        group = [];
+        groups.set(p.file, group);
+        order.push(p.file);
+      }
+      group.push({ lineNo: p.lineNo, rest: p.rest });
+    }
+    const hasSharedFile = order.some((f) => groups.get(f).length >= 2);
+    if (!hasSharedFile) return passOutput();
+    const foldedLines = [];
+    for (const f of order) {
+      foldedLines.push(f);
+      for (const { lineNo, rest } of groups.get(f)) {
+        foldedLines.push(`  ${lineNo}: ${rest}`);
+      }
+    }
+    const rewritten = foldedLines.join("\n");
+    const originalBytes = Buffer.byteLength(text, "utf-8");
+    const rewrittenBytes = Buffer.byteLength(rewritten, "utf-8");
+    if (!isRewriteWorthwhile({
+      originalBytes,
+      rewrittenBytes,
       noticeBytes: 0,
       minNetSavingsBytes: resolveMinNetSavingsBytes()
     })) {
@@ -1332,12 +1714,12 @@ function preGrepHandler(event) {
     if (getToolName(event) !== "Grep") return passOutput();
     const toolInput = getToolInput(event);
     const structSearch = extractGrepStructuralSearch(toolInput);
-    if (structSearch !== null) {
+    if (structSearch !== null && (!structSearch.isDoc || docNavigation(structSearch.filePath).section)) {
       recordStat("session_hint", 0, 0);
       const { isDoc } = structSearch;
       const filePath = displaySafePath(structSearch.filePath);
-      const target = hintTarget(structSearch.filePath, isDoc ? "section" : "symbol", { cwd: getCwd(event) ?? process.cwd(), event });
-      const hint = isDoc ? leadWithCommand('token-goat section "' + filePath + "::" + target.name + '"', 'to read one section, or `token-goat outline "' + filePath + '"` to see the document outline', "Scanning a document for headings loads large match output.") : target.real ? leadWithCommand('token-goat read "' + filePath + "::" + target.name + '"', 'to inspect one symbol, or `token-goat skeleton "' + filePath + '"` to see the file structure', "Scanning a source file for symbols loads large match output.") : leadWithCommand('token-goat skeleton "' + filePath + '"', 'to see the file structure, or `token-goat read "' + filePath + '::SymbolName"` to inspect a specific symbol', "Scanning a source file for symbols loads large match output.");
+      const target = hintTarget(structSearch.filePath, isDoc ? "section" : "symbol", { cwd: getCwd(event) ?? process.cwd(), event, pattern: String(toolInput["pattern"] ?? "") });
+      const hint = isDoc ? docSectionHint(filePath, target.name, "Scanning a document for headings loads large match output.") : target.real ? leadWithCommand('token-goat read "' + filePath + "::" + target.name + '"', 'to inspect one symbol, or `token-goat skeleton "' + filePath + '"` to see the file structure', "Scanning a source file for symbols loads large match output.") : leadWithCommand('token-goat skeleton "' + filePath + '"', 'to see the file structure, or `token-goat read "' + filePath + '::SymbolName"` to inspect a specific symbol', "Scanning a source file for symbols loads large match output.");
       return contextOutput(hint);
     }
     return applyHintTracking(event, preGrepDedupHandler(event), uncorrelatedHint("grep_dedup_hint"));
@@ -1356,18 +1738,23 @@ registerHook("post_tool_use", postGrepHandler, { toolName: "Grep" });
 
 // src/hooks_glob.ts
 init_define_import_meta_env();
-function isBroadCatchAllGlob(pattern, pathArg) {
+function isSameDirAsCwd(target, cwd) {
+  const norm = (p) => foldPath(normalizePath(p).replace(/\/+$/, ""));
+  return norm(target) === norm(cwd);
+}
+function isBroadCatchAllGlob(pattern, pathArg, cwd) {
   const p = pattern.trim();
   const isBroad = p === "*" || p === "**/*" || p === "**" || p === "*.*" || p === "**/*.*" || p === "**/*.**";
   if (!isBroad) return false;
   const target = (pathArg ?? "").trim().replace(/[\\/]+$/, "");
-  return target === "" || target === "." || target === "./" || target === ".\\" || !target.includes("/") && !target.includes("\\");
+  if (target === "" || target === "." || target === "./" || target === ".\\" || !target.includes("/") && !target.includes("\\")) return true;
+  return cwd !== void 0 && isSameDirAsCwd(target, cwd);
 }
 function globSignature(toolInput) {
   const pattern = toolInput["pattern"];
   if (typeof pattern !== "string" || pattern === "") return null;
-  const path6 = typeof toolInput["path"] === "string" ? toolInput["path"] : "";
-  return JSON.stringify([pattern, path6]);
+  const path8 = typeof toolInput["path"] === "string" ? toolInput["path"] : "";
+  return JSON.stringify([pattern, path8]);
 }
 var { post: postGlobHandler, pre: preGlobDedupHandler } = makeDedupHintHandlers({
   toolName: "Glob",
@@ -1383,7 +1770,7 @@ function preGlobHandler(event) {
     const toolInput = getToolInput(event);
     const pattern = typeof toolInput["pattern"] === "string" ? toolInput["pattern"] : "";
     const pathArg = typeof toolInput["path"] === "string" ? toolInput["path"] : typeof toolInput["paths"] === "string" ? toolInput["paths"] : Array.isArray(toolInput["paths"]) && toolInput["paths"].length === 1 && typeof toolInput["paths"][0] === "string" ? toolInput["paths"][0] : void 0;
-    if (pattern && isBroadCatchAllGlob(pattern, pathArg)) {
+    if (pattern && isBroadCatchAllGlob(pattern, pathArg, getCwd(event))) {
       recordStat("session_hint", 0, 0);
       return contextOutput(
         'Broad recursive glob pattern "' + displaySafeText(pattern) + '" traverses entire directory trees and may dump thousands of paths into context. Use `token-goat map --compact` to inspect project directory structure efficiently, or narrow the glob path.'
@@ -1399,17 +1786,25 @@ registerHook("post_tool_use", postGlobHandler, { toolName: "Glob" });
 
 // src/hooks_edit.ts
 init_define_import_meta_env();
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 import { statSync as statSync3 } from "node:fs";
 function postEditHandlerInner(event) {
-  const filePath = getFilePath(event);
-  if (filePath === void 0) return passOutput();
+  const filePaths = getFilePaths(event);
+  if (filePaths.length === 0) return passOutput();
+  const normalizedPaths = filePaths.map((p) => recordEditedFile(event, p));
+  if (normalizedPaths.length !== 1) return passOutput();
+  const normalized = normalizedPaths[0];
+  return markdownSectionHint(event, normalized);
+}
+function recordEditedFile(event, filePath) {
   const normalized = normalizePath(filePath);
   recordFileEdit(normalized);
-  const underSystemTemp = isUnderSystemTemp(normalized);
+  bookEditAfterPartialRead(event, normalized);
+  const indexPath = resolveIndexPath(filePath, getCwd(event) ?? process.cwd());
+  const underSystemTemp = isUnderSystemTemp(indexPath);
   if (!underSystemTemp) {
     try {
-      appendDirtyPath(normalized);
+      appendDirtyPath(indexPath);
     } catch (e) {
       recordStat("dirty_queue_append_failed", 0, 0, void 0, extractErrorMessage(e));
     }
@@ -1419,7 +1814,7 @@ function postEditHandlerInner(event) {
       recordStat("worker_healthcheck_failed", 0, 0, void 0, extractErrorMessage(e));
     }
     try {
-      recordKnownRootThrottled(normalized);
+      recordKnownRootThrottled(indexPath);
     } catch (e) {
       recordStat("known_root_record_failed", 0, 0, void 0, extractErrorMessage(e));
     }
@@ -1427,18 +1822,24 @@ function postEditHandlerInner(event) {
   if (loadConfig().hints.stable_doc_compacts) {
     markCompactStale(compactPathFor(normalized));
   }
-  const editedBasename = path2.basename(normalized);
+  return normalized;
+}
+function markdownSectionHint(event, normalized) {
+  const editedBasename = path3.basename(normalized);
   if (/\.(md|mdx|markdown|rst)$/i.test(editedBasename)) {
     let editedSize = Infinity;
     try {
-      editedSize = statSync3(normalized).size;
+      editedSize = statSync3(hostPathOfIndexKey(normalized)).size;
     } catch {
     }
+    const repeatKey = `edit-section-hint:${normalized}:${getCompactedAt()}`;
+    if (wasHintShown(repeatKey)) return passOutput();
     if (!meetsSavingsFloor(editedSize)) {
       logSuppressedDetection("edit_reread_suggest", event.sessionId, normalized);
     } else {
       const escapedPath = displaySafePath(normalized).replace(/`/g, "\\`").replace(/"/g, '\\"');
       const heading = hintTarget(normalized, "section", { placeholder: "HeadingName" });
+      markHintShown(repeatKey);
       return contextOutput(
         leadWithCommand('token-goat section "' + escapedPath + "::" + heading.name + '"', "to re-read a specific section rather than the full file", displaySafePath(editedBasename) + " was edited."),
         [escapedPath]
@@ -1447,6 +1848,16 @@ function postEditHandlerInner(event) {
   }
   return passOutput();
 }
+function bookEditAfterPartialRead(event, normalized) {
+  try {
+    const stateKey = sessionStateKey(event);
+    const shape = readShapeOf(stateKey, normalized);
+    if (shape === null) return;
+    recordStat("edit_after_fold", 0, 0, void 0, `last_read=${shape} tool=${event.toolName ?? "unknown"}`);
+    if (event.toolName === "Write") recordReadShape(stateKey, normalized, null);
+  } catch {
+  }
+}
 function postEditHandler(event) {
   return applyHintTracking(event, postEditHandlerInner(event), classifyEditHint);
 }
@@ -1457,7 +1868,7 @@ registerHook("post_tool_use", postEditHandler, { toolName: "NotebookEdit" });
 
 // src/hooks_write.ts
 init_define_import_meta_env();
-import { readFileSync as readFileSync3, statSync as statSync4 } from "node:fs";
+import { readFileSync as readFileSync6, statSync as statSync4 } from "node:fs";
 var MAX_LINES_FOR_DIFF = 4e3;
 var MAX_OLD_FILE_BYTES_FOR_DIFF = 4 * 1024 * 1024;
 function splitLines(text) {
@@ -1498,7 +1909,7 @@ function preWriteRewriteHandler(event) {
     if (stat.size > MAX_OLD_FILE_BYTES_FOR_DIFF) return passOutput();
     let oldContent;
     try {
-      oldContent = readFileSync3(filePath, "utf-8");
+      oldContent = readFileSync6(filePath, "utf-8");
     } catch {
       return passOutput();
     }
@@ -1524,7 +1935,8 @@ registerHook("pre_tool_use", preWriteRewriteHandler, { toolName: "Write" });
 
 // src/hooks_compact.ts
 init_define_import_meta_env();
-import * as path3 from "node:path";
+import * as fs3 from "node:fs";
+import * as path4 from "node:path";
 
 // src/harness_channels.ts
 init_define_import_meta_env();
@@ -1536,8 +1948,21 @@ var PRE_COMPACT_CONTEXT_DROPPED = /* @__PURE__ */ new Set(["copilot_cli", "codex
 function dropsPreCompactContext() {
   return PRE_COMPACT_CONTEXT_DROPPED.has(getHarnessName());
 }
+var PRE_COMPACT_RESUMES_ON_PROMPT = /* @__PURE__ */ new Set(["copilot_cli"]);
+function resumesCompactionOnPrompt() {
+  return PRE_COMPACT_RESUMES_ON_PROMPT.has(getHarnessName()) && !dropsPromptSubmitContext();
+}
 
 // src/hooks_compact.ts
+function recordSessionCompaction(sessionId, now) {
+  const p = sessionSidecarPath(sessionId ?? "", COMPACTED_AT_SUFFIX);
+  if (!p) return;
+  try {
+    ensureDirSync(path4.dirname(p));
+    fs3.writeFileSync(p, String(now), "utf8");
+  } catch {
+  }
+}
 function preCompactHandler(event) {
   const cfg = loadConfig().compact_assist;
   let out = passOutput();
@@ -1548,12 +1973,14 @@ function preCompactHandler(event) {
 
 ${manifest}`);
     } else if (event.sessionId) {
-      queuePendingContext(sessionStateKey(event), `${MANIFEST_RECOVERY_PREAMBLE}
+      replacePendingContextBlock(sessionStateKey(event), `${MANIFEST_RECOVERY_PREAMBLE}
 
-${manifest.slice(0, MAX_PENDING_CONTEXT_BYTES - MANIFEST_RECOVERY_PREAMBLE.length - 2)}`);
+${manifest.slice(0, MAX_PENDING_CONTEXT_BYTES - MANIFEST_RECOVERY_PREAMBLE.length - 2)}`, MANIFEST_RECOVERY_PREAMBLE);
     }
   }
-  markCompacted();
+  const now = Date.now();
+  markCompacted(now);
+  recordSessionCompaction(event.sessionId, now);
   return out;
 }
 registerHook("pre_compact", preCompactHandler);
@@ -1569,11 +1996,13 @@ function postCompactHandler(event) {
   const cwd = normalizePath(getCwd(event) ?? process.cwd());
   const spell = (p) => foldPath(p.replaceAll("\\", "/"));
   const haystack = spell(summary);
-  const survived = sample.filter((p) => {
-    const rel = path3.relative(cwd, p);
-    const forms = rel !== "" && !rel.startsWith("..") && !path3.isAbsolute(rel) ? [p, rel] : [p];
+  const kept = sample.filter((p) => {
+    const rel = path4.relative(cwd, p);
+    const forms = rel !== "" && !rel.startsWith("..") && !path4.isAbsolute(rel) ? [p, rel] : [p];
     return forms.some((f) => haystack.includes(spell(f)));
-  }).length;
+  });
+  const survived = kept.length;
+  recordCompactDroppedPaths(sessionStateKey(event), typeof raw === "string" ? sample.filter((p) => !kept.includes(p)) : null);
   const trigger = typeof event.raw["trigger"] === "string" ? event.raw["trigger"] : "unknown";
   const budget = loadConfig().compact_assist.summary_budget_chars;
   const over = budget > 0 && summary.length > budget ? 1 : 0;
@@ -1598,7 +2027,7 @@ init_define_import_meta_env();
 var TRACKED_SKILL = "token-goat";
 var MAX_COMMANDS_SHOWN = 8;
 async function currentCommandNames() {
-  const { buildProgram } = await import("./token-goat-chunk-IFORDBGC.mjs");
+  const { buildProgram } = await import("./token-goat-chunk-HOJLCGDP.mjs");
   return flattenCommandNames(buildCommandManifest(buildProgram()));
 }
 async function recordSkillVersionSnapshot(sessionId, skillName) {
@@ -1747,10 +2176,14 @@ async function userPromptSubmitHandler(event) {
     }
     const driftNudge = await checkSkillVersionDrift(event.sessionId);
     const residentHints = residentContextHints(event);
-    if (parts.length === 0 && !driftNudge && residentHints.length === 0) {
+    const resumed = resumesCompactionOnPrompt() ? peekPendingContext(sessionStateKey(event)) : null;
+    if (parts.length === 0 && !driftNudge && residentHints.length === 0 && resumed === null) {
       return passOutput();
     }
     const lines = [];
+    if (resumed !== null) {
+      lines.push(resumed);
+    }
     if (parts.length > 0) {
       lines.push("[" + parts.join(" | ") + "]");
     }
@@ -1823,20 +2256,6 @@ registerHook("post_tool_use", pendingContextHandler, { advisory: true, followsMa
 
 // src/hooks_session_start.ts
 init_define_import_meta_env();
-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.';
-var NOTE_REMINDER = ' Record a finding that must outlive a compaction with `token-goat note set <key> "<finding>"`; notes come back at every session start.';
-function isIndexedProject(cwd) {
-  if (cwd === void 0) return false;
-  try {
-    return countSymbols({ rootDir: cwd }, globalDbPath()) > 0;
-  } catch {
-    return false;
-  }
-}
-function buildReminder(indexed) {
-  return (indexed ? INDEXED_REMINDER : GENERIC_REMINDER) + NOTE_REMINDER;
-}
 function reconcileNote(cwd, indexed) {
   if (!indexed) return null;
   if (!envBool(ENV_KEYS.RECONCILE, true)) return null;
@@ -1860,6 +2279,11 @@ function reconcileNote(cwd, indexed) {
     const clauses = [];
     if (drifted > 0) clauses.push(`${countNoun(drifted, "file")} that changed outside this session${breakdown}`);
     if (upgraded > 0) clauses.push(`${countNoun(upgraded, "file")} unchanged on disk but indexed by an older version of token-goat`);
+    const unqueued = total - result.enqueued;
+    if (unqueued > 0) {
+      const refused = unqueued < total ? `${unqueued} of them` : total === 1 ? "it" : "they";
+      return `token-goat: found ${clauses.join(" and ")}${truncated}, but ${refused} could not be queued for reindexing, so symbol lookups may stay stale until token-goat index runs here.`;
+    }
     return `token-goat: reindexing ${clauses.join(" and ")}${truncated}. Symbol lookups may be briefly stale.`;
   } catch (e) {
     recordStat("reconcile_note_failed", 0, 0, void 0, extractErrorMessage(e));
@@ -1870,16 +2294,29 @@ async function postCompactRecovery(event) {
   if (event.raw["source"] !== "compact" || event.sessionId === void 0) return null;
   if (!loadConfig().compact_assist.enabled) return null;
   try {
-    const { buildResumePacket } = await import("./token-goat-chunk-D7GHQKQD.mjs");
+    const { buildResumePacket } = await import("./token-goat-chunk-MKPF4CL5.mjs");
     return await buildResumePacket(event.sessionId);
   } catch {
     return null;
   }
 }
 async function sessionStartHandler(event) {
+  return withSavingsReceipt(await sessionStartOutput(event));
+}
+function savingsReceiptText(tokens) {
+  return `token-goat has saved about ${tokens.toLocaleString("en-US")} tokens so far. Run \`token-goat stats\` for the detail.`;
+}
+function withSavingsReceipt(output, homeDir) {
+  if (output.hookType !== "pass" && output.hookType !== "context") return output;
+  if (detectHarness() !== "claudecode") return output;
+  const saved = claimFirstSavingsReceipt(void 0, homeDir);
+  return saved === null ? output : { ...output, notice: savingsReceiptText(saved) };
+}
+async function sessionStartOutput(event) {
   const recovery = await postCompactRecovery(event);
   const cwd = getCwd(event);
-  const tail = [projectNotesFor(cwd), recovery].filter((part) => part !== null).join("\n\n");
+  const { anchorStatus } = await import("./token-goat-chunk-USILZ3T3.mjs");
+  const tail = [projectNotesFor(cwd, anchorStatus), recovery].filter((part) => part !== null).join("\n\n");
   const tailOnly = () => tail === "" ? passOutput() : contextOutput(tail);
   try {
     if (!loadConfig().hints.session_start_reminder) return tailOnly();
@@ -1902,6 +2339,16 @@ ${capsule}`;
       }
     } catch {
     }
+    try {
+      const { currentUpgradeDecision, getCachedUpdateStatus, updateAdvice } = await import("./token-goat-chunk-3CHUNJ2O.mjs");
+      const update = getCachedUpdateStatus();
+      const advice = update === null ? null : updateAdvice(currentUpgradeDecision(update));
+      if (update?.latest && advice !== null) {
+        context += `
+[token-goat update available: v${update.current} -> v${update.latest}. ${advice}]`;
+      }
+    } catch {
+    }
     if (tail !== "") context += `
 
 ${tail}`;
@@ -6470,8 +6917,8 @@ function trimCharacterEnd(str, char) {
 function unicodeEscape(str) {
   return str.replace(/[\s\S]/g, (c) => "\\u" + c.charCodeAt().toString(16).padStart(4, "0"));
 }
-function get(obj, path6) {
-  for (const key of path6) {
+function get(obj, path8) {
+  for (const key of path8) {
     if (!obj) {
       return void 0;
     }
@@ -7672,8 +8119,8 @@ function withBrackets(str, brackets) {
   const rbr = typeof brackets[1] === "string" ? brackets[1] : "]";
   return lbr + str + rbr;
 }
-function pathRewrite(path6, rewriter, baseUrl, metadata, elem) {
-  const modifiedPath = typeof rewriter === "function" ? rewriter(path6, metadata, elem) : path6;
+function pathRewrite(path8, rewriter, baseUrl, metadata, elem) {
+  const modifiedPath = typeof rewriter === "function" ? rewriter(path8, metadata, elem) : path8;
   return modifiedPath[0] === "/" && baseUrl ? trimCharacterEnd(baseUrl, "/") + modifiedPath : modifiedPath;
 }
 function formatImage(elem, walk, builder, formatOptions) {
@@ -7997,9 +8444,9 @@ function handleDeprecatedOptions(options) {
     options.selectors.push(...tagDefinitions);
     options.selectors = mergeDuplicatesPreferLast(options.selectors, ((s) => s.selector));
   }
-  function set(obj, path6, value) {
-    const valueKey = path6.pop();
-    for (const key of path6) {
+  function set(obj, path8, value) {
+    const valueKey = path8.pop();
+    for (const key of path8) {
       let nested = obj[key];
       if (!nested) {
         nested = {};
@@ -8067,19 +8514,30 @@ function resolveWebFetchContext(event) {
   }
   return resolveWebFetchUrl(event);
 }
+function webFetchPolicyUrls(event) {
+  if (getToolName(event) !== "WebFetch") return [];
+  const toolInput = getToolInput(event);
+  const out = [];
+  const single = toolInput["url"];
+  if (typeof single === "string" && single !== "") out.push(single);
+  const list = toolInput["urls"];
+  if (Array.isArray(list)) {
+    for (const entry of list) if (typeof entry === "string" && entry !== "" && !out.includes(entry)) out.push(entry);
+  }
+  return out;
+}
 function preFetchHandler(event) {
   try {
-    const urlOnlyCtx = resolveWebFetchUrl(event);
-    if (urlOnlyCtx !== null) {
-      const metadataRefusal = metadataEndpointRefusal(urlOnlyCtx.url);
+    for (const url2 of webFetchPolicyUrls(event)) {
+      const metadataRefusal = metadataEndpointRefusal(url2);
       if (metadataRefusal !== null) {
         return denyOutput(`WebFetch blocked: ${metadataRefusal}.`);
       }
       const wfCfg = loadConfig().webfetch;
-      if (wfCfg.deny.length > 0 && matchesDenyPattern(urlOnlyCtx.url, wfCfg.deny)) {
+      if (wfCfg.deny.length > 0 && matchesDenyPattern(url2, wfCfg.deny)) {
         return denyOutput(`WebFetch blocked: URL matches a configured webfetch.deny pattern.`);
       }
-      if (wfCfg.allow.length > 0 && !matchesAllowPattern(urlOnlyCtx.url, wfCfg.allow)) {
+      if (wfCfg.allow.length > 0 && !matchesAllowPattern(url2, wfCfg.allow)) {
         return denyOutput(`WebFetch blocked: URL does not match any configured webfetch.allow pattern.`);
       }
     }
@@ -8163,6 +8621,33 @@ registerHook("post_tool_use", postFetchHandler, { toolName: "WebFetch" });
 // src/hooks_skill.ts
 init_define_import_meta_env();
 import { readFile } from "node:fs/promises";
+
+// src/copilot_skill_path.ts
+init_define_import_meta_env();
+import { access } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { resolve } from "node:path";
+async function copilotSkillPath(skillName, cwd) {
+  const name2 = safeSkillName(skillName);
+  if (!name2 || name2.includes(":")) return null;
+  const roots = [];
+  if (cwd) {
+    roots.push(resolve(cwd, ".github", "skills"), resolve(cwd, ".agents", "skills"), resolve(cwd, ".claude", "skills"));
+  }
+  roots.push(resolve(copilotCliUserRoot(), "skills"), resolve(homedir2(), ".agents", "skills"));
+  for (const root of roots) {
+    const diskPath = resolve(root, name2, "SKILL.md");
+    try {
+      await access(diskPath);
+      return diskPath;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+// src/hooks_skill.ts
 var OVERSIZED_FIRST_LOAD_THRESHOLD_BYTES = 6e3;
 var COMPACT_INLINE_MAX_BYTES = 24e3;
 function skillSectionArg(skillPath, body) {
@@ -8184,6 +8669,13 @@ function extractSkillName(toolInput) {
 function extractSkillBody(raw) {
   return extractToolResponseField(raw, BODY_FIRST_TOOL_RESPONSE_KEYS);
 }
+function skillResultIsConfirmationOnly() {
+  return getHarnessName() === "copilot_cli";
+}
+function harnessSkillPath(event, skillName) {
+  if (skillResultIsConfirmationOnly()) return copilotSkillPath(skillName, getCwd(event) ?? null);
+  return installedSkillPath(skillName);
+}
 function resolveSkillContext(event) {
   const toolName = getToolName(event);
   if (toolName !== "Skill") {
@@ -8199,14 +8691,14 @@ function resolveSkillContext(event) {
   }
   return { skillName };
 }
-function planHeadingTree(body, bodyBytes, skillName) {
+function planHeadingTree(body, bodyBytes, skillName, sourcePath) {
   const headings = extractMarkdownHeadings(body);
   if (headings.length < OUTLINE_MIN_HEADINGS) return null;
   const { sectionsList } = formatHeadingTreeParts(headings, skillName);
   const treeBytes = Buffer.byteLength(sectionsList, "utf-8");
   if (treeBytes > bodyBytes * OUTLINE_MAX_REPLACEMENT_RATIO) return null;
   const totalHeadings = extractMarkdownHeadings(body, Number.MAX_SAFE_INTEGER).length;
-  const phrase = totalHeadings > headings.length ? "its heading tree shows " + headings.length + " of " + totalHeadings + " headings below instead of the full body; the remaining sections are reachable only through `token-goat skill-body " + skillName + "`." : "its heading tree (" + headings.length + " headings) is inlined below instead of the full body.";
+  const phrase = totalHeadings > headings.length ? "its heading tree shows " + headings.length + " of " + totalHeadings + " headings below instead of the full body; the other " + (totalHeadings - headings.length) + ' load by name just the same, and `token-goat outline "' + displaySafeText(sourcePath) + '"` lists all ' + totalHeadings + "." : "its heading tree (" + headings.length + " headings) is inlined below instead of the full body.";
   return { sectionsList, treeBytes, phrase };
 }
 async function preSkillHandler(event) {
@@ -8224,10 +8716,10 @@ async function preSkillHandler(event) {
       const denyCredit = cachedBytes !== null ? Math.min(cachedBytes, PER_FILE_COUNTERFACTUAL_CEILING) : 0;
       recordStat("session_hint", denyCredit, savedTokensFromBytes(denyCredit), void 0, "skill-reload-deny");
       return denyOutput(
-        "Skill `" + skillName + "` was already loaded this session and is cached. Use `token-goat skill-section " + skillName + " " + skillSectionArg(await installedSkillPath(skillName)) + "` 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."
+        "Skill `" + skillName + "` was already loaded this session and is cached. Use `token-goat skill-section " + skillName + " " + skillSectionArg(await harnessSkillPath(event, skillName)) + "` 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);
+    const sourcePath = await harnessSkillPath(event, skillName);
     if (sourcePath) {
       try {
         const body = await readFile(sourcePath, "utf-8");
@@ -8244,7 +8736,7 @@ async function preSkillHandler(event) {
               );
             }
           }
-          const tree = planHeadingTree(body, bodyBytes, skillName);
+          const tree = planHeadingTree(body, bodyBytes, skillName, sourcePath);
           if (tree !== null) {
             const replaced = compact !== null ? Buffer.byteLength(compact, "utf-8") : bodyBytes;
             const savedBytes = Math.max(0, replaced - tree.treeBytes);
@@ -8274,13 +8766,23 @@ async function postSkillHandler(event) {
     if (ctx === null) {
       return passOutput();
     }
-    const { skillName } = ctx;
-    recordStat("skill_load");
-    const body = extractSkillBody(event.raw);
+    const { skillName } = ctx;
+    recordStat("skill_load");
+    let body;
+    let sourcePath;
+    if (skillResultIsConfirmationOnly()) {
+      sourcePath = await harnessSkillPath(event, skillName);
+      if (sourcePath === null) {
+        return passOutput();
+      }
+      body = await readFile(sourcePath, "utf-8");
+    } else {
+      body = extractSkillBody(event.raw);
+      sourcePath = await installedSkillPath(skillName);
+    }
     if (!body) {
       return passOutput();
     }
-    const sourcePath = await installedSkillPath(skillName);
     await storeOutput(event.sessionId, skillName, body, sourcePath ? { sourcePath } : void 0);
     await incrementSkillHit(skillName);
     await recordSkillVersionSnapshot(event.sessionId, skillName);
@@ -8309,7 +8811,7 @@ function dualShellArg(s) {
   if (SHELL_UNSAFE_IN_EITHER_QUOTING_RE.test(s)) return null;
   return `"${s}"`;
 }
-function detectStructuralIndexRewrite(rawCmd, cwd) {
+function detectStructuralIndexRewrite(rawCmd, cwd, event) {
   try {
     const detected = detectFromCommand(rawCmd, cwd);
     if (detected === null || detected.filter.name !== "grep") return null;
@@ -8319,10 +8821,11 @@ function detectStructuralIndexRewrite(rawCmd, cwd) {
     if (bin === void 0 || pattern === void 0 || rawPath === void 0) return null;
     if (!ALLOWED_BINARIES.has(pathStem(bin).toLowerCase())) return null;
     if (/[*?[\]{}]/.test(rawPath)) return null;
+    if (!commandPathIsTouchable(rawPath, event)) return null;
     const resolved = resolveIndexPath(rawPath, cwd);
     let stat;
     try {
-      stat = statSync5(resolved);
+      stat = statSync5(hostPathOfIndexKey(resolved));
     } catch {
       return null;
     }
@@ -8367,16 +8870,17 @@ function detectStructuralIndexRewrite(rawCmd, cwd) {
 
 // src/bash_range_savings.ts
 init_define_import_meta_env();
-import { statSync as statSync6, readFileSync as readFileSync4 } from "node:fs";
+import { statSync as statSync6, readFileSync as readFileSync7 } from "node:fs";
 var ALL_SYMBOLS_IN_FILE = -1;
 var REGION_HEADER_BYTES = 56;
 function rangeSubstituteFor(hintPath, cwd, ranges) {
   if (ranges.length === 0) return null;
   try {
     const resolved = resolveIndexPath(hintPath, cwd);
-    if (!statSync6(resolved).isFile()) return null;
+    const onDisk = hostPathOfIndexKey(resolved);
+    if (!statSync6(onDisk).isFile()) return null;
     if (!indexMatchesDisk(resolved)) return null;
-    const lines = readFileSync4(resolved, "utf8").split("\n");
+    const lines = readFileSync7(onDisk, "utf8").split("\n");
     const symbols = querySymbols({ filePath: resolved, limit: ALL_SYMBOLS_IN_FILE });
     if (symbols.length === 0) return null;
     const bytesOf = (start, end) => Buffer.byteLength(lines.slice(start - 1, Math.min(end, lines.length)).join("\n"), "utf8");
@@ -8400,335 +8904,103 @@ function rangeSubstituteFor(hintPath, cwd, ranges) {
     const regions = [...regionBySpan.values()].sort((a, b) => a.start - b.start || a.end - b.end);
     const replacementBytes = regions.reduce((t, r) => t + bytesOf(r.start, r.end) + REGION_HEADER_BYTES, 0);
     const commands = regions.map(
-      (r) => r.name === null ? `token-goat read "${hintPath}:${r.start}-${r.end}"` : `token-goat read "${hintPath}::${r.name}"`
-    );
-    return { requestedBytes, replacementBytes, commands };
-  } catch {
-    return null;
-  }
-}
-
-// src/hooks_bash.ts
-import { statSync as statSync7, existsSync, readFileSync as readFileSync5 } from "node:fs";
-import * as path4 from "node:path";
-function compressionOptedOut(rawCmd) {
-  return process.env["TOKEN_GOAT_BASH_COMPRESS"] === "0" || commandOptsOutOfCompression(rawCmd);
-}
-var INTERPRETER_READ_TOKEN_CAP = 2e3;
-function cappedInterpreterRead(event, rawCmd, cmd, hint, denial) {
-  return maybeCompressRewrite(event, rawCmd, cmd, { maxTokens: INTERPRETER_READ_TOKEN_CAP, hint: stripUnsafeSuggestions(hint) }) ?? denyOutput(denial);
-}
-function maybeCompressRewrite(event, rawCmd, cmd, cap) {
-  if (compressionOptedOut(rawCmd)) return null;
-  if (event.raw["_tg_harness"] === "vscode") return null;
-  const isPwshHarness = process.platform === "win32" && (event.raw["_tg_harness"] === "codex" || event.raw["_tg_harness"] === "copilot_cli" || event.raw["tool_name"] === "powershell");
-  if (isPwshHarness) {
-    if (!canRunPowerShell()) return null;
-  } else {
-    if (!canRunWrappedShell()) return null;
-  }
-  let cfg;
-  try {
-    cfg = loadConfig().bash_compress;
-  } catch {
-    return null;
-  }
-  if (!cfg.enabled) return null;
-  let filterName;
-  if (cap !== void 0) {
-    if (hasBareBackground(cmd)) return null;
-    filterName = "passthrough";
-  } else {
-    const gateCmd = stripTrailingStderrRedirect(cmd);
-    const detected = detectFromCommand(gateCmd, getCwd(event));
-    if (detected !== null) {
-      filterName = detected.filter.name;
-    } else if (isCompressibleSingleCommand(gateCmd)) {
-      filterName = "generic";
-    } else {
-      return null;
-    }
-  }
-  if (cfg.disabled_filters.includes(filterName)) return null;
-  const capArgs = cap === void 0 ? "" : ` --max-tokens ${cap.maxTokens} --cap-hint-b64 ${Buffer.from(cap.hint, "utf8").toString("base64")}`;
-  if (isPwshHarness) {
-    const b64 = Buffer.from(rawCmd, "utf8").toString("base64");
-    if (Buffer.from(b64, "base64").toString("utf8") !== rawCmd) return null;
-    const wrapped2 = `token-goat compress -f ${filterName} --timeout ${cfg.timeout_seconds}${capArgs} --shell pwsh --cmd-b64 ${b64}`;
-    if (wrapped2.length > 24e3) return null;
-    return { hookType: "rewriteInput", updatedInput: { ...event.toolInput, command: wrapped2 } };
-  }
-  const wrapped = `token-goat compress -f ${filterName} --timeout ${cfg.timeout_seconds}${capArgs} -c ${shellQuoteSingle(rawCmd)}`;
-  if (cap !== void 0 && wrapped.length > 24e3) return null;
-  return { hookType: "rewriteInput", updatedInput: { ...event.toolInput, command: wrapped } };
-}
-function elideServedShellLines(cmd, output, priorIds, unknownLineNumbers = false) {
-  if (priorIds.length === 0) return null;
-  const lines = output.split("\n");
-  const numbers = unknownLineNumbers ? Array.from({ length: lines.length }, () => null) : deliveredLineNumbers(cmd, lines.length);
-  if (numbers === null) return null;
-  const rows = lines.map((text, i) => ({ no: numbers[i] ?? null, text, raw: text }));
-  const bodies = [];
-  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) bodies.push(indexServedBody(id, prior.output));
-  }
-  const cuts = planServedElisions(rows, bodies);
-  if (cuts.length === 0) return null;
-  const spans = [];
-  const push = (text, own) => {
-    const sep = spans.length === 0 ? "" : "\n";
-    const prev = spans[spans.length - 1];
-    if (prev !== void 0 && prev.own === true === own) spans[spans.length - 1] = { text: prev.text + sep + text, own };
-    else spans.push({ text: sep + text, own });
-  };
-  let at = 0;
-  for (const cut of cuts) {
-    for (let i = at; i < cut.start; i++) push(rows[i]?.raw ?? "", false);
-    const first2 = rows[cut.start];
-    const last = rows[cut.start + cut.len - 1];
-    if (first2 === void 0 || last === void 0) return null;
-    push(servedRunNotice(first2.no, last.no, cut.id, cut.len), true);
-    at = cut.start + cut.len;
-  }
-  for (let i = at; i < rows.length; i++) push(rows[i]?.raw ?? "", false);
-  return spans;
-}
-function foldShellReadBodies(cmd, output, fileKey, cwd) {
-  if (!foldingEnabled()) return null;
-  if (redactSecrets(output).count > 0) return null;
-  const lines = output.split("\n");
-  const numbers = deliveredLineNumbers(cmd, lines.length);
-  if (numbers === null) return null;
-  const rows = [];
-  for (let i = 0; i < lines.length; i++) {
-    const no = numbers[i];
-    if (no === void 0 || no === null) return null;
-    rows.push({ no, text: lines[i] ?? "", raw: lines[i] ?? "" });
-  }
-  const headRead = extractHeadFile(cmd) ?? extractGetContentHead(cmd);
-  const windowed = extractLineRangeRead(cmd) !== null || headRead !== null && lines.length >= headRead.n;
-  const folded = foldDelivery(rows, fileKey, displaySafePath(toDisplayPath(findProject(cwd ?? process.cwd())?.root, fileKey)), windowed);
-  if (folded === null) return null;
-  return { text: folded.numbered.join("\n"), folds: folded.folds };
-}
-function foldShellReadStructure(cmd, filePath, output, fileKey, cwd) {
-  if (!isWholeFileDump(cmd, filePath)) return null;
-  const originalBytes = Buffer.byteLength(output, "utf-8");
-  let onDisk;
-  try {
-    onDisk = statSync7(fileKey).size;
-  } catch {
-    return null;
-  }
-  if (onDisk !== originalBytes) return null;
-  if (redactSecrets(output).count > 0) return null;
-  const lines = output.split("\n");
-  if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
-  const rows = lines.map((text2, i) => ({ no: i + 1, text: text2, raw: text2 }));
-  const shown = displaySafePath(toDisplayPath(findProject(cwd ?? process.cwd())?.root, fileKey));
-  const fold = planMarkdownOutline(rows, fileKey, shown, originalBytes) ?? planSourceSkeleton(rows, fileKey, shown, originalBytes);
-  if (fold === null) return null;
-  const text = fold.numbered.join("\n");
-  if (!isStructuralRewriteAccepted(originalBytes, Buffer.byteLength(text, "utf-8"), fold.ratioCap)) return null;
-  return { text, kind: fold.kind === "read:markdown_outline" ? "bash_compress:markdown-outline" : "bash_compress:source-skeleton", detail: fold.detail };
-}
-var REWRITE_CLIP_NOTE = "\n[token-goat: rewrite clipped to the harness delivery cap; the pointer above recalls the untouched output]";
-function fenceRewriteWithinCap(spans) {
-  const joined = spans.map((s) => s.text).join("");
-  const fenced = fenceUntrustedSpans(spans, UNTRUSTED_TOOL_TAG);
-  if (fenced === joined) return joined;
-  const overhead = Buffer.byteLength(fenced, "utf-8") - Buffer.byteLength(joined, "utf-8") + Buffer.byteLength(REWRITE_CLIP_NOTE, "utf-8");
-  const cut = clipToDeliveryCap(joined, overhead);
-  if (!cut.clipped) return fenced;
-  const kept = [];
-  let left2 = cut.text.length;
-  for (const s of spans) {
-    if (left2 <= 0) break;
-    kept.push(s.text.length <= left2 ? s : { ...s, text: s.text.slice(0, left2) });
-    left2 -= s.text.length;
-  }
-  return fenceUntrustedSpans(kept, UNTRUSTED_TOOL_TAG) + REWRITE_CLIP_NOTE;
-}
-async function maybeCollapseIdenticalRead(cmd, rawCmd, optedOut, output, exitCode, cwd, cacheMinBytes, persisted = false) {
-  if (optedOut) 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, cdPrefixCwd(rawCmd, 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 elided = elideServedShellLines(cmd, output, priorIds);
-    const priced = (text) => isRewriteWorthwhile({ originalBytes, rewrittenBytes: Buffer.byteLength(text, "utf-8"), noticeBytes: 0, minNetSavingsBytes: resolveMinNetSavingsBytes() });
-    let rewrite = null;
-    if (elided !== null) {
-      const fenced = fenceRewriteWithinCap(elided);
-      if (priced(fenced)) rewrite = { text: fenced, reason: "already-served file lines withheld", kind: "bash_compress:served-elide" };
-    } else {
-      const structural = foldShellReadStructure(cmd, filePath, output, fileKey, cwd);
-      if (structural !== null && priced(structural.text)) {
-        rewrite = { text: structural.text, reason: structural.kind === "bash_compress:markdown-outline" ? "document replaced with its heading tree" : "source replaced with its structural skeleton", kind: structural.kind, detail: structural.detail };
-      }
-      if (rewrite === null) {
-        const folded = foldShellReadBodies(cmd, output, fileKey, cwd);
-        if (folded !== null) {
-          const fenced = fenceRewriteWithinCap([{ text: folded.text }]);
-          if (priced(fenced)) rewrite = { text: fenced, reason: "code bodies folded", kind: "bash_compress:body-fold", detail: foldDetail(fileKey, folded.folds) };
-        }
-      }
-    }
-    const storedId = await storeBashOutput(cmd, rewrite?.text ?? output, exitCode ?? 0, cwd);
-    recordBashOutput(sessionKey, storedId, originalBytes);
-    if (!persisted) recordFileServedOutput(fileKey, storedId);
-    if (rewrite === null) return null;
-    return emitRewrite(rewrite.text, rewrite.reason, { kind: rewrite.kind, originalBytes: deliveredOutputBytes(originalBytes), ...rewrite.detail === void 0 ? {} : { detail: rewrite.detail } });
-  }
-  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 + " --full`." : "[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 + " --full`.";
-  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 maybeElideServedGenericOutput(cmd, optedOut, output, exitCode, cwd, cacheMinBytes, persisted = false) {
-  if (optedOut) return null;
-  if (!loadConfig().bash_compress.elide_served_shell_output) return null;
-  if (exitCode !== null && exitCode !== 0) return null;
-  if (redactSecrets(output).count > 0) return null;
-  const originalBytes = Buffer.byteLength(output, "utf-8");
-  if (originalBytes < cacheMinBytes) return null;
-  const priorIds = getFileServedOutputs(GENERIC_SERVED_OUTPUT_KEY).filter((id) => getBashOutput(id)?.command !== cmd);
-  let rewrittenText = null;
-  if (priorIds.length > 0) {
-    const elided = elideServedShellLines(cmd, output, priorIds, true);
-    const fenced = elided === null ? null : fenceRewriteWithinCap(elided);
-    if (fenced !== null && isRewriteWorthwhile({ originalBytes, rewrittenBytes: Buffer.byteLength(fenced, "utf-8"), noticeBytes: 0, minNetSavingsBytes: resolveMinNetSavingsBytes() })) {
-      rewrittenText = fenced;
-    }
-  }
-  if (!persisted) recordFileServedOutput(GENERIC_SERVED_OUTPUT_KEY, await storeBashOutput(cmd, rewrittenText ?? output, exitCode ?? 0, cwd));
-  if (rewrittenText === null) return null;
-  return emitRewrite(rewrittenText, "already-served shell output collapsed", { kind: "bash_compress:generic-served-elision", originalBytes: deliveredOutputBytes(originalBytes) });
-}
-async function maybeCompressCompoundOutput(cmd, optedOut, output, exitCode, cwd, cacheMinBytes, isUnwrapped = false) {
-  if (optedOut) return null;
-  if (!isUnwrapped) return null;
-  if (isFullRecallCommand(cmd)) return null;
-  if (exitCode !== null && exitCode !== 0) return null;
-  let cfg;
-  try {
-    cfg = loadConfig().bash_compress;
-  } catch {
-    return null;
-  }
-  if (!cfg.enabled || cfg.disabled_filters.includes("generic")) return null;
-  if (Buffer.byteLength(output, "utf-8") < cacheMinBytes) return null;
-  const shaped = pipelineShapeFilter(cmd, cwd) ?? (isUnwrapped ? detectFromCommand(cmd, cwd ?? void 0) ?? null : null);
-  const useShaped = shaped !== null && !cfg.disabled_filters.includes(shaped.filter.name);
-  const filter3 = useShaped ? shaped.filter : filterByName("generic");
-  if (filter3 === null) return null;
-  const filterArgv = useShaped ? shaped.argv : [];
-  const compressed = compressOutput(filter3, output, "", exitCode ?? 0, filterArgv, {
-    maxLines: cfg.max_lines,
-    maxBytes: cfg.max_bytes
-  });
-  const minNet = resolveMinNetSavingsBytes();
-  if (!compressed.worthApplying(minNet)) return null;
-  const id = bashOutputIdSync(cmd, output, cwd);
-  const { body: untrusted, notices } = splitOwnTrailingNotices(compressed.text);
-  const marker = compressed.withMarker(minNet).slice(compressed.text.length);
-  const body = fenceUntrusted(untrusted, UNTRUSTED_TOOL_TAG) + notices + marker + "\n[token-goat] full output: bash-output " + id + " --full";
-  const emittedBytes = Buffer.byteLength(body, "utf-8");
-  if (!isRewriteWorthwhile({
-    originalBytes: compressed.originalBytes,
-    rewrittenBytes: emittedBytes,
-    noticeBytes: 0,
-    minNetSavingsBytes: minNet
-  })) {
-    return null;
-  }
-  await storeBashOutput(cmd, output, exitCode ?? 0, cwd);
-  return emitRewrite(body, "bash", { kind: `bash_compress:${filter3.name}`, originalBytes: deliveredOutputBytes(compressed.originalBytes) });
-}
-function maybeStripAnsiOnly(output) {
-  if (!output.includes("\x1B")) return null;
-  let cfg;
-  try {
-    cfg = loadConfig().bash_compress;
+      (r) => r.name === null ? `token-goat read "${hintPath}:${r.start}-${r.end}"` : `token-goat read "${hintPath}::${r.name}"`
+    );
+    return { requestedBytes, replacementBytes, commands };
   } 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 maybeFoldCurlHtml(cmd, output, id) {
-  if (!isCurlGetCommand(cmd) || !looksLikeHtml(output)) return null;
+
+// src/hooks_bash.ts
+import { statSync as statSync7, existsSync, readFileSync as readFileSync8 } from "node:fs";
+import * as path5 from "node:path";
+var INTERPRETER_READ_TOKEN_CAP = 2e3;
+function cappedInterpreterRead(event, rawCmd, cmd, hint, denial) {
+  return maybeCompressRewrite(event, rawCmd, cmd, { maxTokens: INTERPRETER_READ_TOKEN_CAP, hint: stripUnsafeSuggestions(hint) }) ?? denyOutput(denial);
+}
+function maybeCompressRewrite(event, rawCmd, cmd, cap) {
+  if (/^(?:token-goat|tg|npx\s+token-goat)(?:\s|$)/.test(cmd.trimStart())) return null;
+  if (compressionOptedOut(rawCmd)) return null;
+  if (event.raw["_tg_harness"] === "vscode") return null;
+  const isPwshHarness = process.platform === "win32" && (event.raw["_tg_harness"] === "codex" || event.raw["_tg_harness"] === "copilot_cli" || event.raw["tool_name"] === "powershell");
+  if (isPwshHarness) {
+    if (!canRunPowerShell()) return null;
+  } else {
+    if (!canRunWrappedShell()) return null;
+  }
   let cfg;
   try {
     cfg = loadConfig().bash_compress;
   } catch {
     return null;
   }
-  if (!cfg.enabled || cfg.disabled_filters.includes("curl-html")) return null;
-  let cleaned;
+  if (!cfg.enabled) return null;
+  let filterName;
+  if (cap !== void 0) {
+    if (hasBareBackground(cmd)) return null;
+    filterName = "passthrough";
+  } else {
+    const gateCmd = stripTrailingStderrRedirect(cmd);
+    const detected = detectFromCommand(gateCmd, commandRunDir(rawCmd, getCwd(event) ?? null) ?? void 0);
+    if (detected !== null) {
+      filterName = detected.filter.name;
+    } else if (isCompressibleSingleCommand(gateCmd)) {
+      filterName = "generic";
+    } else {
+      return null;
+    }
+  }
+  if (cfg.disabled_filters.includes(filterName)) return null;
+  const capArgs = cap === void 0 ? "" : ` --max-tokens ${cap.maxTokens} --cap-hint-b64 ${Buffer.from(cap.hint, "utf8").toString("base64")}`;
+  if (isPwshHarness) {
+    const b64 = Buffer.from(rawCmd, "utf8").toString("base64");
+    if (Buffer.from(b64, "base64").toString("utf8") !== rawCmd) return null;
+    const wrapped2 = `token-goat compress -f ${filterName} --timeout ${cfg.timeout_seconds}${capArgs} --shell pwsh --cmd-b64 ${b64}`;
+    if (wrapped2.length > 24e3) return null;
+    return { hookType: "rewriteInput", updatedInput: { ...event.toolInput, command: wrapped2 } };
+  }
+  const wrapped = `token-goat compress -f ${filterName} --timeout ${cfg.timeout_seconds}${capArgs} -c ${shellQuoteSingle(rawCmd)}`;
+  if (cap !== void 0 && wrapped.length > 24e3) return null;
+  return { hookType: "rewriteInput", updatedInput: { ...event.toolInput, command: wrapped } };
+}
+function wholeFileRange(filePath, hintPath, cwd, ranges, tool) {
+  const [range] = ranges;
+  if (ranges.length !== 1 || range === void 0 || range[0] > 1) return null;
+  const cat = classifyCatPath(filePath, tool);
+  if (cat === null) return null;
   try {
-    cleaned = extractCleanText(output);
+    const onDisk = hostPathOfTypedPath(hintPath, cwd);
+    const st = statSync7(onDisk);
+    if (!st.isFile() || st.size > SLICE_ESTIMATE_SCAN_CAP_BYTES) return null;
+    const total = countTextLines(readFileSync8(onDisk, "utf8"));
+    if (total === 0 || range[1] < total) return null;
+    return { start: range[0], end: range[1], cat, reason: "`" + tool + "` over lines " + range[0] + "-" + range[1] + " is the whole file (" + total + " lines), and loads all of it into context." };
   } catch {
     return null;
   }
-  const originalBytes = Buffer.byteLength(output, "utf-8");
-  const notice = `[token-goat: curl HTML body cleaned via extractCleanText; use \`token-goat bash-output ${id} --full\` to recall the raw markup]
-`;
-  const noticeBytes = Buffer.byteLength(notice, "utf-8");
-  const clipNote = "\n[token-goat: cleaned text clipped to the harness delivery cap; the notice at the top of this output recalls the full raw markup]";
-  const fenceOverhead = Buffer.byteLength(fenceUntrusted(cleaned, UNTRUSTED_TOOL_TAG), "utf-8") - Buffer.byteLength(cleaned, "utf-8");
-  const cut = clipToDeliveryCap(cleaned, noticeBytes + fenceOverhead + Buffer.byteLength(clipNote, "utf-8"));
-  const body = cut.text;
-  const clipped = cut.clipped ? clipNote : "";
-  const fenced = fenceUntrusted(body, UNTRUSTED_TOOL_TAG) + clipped;
-  if (!isRewriteWorthwhile({
-    originalBytes,
-    rewrittenBytes: Buffer.byteLength(fenced, "utf-8"),
-    noticeBytes,
-    minNetSavingsBytes: resolveMinNetSavingsBytes()
-  })) {
-    return null;
-  }
-  return emitRewrite(notice + fenced, "curl HTML body cleaned", { kind: "bash_compress:curl-html", originalBytes: deliveredOutputBytes(originalBytes) });
 }
 function preBashHandlerInner(event) {
   const rawCmd = extractCommand(event);
   if (rawCmd === void 0) return passOutput();
   const cmd = stripCommandPrefix(rawCmd);
-  const cdStripped = stripCdPrefix(rawCmd) !== rawCmd;
+  const grouped = stripSubshellGroup(rawCmd);
+  const cdStripped = stripCdPrefix(grouped) !== grouped;
   const preHookCwd = getCwd(event) ?? null;
+  const toolUseId = event.raw["tool_use_id"];
+  if (typeof toolUseId === "string" && toolUseId !== "" && preHookCwd !== null) recordBashStartCwd(toolUseId, preHookCwd);
   const hintCwd = preHookCwd ?? process.cwd();
+  const runDir = commandRunDir(rawCmd, preHookCwd);
   const pathHint = (paths, text) => contextOutput(text, typeof paths === "string" ? [paths] : paths);
   const targetFor = (hintPath, slice = sliceForPath(hintPath)) => hintTarget(hintPath, slice, { cwd: hintCwd, event });
+  const taskOutputPath = (typed) => {
+    if (!commandPathIsTouchable(typed, event)) return null;
+    if (path5.isAbsolute(typed) || path5.win32.isAbsolute(typed)) return { probe: typed, shown: displaySafePath(typed) };
+    const probe = resolveIndexPath(typed, cdPrefixCwd(rawCmd, hintCwd));
+    return { probe, shown: displaySafePath(probe) };
+  };
   const pricedSubstitute = (hintPath, start, end) => {
+    if (!commandPathIsTouchable(hintPath, event)) return null;
     const sub = rangeSubstituteFor(hintPath, hintCwd, [[start, end]]);
     return sub !== null && meetsSavingsFloor(sub.requestedBytes - sub.replacementBytes) ? sub : null;
   };
@@ -8743,6 +9015,12 @@ function preBashHandlerInner(event) {
     return false;
   };
   const cfg = loadConfig();
+  if (cfg.hints.deny_bash_double_backslash && process.platform === "win32" && event.raw["_tg_harness"] === "claude" && rawCmd.includes("\\\\") && detectHarness() === "claudecode") {
+    recordStat("session_hint", 0, 0);
+    return denyOutput(
+      "This command has two backslashes in a row. Claude Code's Bash tool on Windows halves every run of two or more backslashes before Git Bash sees the command, so it would run with different text than you wrote, with no error (anthropics/claude-code#85856). Write text containing backslashes to a file with the Write tool and run it by path, or use the PowerShell tool, which passes the command unchanged. For paths, use forward slashes: C:/Users/me works in Git Bash. To turn this check off, set hints.deny_bash_double_backslash = false or TOKEN_GOAT_DENY_BASH_DOUBLE_BACKSLASH=0."
+    );
+  }
   if (cfg.hints.warn_unbalanced_shell_quoting) {
     const quoteError = detectUnbalancedShellSyntax(cmd);
     if (quoteError !== null) {
@@ -8754,9 +9032,11 @@ function preBashHandlerInner(event) {
   }
   const taskOutput = extractTasksOutput(cmd);
   if (taskOutput !== null) {
-    const { id, path: outPath, n } = taskOutput;
+    const { id, n } = taskOutput;
+    const outPaths = taskOutputPath(taskOutput.path);
     recordStat("session_hint", 0, 0);
-    if (taskOutputIsJsonlTranscript(outPath)) {
+    if (outPaths !== null && taskOutputIsJsonlTranscript(outPaths.probe)) {
+      const outPath = outPaths.shown;
       const tail = n ?? 50;
       return denyOutput(
         "Task output " + id + ' is a JSONL agent transcript on disk. Use `token-goat bash-output --file "' + outPath + '" --transcript` to read the assistant text, then narrow with `--grep PATTERN` or `--tail ' + tail + '`, or read a specific line range (the only way to reach the MIDDLE of a large artifact) with `token-goat read "' + outPath + '@START-END"`, instead of reading the whole file.'
@@ -8814,13 +9094,22 @@ function preBashHandlerInner(event) {
     const hintPaths = [];
     for (const { filePath, ranges, tool } of sedReads) {
       const hintPath = displaySafePath(cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath);
+      if (!commandPathIsTouchable(hintPath, event)) continue;
       hintPaths.push(hintPath);
       const sedDedupKey = resolveIndexPath(hintPath, preHookCwd ?? process.cwd());
+      const whole = singleLineRangeRead === null ? null : wholeFileRange(filePath, hintPath, hintCwd, ranges, tool);
+      if (whole !== null && findRangeOverlap(getFileLineRanges(sedDedupKey), whole.start, whole.end) === null) {
+        recordStat("session_hint", 0, 0);
+        if (whole.cat.isSql) return pathHint(hintPath, sqlTableHint(hintPath, targetFor(hintPath, "table"), whole.reason));
+        const hint = surgicalHintFor(hintPath, whole.cat.isEnv, whole.cat.isConfig, whole.cat.isDoc, whole.cat.isXml, targetFor(hintPath, whole.cat.isEnv ? "key" : void 0), whole.reason);
+        return cdStripped ? pathHint(hintPath, hint) : denyOutput(hint);
+      }
       const overlapHints = [];
       const freshRanges = [];
+      const onDisk = isFileAtIndexKey(sedDedupKey);
       for (const [start, end] of ranges) {
         const priorOverlap = findRangeOverlap(getFileLineRanges(sedDedupKey), start, end);
-        recordFileLineRange(sedDedupKey, start, end);
+        if (onDisk) recordFileLineRange(sedDedupKey, start, end);
         if (priorOverlap !== null) {
           overlapHints.push(sedOverlapHint(hintPath, priorOverlap, start, end));
         } else {
@@ -8933,8 +9222,9 @@ function preBashHandlerInner(event) {
     const hintPath = displaySafePath(cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath);
     recordStat("session_hint", 0, 0);
     if (isOutputFile) {
-      if (taskOutputIsJsonlTranscript(filePath)) {
-        const tHint = 'This `.output` file is a JSONL agent transcript. Use `token-goat bash-output --file "' + hintPath + '" --transcript` to read the assistant text, then narrow with `--grep PATTERN` or `--tail N`, instead of hand-parsing the JSONL.';
+      const outPaths = taskOutputPath(filePath);
+      if (outPaths !== null && taskOutputIsJsonlTranscript(outPaths.probe)) {
+        const tHint = 'This `.output` file is a JSONL agent transcript. Use `token-goat bash-output --file "' + outPaths.shown + '" --transcript` to read the assistant text, then narrow with `--grep PATTERN` or `--tail N`, instead of hand-parsing the JSONL.';
         return cdStripped ? pathHint(hintPath, tHint) : denyOutput(tHint);
       }
       return pathHint(
@@ -8995,7 +9285,7 @@ function preBashHandlerInner(event) {
     recordStat("session_hint", 0, 0);
     return cdStripped ? pathHint(hintPath, denial) : cappedInterpreterRead(event, rawCmd, cmd, hint, denial);
   }
-  const structuralRewrite = detectStructuralIndexRewrite(rawCmd, hintCwd);
+  const structuralRewrite = detectStructuralIndexRewrite(rawCmd, hintCwd, event);
   if (structuralRewrite !== null) {
     return { hookType: "rewriteInput", updatedInput: { ...event.toolInput, command: structuralRewrite.command } };
   }
@@ -9010,7 +9300,7 @@ function preBashHandlerInner(event) {
     const { filePath } = mdHeadingGrep;
     const hintPath = displaySafePath(cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath);
     recordStat("session_hint", 0, 0);
-    return pathHint(hintPath, leadWithCommand('token-goat section "' + hintPath + "::" + targetFor(hintPath, "section").name + '"', 'to read one section, or `token-goat outline "' + hintPath + '"` for every heading with line ranges'));
+    return pathHint(hintPath, docSectionHint(hintPath, targetFor(hintPath, "section").name));
   }
   const rgSymbol = extractRgSymbolSearch(cmd);
   if (rgSymbol !== null) {
@@ -9033,11 +9323,11 @@ function preBashHandlerInner(event) {
   }
   const monitoringHint = getMonitoringRecallHint(cmd);
   if (monitoringHint !== null) {
-    const monCmdHash = shortFingerprint(stripOutputPipeline(cmd));
+    const monCmdHash = bashRecallKey(cmd, runDir);
     const monOutputId = getBashOutputId(monCmdHash);
     const monEntryRaw = monOutputId !== null ? getBashOutput(monOutputId) : null;
-    const monEntry = monEntryRaw !== null && !isBashEntryStale(monEntryRaw, cmd, preHookCwd) ? monEntryRaw : null;
-    if (monOutputId !== null && monEntry !== null && recallWorthShowing(monOutputId, monEntry)) {
+    const monEntry = monEntryRaw !== null && !isBashEntryStale(monEntryRaw, cmd, runDir) ? monEntryRaw : null;
+    if (monOutputId !== null && monEntry !== null && cachedRunCoversCommand(monEntry.command, cmd) && recallWorthShowing(monOutputId, monEntry)) {
       const monBytes = monEntry.sizeBytes;
       const catFile = extractCatSourceFile(cmd);
       if (catFile !== null) {
@@ -9046,7 +9336,7 @@ function preBashHandlerInner(event) {
           "Prior output from `" + cmd + "`" + pipelineDivergenceNote(cmd, monEntry.command) + " is cached. Use `token-goat bash-output " + monOutputId + "` to recall the full file, or `" + sliceCommand(displaySafePath(catFile), targetFor(displaySafePath(catFile))) + "` to extract only the part you need."
         );
       }
-      const cmdSummary = cmd.length > 60 ? cmd.slice(0, 57) + "..." : cmd;
+      const cmdSummary = cmd.length > 60 ? cmd.slice(0, 57).trimEnd() + "..." : cmd;
       recordStat("bash_compress:recall", monBytes, savedTokensFromBytes(monBytes));
       return contextOutput(
         "Prior output from `" + cmdSummary + "`" + pipelineDivergenceNote(cmd, monEntry.command) + " is cached.\nUse `token-goat bash-output " + monOutputId + " " + monitoringHint + "` to re-inspect without re-running."
@@ -9056,10 +9346,10 @@ function preBashHandlerInner(event) {
   const curlDl = extractCurlDownload(cmd);
   if (curlDl !== null) {
     const prevPath = getCurlDownloadPath(curlDl.url);
-    const prevResolvedPath = prevPath !== null && commandPathIsTouchable(prevPath, event) ? resolveIndexPath(prevPath, preHookCwd ?? process.cwd()) : null;
-    if (prevPath !== null && prevResolvedPath !== null && !existsSync(prevResolvedPath)) {
+    const prevOnDisk = prevPath !== null && commandPathIsTouchable(prevPath, event) ? hostPathOfTypedPath(prevPath, preHookCwd ?? process.cwd()) : null;
+    if (prevPath !== null && prevOnDisk !== null && !existsSync(prevOnDisk)) {
       clearCurlDownload(curlDl.url);
-    } else if (prevPath !== null && prevResolvedPath !== null && statSync7(prevResolvedPath).size >= loadConfig().hints.bash_dedup_min_bytes) {
+    } else if (prevPath !== null && prevOnDisk !== null && statSync7(prevOnDisk).size >= loadConfig().hints.bash_dedup_min_bytes) {
       recordStat("session_hint", 0, 0);
       return denyOutput(leadWithCommand(sliceCommand(prevPath, targetFor(prevPath)), "to read a part of it, or `rg '<pattern>' " + prevPath + "` to search it", "Already downloaded to " + prevPath + " earlier this session."));
     }
@@ -9069,7 +9359,7 @@ function preBashHandlerInner(event) {
     const curlHash = shortFingerprint(curlCacheKey);
     const curlOutputId = getBashOutputId(curlHash);
     const curlEntryRaw = curlOutputId !== null ? getBashOutput(curlOutputId) : null;
-    const curlEntry = curlEntryRaw !== null && !isBashEntryStale(curlEntryRaw, cmd, preHookCwd) ? curlEntryRaw : null;
+    const curlEntry = curlEntryRaw !== null && !isBashEntryStale(curlEntryRaw, cmd, runDir) ? curlEntryRaw : null;
     if (curlOutputId !== null && curlEntry !== null && recallWorthShowing(curlOutputId, curlEntry)) {
       const curlBytes = curlEntry.sizeBytes;
       recordStat("bash_compress:recall", curlBytes, savedTokensFromBytes(curlBytes));
@@ -9081,10 +9371,10 @@ function preBashHandlerInner(event) {
     }
   }
   if (isReadOnlyGhApi(cmd)) {
-    const ghHash = shortFingerprint(stripOutputPipeline(cmd));
+    const ghHash = bashRecallKey(cmd, runDir);
     const ghOutputId = getBashOutputId(ghHash);
     const ghEntryRaw = ghOutputId !== null ? getBashOutput(ghOutputId) : null;
-    const ghEntry = ghEntryRaw !== null && !isBashEntryStale(ghEntryRaw, cmd, preHookCwd) ? ghEntryRaw : null;
+    const ghEntry = ghEntryRaw !== null && !isBashEntryStale(ghEntryRaw, cmd, runDir) ? ghEntryRaw : null;
     if (ghOutputId !== null && ghEntry !== null && recallWorthShowing(ghOutputId, ghEntry)) {
       const ghBytes = ghEntry.sizeBytes;
       recordStat("bash_compress:recall", ghBytes, savedTokensFromBytes(ghBytes));
@@ -9095,10 +9385,10 @@ function preBashHandlerInner(event) {
     }
   }
   if (isScopedGitStatusOrDiffStatCommand(cmd)) {
-    const gitScopedHash = shortFingerprint(stripOutputPipeline(cmd));
+    const gitScopedHash = bashRecallKey(cmd, runDir);
     const gitScopedOutputId = getBashOutputId(gitScopedHash);
     const gitScopedEntryRaw = gitScopedOutputId !== null ? getBashOutput(gitScopedOutputId) : null;
-    const gitScopedEntry = gitScopedEntryRaw !== null && !isBashEntryStale(gitScopedEntryRaw, cmd, preHookCwd) ? gitScopedEntryRaw : null;
+    const gitScopedEntry = gitScopedEntryRaw !== null && !isBashEntryStale(gitScopedEntryRaw, cmd, runDir) ? gitScopedEntryRaw : null;
     if (gitScopedOutputId !== null && gitScopedEntry !== null && recallWorthShowing(gitScopedOutputId, gitScopedEntry)) {
       const gitScopedBytes = gitScopedEntry.sizeBytes;
       recordStat("bash_compress:recall", gitScopedBytes, savedTokensFromBytes(gitScopedBytes));
@@ -9108,61 +9398,326 @@ function preBashHandlerInner(event) {
       );
     }
   }
-  const tgRead = extractTgSurgicalRead(cmd, preHookCwd);
-  if (tgRead !== null) {
-    const cliKey = tgRead.sub + "::" + tgRead.spec;
-    const notes = [];
-    if (wasCliReadThisSession(cliKey)) {
-      notes.push("You already ran this exact `token-goat " + tgRead.sub + "` query earlier this session \u2014 check your context above before re-running it.");
-    }
-    if (tgRead.filePath !== null && wasFileReadThisSession(tgRead.filePath)) {
-      notes.push("`" + tgRead.filePath + "` was already fully read via the Read tool this session \u2014 that content may already cover this.");
-    }
-    if (notes.length > 0) {
-      recordStat("session_hint", 0, 0);
-      return pathHint(tgRead.filePath !== null ? [tgRead.filePath] : [], notes.join(" "));
+  const tgRead = extractTgSurgicalRead(cmd, runDir);
+  if (tgRead !== null) {
+    const cliKey = tgRead.sub + "::" + tgRead.spec;
+    const notes = [];
+    if (wasCliReadThisSession(cliKey)) {
+      notes.push("You already ran this exact `token-goat " + tgRead.sub + "` query earlier this session \u2014 check your context above before re-running it.");
+    }
+    if (tgRead.filePath !== null && wasFileReadThisSession(tgRead.filePath)) {
+      notes.push("`" + tgRead.filePath + "` was already fully read via the Read tool this session \u2014 that content may already cover this.");
+    }
+    if (notes.length > 0) {
+      recordStat("session_hint", 0, 0);
+      return pathHint(tgRead.filePath !== null ? [tgRead.filePath] : [], notes.join(" "));
+    }
+    return passOutput();
+  }
+  if (isTestRunnerCommand(cmd) && isDirectTestRunnerCommand(cmd) && !hasTestRunScopeOrBudget(cmd)) {
+    const compression = maybeCompressRewrite(event, rawCmd, cmd);
+    if (compression !== null) return compression;
+    const key = `test-run-budget:${event.sessionId}:${shortFingerprint(cmd)}`;
+    if (!wasHintShown(key)) {
+      markHintShown(key);
+      recordStat("session_hint", 0, 0);
+      return contextOutput(
+        "This test command has no targeted selector or explicit timeout. Prefer a focused test path/name or the runner\u2019s supported timeout before starting a potentially unbounded suite; run the full suite deliberately when it is needed."
+      );
+    }
+  }
+  if (!isBuildCommand(cmd) && detectFromCommand(stripTrailingStderrRedirect(cmd), runDir ?? void 0) === null) return passOutput();
+  const cmdHash = bashRecallKey(cmd, runDir);
+  const outputId = getBashOutputId(cmdHash);
+  const entryRaw = outputId !== null ? getBashOutput(outputId) : null;
+  const entry = entryRaw !== null && !isBashEntryStale(entryRaw, cmd, runDir) ? entryRaw : null;
+  if (outputId !== null && entry !== null && recallWorthShowing(outputId, entry)) {
+    const bytes = entry.sizeBytes;
+    recordStat("bash_compress:recall", bytes, savedTokensFromBytes(bytes));
+    return contextOutput(buildRecallHint(cmd, outputId));
+  }
+  return maybeCompressRewrite(event, rawCmd, cmd) ?? passOutput();
+}
+function preBashHandler(event) {
+  return applyHintTracking(event, preBashHandlerInner(event), classifyBashHint);
+}
+registerHook("pre_tool_use", preBashHandler, { toolName: "Bash" });
+
+// src/hooks_bash_post.ts
+init_define_import_meta_env();
+import { statSync as statSync8, existsSync as existsSync2, readFileSync as readFileSync9 } from "node:fs";
+import * as path6 from "node:path";
+function elideServedShellLines(cmd, output, priorIds, unknownLineNumbers = false) {
+  if (priorIds.length === 0) return null;
+  const lines = output.split("\n");
+  const numbers = unknownLineNumbers ? Array.from({ length: lines.length }, () => null) : deliveredLineNumbers(cmd, lines.length);
+  if (numbers === null) return null;
+  const rows = lines.map((text, i) => ({ no: numbers[i] ?? null, text, raw: text }));
+  const bodies = [];
+  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) bodies.push(indexServedBody(id, prior.output));
+  }
+  const cuts = planServedElisions(rows, bodies);
+  if (cuts.length === 0) return null;
+  const spans = [];
+  const push = (text, own) => {
+    const sep = spans.length === 0 ? "" : "\n";
+    const prev = spans[spans.length - 1];
+    if (prev !== void 0 && prev.own === true === own) spans[spans.length - 1] = { text: prev.text + sep + text, own };
+    else spans.push({ text: sep + text, own });
+  };
+  let at = 0;
+  for (const cut of cuts) {
+    for (let i = at; i < cut.start; i++) push(rows[i]?.raw ?? "", false);
+    const first2 = rows[cut.start];
+    const last = rows[cut.start + cut.len - 1];
+    if (first2 === void 0 || last === void 0) return null;
+    push(servedRunNotice(first2.no, last.no, cut.id, cut.len), true);
+    at = cut.start + cut.len;
+  }
+  for (let i = at; i < rows.length; i++) push(rows[i]?.raw ?? "", false);
+  return spans;
+}
+function foldShellReadBodies(cmd, output, fileKey, cwd) {
+  if (!foldingEnabled()) return null;
+  if (redactSecrets(output).count > 0) return null;
+  const lines = output.split("\n");
+  const numbers = deliveredLineNumbers(cmd, lines.length);
+  if (numbers === null) return null;
+  const rows = [];
+  for (let i = 0; i < lines.length; i++) {
+    const no = numbers[i];
+    if (no === void 0 || no === null) return null;
+    rows.push({ no, text: lines[i] ?? "", raw: lines[i] ?? "" });
+  }
+  const headRead = extractHeadFile(cmd) ?? extractGetContentHead(cmd);
+  const windowed = extractLineRangeRead(cmd) !== null || headRead !== null && lines.length >= headRead.n;
+  const folded = foldDelivery(rows, fileKey, displaySafePath(toDisplayPath(findProject(cwd ?? process.cwd())?.root, fileKey)), windowed);
+  if (folded === null) return null;
+  return { text: folded.numbered.join("\n"), folds: folded.folds };
+}
+function foldShellReadStructure(cmd, filePath, output, fileKey, cwd) {
+  if (!isWholeFileDump(cmd, filePath)) return null;
+  const originalBytes = Buffer.byteLength(output, "utf-8");
+  let onDisk;
+  try {
+    onDisk = statSync8(hostPathOfIndexKey(fileKey)).size;
+  } catch {
+    return null;
+  }
+  if (onDisk !== originalBytes) return null;
+  if (redactSecrets(output).count > 0) return null;
+  const lines = output.split("\n");
+  if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
+  const rows = lines.map((text2, i) => ({ no: i + 1, text: text2, raw: text2 }));
+  const shown = displaySafePath(toDisplayPath(findProject(cwd ?? process.cwd())?.root, fileKey));
+  const fold = planMarkdownOutline(rows, fileKey, shown, originalBytes) ?? planSourceSkeleton(rows, fileKey, shown, originalBytes);
+  if (fold === null) return null;
+  const text = fold.numbered.join("\n");
+  if (!isStructuralRewriteAccepted(originalBytes, Buffer.byteLength(text, "utf-8"), fold.ratioCap)) return null;
+  return { text, kind: fold.kind === "read:markdown_outline" ? "bash_compress:markdown-outline" : "bash_compress:source-skeleton", detail: fold.detail };
+}
+var REWRITE_CLIP_NOTE = "\n[token-goat: rewrite clipped to the harness delivery cap; the pointer above recalls the untouched output]";
+function fenceRewriteWithinCap(spans) {
+  const joined = spans.map((s) => s.text).join("");
+  const fenced = fenceUntrustedSpans(spans, UNTRUSTED_TOOL_TAG);
+  if (fenced === joined) return joined;
+  const overhead = Buffer.byteLength(fenced, "utf-8") - Buffer.byteLength(joined, "utf-8") + Buffer.byteLength(REWRITE_CLIP_NOTE, "utf-8");
+  const cut = clipToDeliveryCap(joined, overhead);
+  if (!cut.clipped) return fenced;
+  const kept = [];
+  let left2 = cut.text.length;
+  for (const s of spans) {
+    if (left2 <= 0) break;
+    kept.push(s.text.length <= left2 ? s : { ...s, text: s.text.slice(0, left2) });
+    left2 -= s.text.length;
+  }
+  return fenceUntrustedSpans(kept, UNTRUSTED_TOOL_TAG) + REWRITE_CLIP_NOTE;
+}
+async function maybeCollapseIdenticalRead(cmd, runDir, optedOut, output, exitCode, cwd, cacheMinBytes, persisted = false) {
+  if (optedOut) 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, runDir ?? 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 = bashRecallKey(cmd, runDir);
+  if (containerId === null) {
+    const elided = elideServedShellLines(cmd, output, priorIds);
+    const priced = (text) => isRewriteWorthwhile({ originalBytes, rewrittenBytes: Buffer.byteLength(text, "utf-8"), noticeBytes: 0, minNetSavingsBytes: resolveMinNetSavingsBytes() });
+    let rewrite = null;
+    if (elided !== null) {
+      const fenced = fenceRewriteWithinCap(elided);
+      if (priced(fenced)) rewrite = { text: fenced, reason: "already-served file lines withheld", kind: "bash_compress:served-elide" };
+    } else {
+      const structural = foldShellReadStructure(cmd, filePath, output, fileKey, cwd);
+      if (structural !== null && priced(structural.text)) {
+        rewrite = { text: structural.text, reason: structural.kind === "bash_compress:markdown-outline" ? "document replaced with its heading tree" : "source replaced with its structural skeleton", kind: structural.kind, detail: structural.detail };
+      }
+      if (rewrite === null) {
+        const folded = foldShellReadBodies(cmd, output, fileKey, cwd);
+        if (folded !== null) {
+          const fenced = fenceRewriteWithinCap([{ text: folded.text }]);
+          if (priced(fenced)) rewrite = { text: fenced, reason: "code bodies folded", kind: "bash_compress:body-fold", detail: foldDetail(fileKey, folded.folds) };
+        }
+      }
+      if (rewrite !== null && (extractLineRangeRead(cmd) !== null || extractHeadFile(cmd) !== null)) resetFileLineRanges(fileKey);
+    }
+    const storedId = await storeBashOutput(cmd, rewrite?.text ?? output, exitCode ?? 0, runDir);
+    recordBashOutput(sessionKey, storedId, originalBytes);
+    if (!persisted) recordFileServedOutput(fileKey, storedId);
+    if (rewrite === null) return null;
+    return emitRewrite(rewrite.text, rewrite.reason, { kind: rewrite.kind, originalBytes: deliveredOutputBytes(originalBytes), ...rewrite.detail === void 0 ? {} : { detail: rewrite.detail } });
+  }
+  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 + " --full`." : "[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 + " --full`.";
+  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 maybeElideServedGenericOutput(cmd, optedOut, output, exitCode, runDir, cacheMinBytes, persisted = false) {
+  if (optedOut) return null;
+  if (isRecallCommand(cmd)) return null;
+  if (!loadConfig().bash_compress.elide_served_shell_output) return null;
+  if (exitCode !== null && exitCode !== 0) return null;
+  if (redactSecrets(output).count > 0) return null;
+  const originalBytes = Buffer.byteLength(output, "utf-8");
+  if (originalBytes < cacheMinBytes) return null;
+  const priorIds = getFileServedOutputs(GENERIC_SERVED_OUTPUT_KEY).filter((id) => getBashOutput(id)?.command !== cmd);
+  let rewrittenText = null;
+  if (priorIds.length > 0) {
+    const elided = elideServedShellLines(cmd, output, priorIds, true);
+    const fenced = elided === null ? null : fenceRewriteWithinCap(elided);
+    if (fenced !== null && isRewriteWorthwhile({ originalBytes, rewrittenBytes: Buffer.byteLength(fenced, "utf-8"), noticeBytes: 0, minNetSavingsBytes: resolveMinNetSavingsBytes() })) {
+      rewrittenText = fenced;
     }
-    return passOutput();
   }
-  if (isTestRunnerCommand(cmd) && isDirectTestRunnerCommand(cmd) && !hasTestRunScopeOrBudget(cmd)) {
-    const compression = maybeCompressRewrite(event, rawCmd, cmd);
-    if (compression !== null) return compression;
-    const key = `test-run-budget:${event.sessionId}:${shortFingerprint(cmd)}`;
-    if (!wasHintShown(key)) {
-      markHintShown(key);
-      recordStat("session_hint", 0, 0);
-      return contextOutput(
-        "This test command has no targeted selector or explicit timeout. Prefer a focused test path/name or the runner\u2019s supported timeout before starting a potentially unbounded suite; run the full suite deliberately when it is needed."
-      );
-    }
+  if (!persisted) recordFileServedOutput(GENERIC_SERVED_OUTPUT_KEY, await storeBashOutput(cmd, rewrittenText ?? output, exitCode ?? 0, runDir));
+  if (rewrittenText === null) return null;
+  return emitRewrite(rewrittenText, "already-served shell output collapsed", { kind: "bash_compress:generic-served-elision", originalBytes: deliveredOutputBytes(originalBytes) });
+}
+async function maybeCompressCompoundOutput(cmd, optedOut, output, exitCode, runDir, cacheMinBytes, isUnwrapped = false) {
+  if (optedOut) return null;
+  if (!isUnwrapped) return null;
+  if (isFullRecallCommand(cmd)) return null;
+  if (isTokenGoatOwnCommand(cmd)) return null;
+  if (exitCode !== null && exitCode !== 0) return null;
+  let cfg;
+  try {
+    cfg = loadConfig().bash_compress;
+  } catch {
+    return null;
   }
-  if (!isBuildCommand(cmd) && detectFromCommand(stripTrailingStderrRedirect(cmd), preHookCwd ?? void 0) === null) return passOutput();
-  const cmdHash = shortFingerprint(stripOutputPipeline(cmd));
-  const outputId = getBashOutputId(cmdHash);
-  const entryRaw = outputId !== null ? getBashOutput(outputId) : null;
-  const entry = entryRaw !== null && !isBashEntryStale(entryRaw, cmd, preHookCwd) ? entryRaw : null;
-  if (outputId !== null && entry !== null && recallWorthShowing(outputId, entry)) {
-    const bytes = entry.sizeBytes;
-    recordStat("bash_compress:recall", bytes, savedTokensFromBytes(bytes));
-    return contextOutput(buildRecallHint(cmd, outputId));
+  if (!cfg.enabled || cfg.disabled_filters.includes("generic")) return null;
+  if (Buffer.byteLength(output, "utf-8") < cacheMinBytes) return null;
+  const shaped = pipelineShapeFilter(cmd, runDir) ?? (isUnwrapped ? detectFromCommand(cmd, runDir ?? void 0) ?? null : null);
+  const useShaped = shaped !== null && !cfg.disabled_filters.includes(shaped.filter.name);
+  const filter3 = useShaped ? shaped.filter : filterByName("generic");
+  if (filter3 === null) return null;
+  const filterArgv = useShaped ? shaped.argv : [];
+  const compressed = compressOutput(filter3, output, "", exitCode ?? 0, filterArgv, {
+    maxLines: cfg.max_lines,
+    maxBytes: cfg.max_bytes
+  });
+  const minNet = resolveMinNetSavingsBytes();
+  if (!compressed.worthApplying(minNet)) return null;
+  const id = bashOutputIdSync(cmd, output, runDir);
+  const { body: untrusted, notices } = splitOwnTrailingNotices(compressed.text);
+  const marker = compressed.withMarker(minNet).slice(compressed.text.length);
+  const body = fenceUntrusted(untrusted, UNTRUSTED_TOOL_TAG) + notices + marker + "\n[token-goat] full output: bash-output " + id + " --full";
+  const emittedBytes = Buffer.byteLength(body, "utf-8");
+  if (!isRewriteWorthwhile({
+    originalBytes: compressed.originalBytes,
+    rewrittenBytes: emittedBytes,
+    noticeBytes: 0,
+    minNetSavingsBytes: minNet
+  })) {
+    return null;
   }
-  return maybeCompressRewrite(event, rawCmd, cmd) ?? passOutput();
+  await storeBashOutput(cmd, output, exitCode ?? 0, runDir);
+  return emitRewrite(body, "bash", { kind: `bash_compress:${filter3.name}`, originalBytes: deliveredOutputBytes(compressed.originalBytes) });
 }
-function preBashHandler(event) {
-  return applyHintTracking(event, preBashHandlerInner(event), classifyBashHint);
+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 maybeFoldCurlHtml(cmd, output, id) {
+  if (!isCurlGetCommand(cmd) || !looksLikeHtml(output)) return null;
+  let cfg;
+  try {
+    cfg = loadConfig().bash_compress;
+  } catch {
+    return null;
+  }
+  if (!cfg.enabled || cfg.disabled_filters.includes("curl-html")) return null;
+  let cleaned;
+  try {
+    cleaned = extractCleanText(output);
+  } catch {
+    return null;
+  }
+  const originalBytes = Buffer.byteLength(output, "utf-8");
+  const notice = `[token-goat: curl HTML body cleaned via extractCleanText; use \`token-goat bash-output ${id} --full\` to recall the raw markup]
+`;
+  const noticeBytes = Buffer.byteLength(notice, "utf-8");
+  const clipNote = "\n[token-goat: cleaned text clipped to the harness delivery cap; the notice at the top of this output recalls the full raw markup]";
+  const fenceOverhead = Buffer.byteLength(fenceUntrusted(cleaned, UNTRUSTED_TOOL_TAG), "utf-8") - Buffer.byteLength(cleaned, "utf-8");
+  const cut = clipToDeliveryCap(cleaned, noticeBytes + fenceOverhead + Buffer.byteLength(clipNote, "utf-8"));
+  const body = cut.text;
+  const clipped = cut.clipped ? clipNote : "";
+  const fenced = fenceUntrusted(body, UNTRUSTED_TOOL_TAG) + clipped;
+  if (!isRewriteWorthwhile({
+    originalBytes,
+    rewrittenBytes: Buffer.byteLength(fenced, "utf-8"),
+    noticeBytes,
+    minNetSavingsBytes: resolveMinNetSavingsBytes()
+  })) {
+    return null;
+  }
+  return emitRewrite(notice + fenced, "curl HTML body cleaned", { kind: "bash_compress:curl-html", originalBytes: deliveredOutputBytes(originalBytes) });
 }
-registerHook("pre_tool_use", preBashHandler, { toolName: "Bash" });
 function readPersistedBashOutput(resp, cwd, sessionId) {
   const persistedPath = resp["persistedOutputPath"];
   if (typeof persistedPath !== "string" || persistedPath === "" || sessionId === "") return null;
-  const root = path4.join(projectTranscriptsDir(cwd ?? process.cwd()), sessionId, "tool-results");
+  const root = path6.join(projectTranscriptsDir(cwd ?? process.cwd()), sessionId, "tool-results");
   if (!isInsideRoot(persistedPath, root)) return null;
   try {
-    const stat = statSync7(persistedPath);
+    const stat = statSync8(persistedPath);
     if (!stat.isFile() || stat.size > MAX_CAPTURE_BYTES) return null;
     const persistedSize = resp["persistedOutputSize"];
     if (typeof persistedSize === "number" && Math.abs(stat.size - persistedSize) > 8) return null;
-    return readFileSync5(persistedPath, "utf-8");
+    return readFileSync9(persistedPath, "utf-8");
   } catch {
     return null;
   }
@@ -9230,63 +9785,71 @@ function forgetPersistedLineRangeReads(rawCmd, cmd, cwd) {
     resetFileLineRanges(resolveIndexPath(hintPath, hintCwd));
   }
 }
-function recordBashFileReadsForSessionCache(cmd, cwd) {
-  const resolve2 = (p) => resolveIndexPath(p, cwd ?? process.cwd());
+function recordBashFileReadsForSessionCache(cmd, runDir) {
+  const base = runDir ?? process.cwd();
+  const record = (p, put) => {
+    const file = resolveIndexPath(p, base);
+    if (isFileAtIndexKey(file)) put(file);
+  };
   const gcTail = extractGetContentTail(cmd);
   if (gcTail !== null) {
-    markFileTruncated(resolve2(gcTail.filePath));
+    record(gcTail.filePath, markFileTruncated);
     return;
   }
   const tail = extractTailFile(cmd);
   if (tail !== null) {
-    markFileTruncated(resolve2(tail.filePath));
+    record(tail.filePath, markFileTruncated);
     return;
   }
   const gcSelect = extractGetContentSelectFirst(cmd);
   if (gcSelect !== null) {
-    recordFileLineRange(resolve2(gcSelect.filePath), 1, gcSelect.n);
+    record(gcSelect.filePath, (file) => recordFileLineRange(file, 1, gcSelect.n));
     return;
   }
   const gcHead = extractGetContentHead(cmd);
   if (gcHead !== null) {
-    recordFileLineRange(resolve2(gcHead.filePath), 1, gcHead.n);
+    record(gcHead.filePath, (file) => recordFileLineRange(file, 1, gcHead.n));
     return;
   }
   const head = extractHeadFile(cmd);
   if (head !== null) {
-    recordFileLineRange(resolve2(head.filePath), 1, head.n);
+    record(head.filePath, (file) => recordFileLineRange(file, 1, head.n));
     return;
   }
   const cat = extractCatFile(cmd);
   if (cat !== null) {
-    recordFileRead(resolve2(cat.filePath));
+    record(cat.filePath, recordFileRead);
     return;
   }
   const catMulti = extractCatFilesMulti(cmd);
   if (catMulti !== null) {
-    for (const r of catMulti) recordFileRead(resolve2(r.filePath));
+    for (const r of catMulti) record(r.filePath, recordFileRead);
     return;
   }
   const wslCat = extractWslCatFile(cmd);
   if (wslCat !== null) {
-    recordFileRead(resolve2(wslCat.filePath));
+    record(wslCat.filePath, recordFileRead);
     return;
   }
 }
-async function maybeEmitLargeUncompressedHint(cmd, rawCmd, optedOut, output, exitCode, cwd, isUnwrapped, event, ansiResult) {
+async function maybeEmitLargeUncompressedHint(cmd, rawCmd, optedOut, output, exitCode, runDir, isUnwrapped, event, ansiResult) {
   const outputBytes = Buffer.byteLength(output, "utf-8");
   if (outputBytes < 4096 || optedOut || exitCode !== null && exitCode !== 0 || // token-goat's own output is already the narrow form; telling the model to compress it is noise.
-  /^\s*token-goat\s/.test(cmd) || event.raw["_tg_harness"] !== "vscode" && (isCompressibleSingleCommand(cmd) || !isUnwrapped)) {
+  isTokenGoatOwnCommand(cmd) || // a line-range read, piped or repeated, is already the narrow slice; compressing it saves nothing.
+  extractLineRangeReadsCompound(cmd) !== null || event.raw["_tg_harness"] !== "vscode" && (isCompressibleSingleCommand(cmd) || !isUnwrapped)) {
     return null;
   }
   const key = `bash-uncompressed-4k:${event.sessionId ?? ""}:${shortFingerprint(cmd)}`;
   if (wasHintShown(key)) return null;
   markHintShown(key);
   recordStat("session_hint", 0, 0);
-  const id = await storeBashOutput(cmd, output, exitCode ?? 0, cwd);
+  const id = await storeBashOutput(cmd, output, exitCode ?? 0, runDir);
   const kb = Math.round(outputBytes / 1024);
-  const runCmd = stripCdPrefix(rawCmd);
-  const compressable = !/["`$\r\n]/.test(runCmd);
+  const bare = stripCdPrefix(rawCmd);
+  const cdDir = bare === rawCmd ? null : runDir;
+  const cdHost = cdDir === null ? null : dirAtIndexKey(cdDir);
+  const runCmd = cdHost === null ? bare : `cd '${cdHost}' && ${bare}`;
+  const compressable = !/["`$\r\n]/.test(runCmd) && (cdDir === null || cdHost !== null && !cdHost.includes("'"));
   const msg = `[tg] Output was ${kb}KB uncompressed; \`token-goat bash-output ${id}\` recalls it` + (compressable ? `, and \`token-goat compress -c "${displaySafeText(runCmd)}"\` compresses the next run.` : ".");
   if (ansiResult !== null && ansiResult.hookType === "rewriteOutput") {
     return emitRewrite(msg + "\n" + fenceUntrusted(ansiResult.updatedOutput, UNTRUSTED_TOOL_TAG), "large uncompressed output hint", void 0, "counted-elsewhere");
@@ -9298,17 +9861,19 @@ async function postBashHandler(event) {
     const rawCmdRaw = extractCommand(event);
     if (rawCmdRaw === void 0) return passOutput();
     const isUnwrapped = unwrapCompressCommand(rawCmdRaw) === null;
-    const rawCmd = unwrapCompressCommand(rawCmdRaw) ?? rawCmdRaw;
-    const cmd = stripCommandPrefix(rawCmd);
     const output = extractBashOutput(event);
     const exitCode = extractExitCode(event.raw);
     const cwd = getCwd(event) ?? null;
+    const toolUseId = event.raw["tool_use_id"];
+    const heldStartCwd = typeof toolUseId === "string" && toolUseId !== "" ? takeBashStartCwd(toolUseId) : null;
+    const startCwd = heldStartCwd ?? cwd;
+    const { rawCmd, cmd, runDir } = resolveBashCall(rawCmdRaw, startCwd);
     const cacheMinBytes = loadConfig().bash_compress.cache_min_bytes;
     const resp = event.raw["tool_response"];
     const persisted = resp !== null && typeof resp === "object" && typeof resp["persistedOutputPath"] === "string" && resp["persistedOutputPath"] !== "";
     const optedOut = compressionOptedOut(rawCmd);
     if (isHeadMovingGitCommand(cmd) && (exitCode === null || exitCode === 0)) {
-      const gitDir = cwd ?? process.cwd();
+      const gitDir = runDir ?? process.cwd();
       let diffBase = "HEAD@{1}";
       if (ORIG_HEAD_ELIGIBLE_GIT_RE.test(cmd)) {
         const reflogTop = runGit(["reflog", "-1", "--format=%gs", "HEAD"], { cwd: gitDir, timeoutMs: 5e3 });
@@ -9328,18 +9893,19 @@ async function postBashHandler(event) {
       }
     }
     if (exitCode === null || exitCode === 0) {
-      enqueueNonHeadMovingRewrites(cmd, rawCmd, cwd ?? process.cwd());
+      enqueueNonHeadMovingRewrites(cmd, runDir ?? process.cwd());
     }
     const curlDl = extractCurlDownload(cmd);
     if (curlDl !== null && (exitCode === null || exitCode === 0)) {
-      const resolvedOutputPath = resolveIndexPath(curlDl.outputPath, cwd ?? process.cwd());
-      if (existsSync(resolvedOutputPath)) {
-        recordCurlDownload(curlDl.url, resolvedOutputPath);
+      const outputOnDisk = hostPathOfTypedPath(curlDl.outputPath, runDir ?? process.cwd());
+      if (existsSync2(outputOnDisk)) {
+        recordCurlDownload(curlDl.url, outputOnDisk);
       }
     }
-    if (persisted) forgetPersistedLineRangeReads(rawCmd, cmd, cwd);
-    else if (exitCode === null || exitCode === 0) recordBashFileReadsForSessionCache(cmd, cwd);
-    const tgRead = extractTgSurgicalRead(cmd, cwd);
+    if (persisted) forgetPersistedLineRangeReads(rawCmd, cmd, startCwd);
+    else if (exitCode === null || exitCode === 0) recordBashFileReadsForSessionCache(cmd, runDir);
+    let tgRead = extractTgSurgicalRead(cmd, runDir);
+    if (heldStartCwd === null && cwd !== null && tgRead?.filePath != null && !isFileAtIndexKey(tgRead.filePath)) tgRead = extractTgSurgicalRead(cmd, cwd);
     if (tgRead !== null && (exitCode === null || exitCode === 0)) {
       recordCliRead(tgRead.sub + "::" + tgRead.spec);
       if (tgRead.filePath !== null) {
@@ -9354,8 +9920,8 @@ async function postBashHandler(event) {
       }
     }
     if (isReadOnlyGhApi(cmd) && (exitCode === null || exitCode === 0) && Buffer.byteLength(output, "utf-8") >= cacheMinBytes) {
-      const ghCacheHash = shortFingerprint(stripOutputPipeline(cmd));
-      const ghCacheId = await storeBashOutput(cmd, output, exitCode ?? 0, cwd);
+      const ghCacheHash = bashRecallKey(cmd, runDir);
+      const ghCacheId = await storeBashOutput(cmd, output, exitCode ?? 0, runDir);
       recordBashOutput(ghCacheHash, ghCacheId, Buffer.byteLength(output, "utf-8"));
     }
     const ghHint = buildGhApiHint(cmd, output, exitCode);
@@ -9367,52 +9933,54 @@ async function postBashHandler(event) {
     if (ghView !== null && (exitCode === null || exitCode === 0) && !wasHintShown(GH_VIEW_BATCH_HINT_KEY)) {
       markHintShown(GH_VIEW_BATCH_HINT_KEY);
       if (Buffer.byteLength(output, "utf-8") >= cacheMinBytes) {
-        const ghViewId = await storeBashOutput(cmd, output, exitCode ?? 0, cwd);
-        recordBashOutput(shortFingerprint(stripOutputPipeline(cmd)), ghViewId, Buffer.byteLength(output, "utf-8"));
+        const ghViewId = await storeBashOutput(cmd, output, exitCode ?? 0, runDir);
+        recordBashOutput(bashRecallKey(cmd, runDir), ghViewId, Buffer.byteLength(output, "utf-8"));
       }
       recordStat("session_hint", 0, 0);
       return contextOutput(buildGhViewBatchAdvisory(ghView.sub, ghView.ref));
     }
     if (isTestRunnerCommand(cmd) && exitCode !== null && exitCode !== 0 && Buffer.byteLength(output, "utf-8") >= cacheMinBytes) {
-      const testFailHash = shortFingerprint(stripOutputPipeline(cmd));
-      const testFailId = await storeBashOutput(cmd, output, exitCode, cwd);
+      const testFailHash = bashRecallKey(cmd, runDir);
+      const testFailId = await storeBashOutput(cmd, output, exitCode, runDir);
       recordBashOutput(testFailHash, testFailId, Buffer.byteLength(output, "utf-8"));
       recordStat("session_hint", 0, 0);
       return contextOutput(`[token-goat] Tests failed. Run \`token-goat bash-output ${testFailId} | token-goat failures\` to see just the failing blocks instead of the full output.`);
     }
     if (isScopedGitStatusOrDiffStatCommand(cmd) && (exitCode === null || exitCode === 0) && Buffer.byteLength(output, "utf-8") >= cacheMinBytes) {
-      const gitScopedCacheHash = shortFingerprint(stripOutputPipeline(cmd));
-      const gitScopedCacheId = await storeBashOutput(cmd, output, exitCode ?? 0, cwd);
+      const gitScopedCacheHash = bashRecallKey(cmd, runDir);
+      const gitScopedCacheId = await storeBashOutput(cmd, output, exitCode ?? 0, runDir);
       recordBashOutput(gitScopedCacheHash, gitScopedCacheId, Buffer.byteLength(output, "utf-8"));
     }
-    if (isUnwrapped && /^git(?:\s+-[^\s]+|\s+--[^\s]+)*\s+diff\b/i.test(cmd)) {
-      const unwrappedCompressed = await maybeCompressCompoundOutput(cmd, optedOut, output, exitCode, cwd, cacheMinBytes, isUnwrapped);
-      if (unwrappedCompressed !== null) return unwrappedCompressed;
+    if (isUnwrapped && (isTestRunnerCommand(cmd) && detectFromCommand(cmd, runDir ?? void 0) !== null || /^git(?:\s+-[^\s]+|\s+--[^\s]+)*\s+diff\b/i.test(cmd))) {
+      const unwrappedCompressed = await maybeCompressCompoundOutput(cmd, optedOut, output, exitCode, runDir, cacheMinBytes, isUnwrapped);
+      if (unwrappedCompressed !== null) {
+        recordBashOutput(bashRecallKey(cmd, runDir), bashOutputIdSync(cmd, output, runDir), Buffer.byteLength(output, "utf-8"));
+        return unwrappedCompressed;
+      }
     }
     const isMonitoring = getMonitoringRecallHint(cmd) !== null;
     const isFileRead = pureFileReadPath(cmd) !== null;
     if (isFileRead || !isMonitoring && !isBuildCommand(cmd) && !isCurlGetCommand(cmd)) {
-      const identical = await maybeCollapseIdenticalRead(cmd, rawCmd, optedOut, output, exitCode, cwd, cacheMinBytes, persisted);
+      const identical = await maybeCollapseIdenticalRead(cmd, runDir, optedOut, output, exitCode, cwd, cacheMinBytes, persisted);
       if (identical !== null) return identical;
       if (!isFileRead && (!isUnwrapped || !isCompressibleSingleCommand(cmd))) {
-        const compound = await maybeCompressCompoundOutput(cmd, optedOut, output, exitCode, cwd, cacheMinBytes, isUnwrapped);
+        const compound = await maybeCompressCompoundOutput(cmd, optedOut, output, exitCode, runDir, cacheMinBytes, isUnwrapped);
         if (compound !== null) return compound;
       }
       if (!isFileRead && extractLineRangeReadsCompound(cmd) === null) {
-        const genericElision = await maybeElideServedGenericOutput(cmd, optedOut, output, exitCode, cwd, cacheMinBytes, persisted);
+        const genericElision = await maybeElideServedGenericOutput(cmd, optedOut, output, exitCode, runDir, cacheMinBytes, persisted);
         if (genericElision !== null) return genericElision;
       }
       const ansiStripped = optedOut ? null : maybeStripAnsiOnly(output);
-      const largeHint2 = await maybeEmitLargeUncompressedHint(cmd, rawCmd, optedOut, output, exitCode, cwd, isUnwrapped, event, ansiStripped);
+      const largeHint2 = await maybeEmitLargeUncompressedHint(cmd, rawCmd, optedOut, output, exitCode, runDir, isUnwrapped, event, ansiStripped);
       if (largeHint2 !== null) return largeHint2;
       return ansiStripped ?? passOutput();
     }
     if (Buffer.byteLength(output, "utf-8") < cacheMinBytes) return passOutput();
-    const cacheKey = isCurlGetCommand(cmd) ? extractCurlUrl(cmd) ?? cmd : stripOutputPipeline(cmd);
-    const simpleHash = shortFingerprint(cacheKey);
-    const priorId = await commandHash(cmd, cwd);
+    const simpleHash = isCurlGetCommand(cmd) ? shortFingerprint(extractCurlUrl(cmd) ?? cmd) : bashRecallKey(cmd, runDir);
+    const priorId = await commandHash(cmd, runDir);
     const priorEntry = getBashOutput(priorId);
-    const id = await storeBashOutput(cmd, output, exitCode ?? 0, cwd);
+    const id = await storeBashOutput(cmd, output, exitCode ?? 0, runDir);
     recordBashOutput(simpleHash, id, Buffer.byteLength(output, "utf-8"));
     if (priorEntry !== null) {
       recordBashRerun(simpleHash);
@@ -9425,7 +9993,7 @@ async function postBashHandler(event) {
     const curlHtmlFold = optedOut ? null : maybeFoldCurlHtml(cmd, output, id);
     if (curlHtmlFold !== null) return curlHtmlFold;
     const ansiOnly = optedOut ? null : maybeStripAnsiOnly(output);
-    const largeHint = await maybeEmitLargeUncompressedHint(cmd, rawCmd, optedOut, output, exitCode, cwd, isUnwrapped, event, ansiOnly);
+    const largeHint = await maybeEmitLargeUncompressedHint(cmd, rawCmd, optedOut, output, exitCode, runDir, isUnwrapped, event, ansiOnly);
     if (largeHint !== null) return largeHint;
     if (ansiOnly !== null) return ansiOnly;
   } catch {
@@ -9436,14 +10004,13 @@ registerHook("post_tool_use", postBashHandler, { toolName: "Bash" });
 
 // src/hooks_bashoutput.ts
 init_define_import_meta_env();
-function pollCacheId(sessionId, bashId) {
-  return `bgpoll_${shortFingerprint(`${sessionId}\0bashoutput\0${bashId}`)}`;
+function pollCacheId(tool, sessionId, pollId) {
+  return `${tool.blobPrefix}_${shortFingerprint(`${sessionId}\0${tool.channel}\0${pollId}`)}`;
 }
-function storePollSnapshot(sessionId, bashId, output) {
-  const id = pollCacheId(sessionId, bashId);
+function storePollSnapshot(tool, id, pollId, output) {
   const entry = {
     id,
-    command: `bashoutput:${bashId}`,
+    command: `${tool.channel}:${pollId}`,
     output,
     exitCode: 0,
     storedAt: Date.now(),
@@ -9451,61 +10018,55 @@ function storePollSnapshot(sessionId, bashId, output) {
   };
   storeBlob(BASH_OUTPUT_SUBDIR, id, entry);
 }
+function rewritePoll(tool, sessionId, pollId, rawOutput) {
+  if (!rawOutput) return passOutput();
+  const output = redactSecrets(rawOutput).text;
+  if (!output) return passOutput();
+  const originalBytes = Buffer.byteLength(rawOutput, "utf-8");
+  const outputBytes = Buffer.byteLength(output, "utf-8");
+  const id = pollCacheId(tool, sessionId, pollId);
+  const prior = getBashOutput(id);
+  const minBytes = loadConfig().bash_compress.cache_min_bytes;
+  storePollSnapshot(tool, id, pollId, output);
+  if (prior === null) {
+    if (tool.channel === "bashoutput") return passOutput();
+    const collapsed = tool.compactFirst(output);
+    if (collapsed === output) return passOutput();
+    const collapsedBytes = Buffer.byteLength(collapsed, "utf-8");
+    if (outputBytes - collapsedBytes < minBytes) return passOutput();
+    if (!isRewriteWorthwhile({ originalBytes: outputBytes, rewrittenBytes: collapsedBytes, noticeBytes: 0, minNetSavingsBytes: resolveMinNetSavingsBytes() })) return passOutput();
+    return emitRewrite(collapsed, "taskoutput", { kind: "taskoutput:collapse", originalBytes });
+  }
+  if (outputBytes < minBytes) return passOutput();
+  if (output === prior.output) {
+    const unchangedNotice = `[token-goat: ${tool.idArg} ${pollId} unchanged since last poll -- no new output]`;
+    if (!isRewriteWorthwhile({ originalBytes: outputBytes, rewrittenBytes: 0, noticeBytes: Buffer.byteLength(unchangedNotice, "utf-8"), minNetSavingsBytes: resolveMinNetSavingsBytes() })) return passOutput();
+    return tool.channel === "bashoutput" ? emitRewrite(unchangedNotice, "bashoutput", { kind: "bashoutput:unchanged", originalBytes }) : emitRewrite(unchangedNotice, "taskoutput", { kind: "taskoutput:unchanged", originalBytes });
+  }
+  if (!output.startsWith(prior.output)) return passOutput();
+  const deltaNotice = `[token-goat: ${tool.idArg} ${pollId} delta since last poll]
+`;
+  const fenced = fenceUntrusted(tool.compactDelta(output.slice(prior.output.length)), UNTRUSTED_TOOL_TAG);
+  const body = `${deltaNotice}${fenced}`;
+  if (!isRewriteWorthwhile({ originalBytes: outputBytes, rewrittenBytes: Buffer.byteLength(body, "utf-8"), noticeBytes: 0, minNetSavingsBytes: resolveMinNetSavingsBytes() })) return passOutput();
+  return tool.channel === "bashoutput" ? emitRewrite(body, "bashoutput", { kind: "bashoutput:delta", originalBytes }) : emitRewrite(body, "taskoutput", { kind: "taskoutput:delta", originalBytes });
+}
 function getBashId(toolInput) {
   const value = toolInput["bash_id"];
   return typeof value === "string" && value !== "" ? value : void 0;
 }
+function compactPytestDelta(delta) {
+  if (!looksLikePytestOutput(delta)) return delta;
+  const compressed = pytestFilter.apply(delta, "", 0, []);
+  return compressed.worthApplying(resolveMinNetSavingsBytes()) ? compressed.withMarker(resolveMinNetSavingsBytes()) : delta;
+}
+var BASH_OUTPUT_POLL = { channel: "bashoutput", blobPrefix: "bgpoll", idArg: "bash_id", compactDelta: compactPytestDelta };
 function postBashOutputHandler(event) {
   try {
     if (getToolName(event) !== "BashOutput" || !event.sessionId) return passOutput();
     const bashId = getBashId(getToolInput(event));
     if (bashId === void 0) return passOutput();
-    const rawOutput = extractToolResultText(event.raw);
-    if (!rawOutput) return passOutput();
-    const output = redactSecrets(rawOutput).text;
-    if (!output) return passOutput();
-    const prior = getBashOutput(pollCacheId(event.sessionId, bashId));
-    const minBytes = loadConfig().bash_compress.cache_min_bytes;
-    if (prior === null) {
-      storePollSnapshot(event.sessionId, bashId, output);
-      return passOutput();
-    }
-    if (output === prior.output) {
-      storePollSnapshot(event.sessionId, bashId, output);
-      if (Buffer.byteLength(output, "utf-8") < minBytes) return passOutput();
-      const unchangedNotice = `[token-goat: bash_id ${bashId} unchanged since last poll -- no new output]`;
-      if (!isRewriteWorthwhile({
-        originalBytes: Buffer.byteLength(output, "utf-8"),
-        rewrittenBytes: 0,
-        noticeBytes: Buffer.byteLength(unchangedNotice, "utf-8"),
-        minNetSavingsBytes: resolveMinNetSavingsBytes()
-      })) {
-        return passOutput();
-      }
-      return emitRewrite(unchangedNotice, "bashoutput", { kind: "bashoutput:unchanged", originalBytes: Buffer.byteLength(rawOutput, "utf-8") });
-    }
-    if (!output.startsWith(prior.output)) {
-      storePollSnapshot(event.sessionId, bashId, output);
-      return passOutput();
-    }
-    const delta = output.slice(prior.output.length);
-    storePollSnapshot(event.sessionId, bashId, output);
-    if (Buffer.byteLength(delta, "utf-8") < minBytes) return passOutput();
-    const compressedDelta = looksLikePytestOutput(delta) ? pytestFilter.apply(delta, "", 0, []) : null;
-    const deltaBody = compressedDelta !== null && compressedDelta.worthApplying(resolveMinNetSavingsBytes()) ? compressedDelta.withMarker(resolveMinNetSavingsBytes()) : delta;
-    const deltaNotice = `[token-goat: bash_id ${bashId} delta since last poll]
-`;
-    const fenced = fenceUntrusted(deltaBody, UNTRUSTED_TOOL_TAG);
-    const body = `${deltaNotice}${fenced}`;
-    if (!isRewriteWorthwhile({
-      originalBytes: Buffer.byteLength(output, "utf-8"),
-      rewrittenBytes: Buffer.byteLength(body, "utf-8"),
-      noticeBytes: 0,
-      minNetSavingsBytes: resolveMinNetSavingsBytes()
-    })) {
-      return passOutput();
-    }
-    return emitRewrite(body, "bashoutput", { kind: "bashoutput:delta", originalBytes: Buffer.byteLength(rawOutput, "utf-8") });
+    return rewritePoll(BASH_OUTPUT_POLL, event.sessionId, bashId, extractToolResultText(event.raw));
   } catch {
     return passOutput();
   }
@@ -9514,21 +10075,6 @@ registerHook("post_tool_use", postBashOutputHandler, { toolName: "BashOutput" })
 
 // src/hooks_taskoutput.ts
 init_define_import_meta_env();
-function pollCacheId2(sessionId, taskId) {
-  return `taskpoll_${shortFingerprint(`${sessionId}\0taskoutput\0${taskId}`)}`;
-}
-function storePollSnapshot2(sessionId, taskId, output) {
-  const id = pollCacheId2(sessionId, taskId);
-  const entry = {
-    id,
-    command: `taskoutput:${taskId}`,
-    output,
-    exitCode: 0,
-    storedAt: Date.now(),
-    sizeBytes: Buffer.byteLength(output, "utf-8")
-  };
-  storeBlob(BASH_OUTPUT_SUBDIR, id, entry);
-}
 function collapseRepeatedLines(text) {
   return dedupeConsecutive(text.split("\n")).join("\n");
 }
@@ -9547,68 +10093,13 @@ function extractTaskOutputText(raw) {
   }
   return extractToolResultText(raw);
 }
+var TASK_OUTPUT_POLL = { channel: "taskoutput", blobPrefix: "taskpoll", idArg: "task_id", compactDelta: collapseRepeatedLines, compactFirst: collapseRepeatedLines };
 function postTaskOutputHandler(event) {
   try {
     if (getToolName(event) !== "TaskOutput" || !event.sessionId) return passOutput();
     const taskId = getTaskId(getToolInput(event));
     if (taskId === void 0) return passOutput();
-    const rawOutput = extractTaskOutputText(event.raw);
-    if (!rawOutput) return passOutput();
-    const output = redactSecrets(rawOutput).text;
-    if (!output) return passOutput();
-    const prior = getBashOutput(pollCacheId2(event.sessionId, taskId));
-    const minBytes = loadConfig().bash_compress.cache_min_bytes;
-    if (prior === null) {
-      storePollSnapshot2(event.sessionId, taskId, output);
-      const collapsed = collapseRepeatedLines(output);
-      if (collapsed === output) return passOutput();
-      const savings = Buffer.byteLength(output, "utf-8") - Buffer.byteLength(collapsed, "utf-8");
-      if (savings < minBytes) return passOutput();
-      if (!isRewriteWorthwhile({
-        originalBytes: Buffer.byteLength(output, "utf-8"),
-        rewrittenBytes: Buffer.byteLength(collapsed, "utf-8"),
-        noticeBytes: 0,
-        minNetSavingsBytes: resolveMinNetSavingsBytes()
-      })) {
-        return passOutput();
-      }
-      return emitRewrite(collapsed, "taskoutput", { kind: "taskoutput:collapse", originalBytes: Buffer.byteLength(rawOutput, "utf-8") });
-    }
-    if (output === prior.output) {
-      storePollSnapshot2(event.sessionId, taskId, output);
-      if (Buffer.byteLength(output, "utf-8") < minBytes) return passOutput();
-      const unchangedNotice = `[token-goat: task_id ${taskId} unchanged since last poll -- no new output]`;
-      if (!isRewriteWorthwhile({
-        originalBytes: Buffer.byteLength(output, "utf-8"),
-        rewrittenBytes: 0,
-        noticeBytes: Buffer.byteLength(unchangedNotice, "utf-8"),
-        minNetSavingsBytes: resolveMinNetSavingsBytes()
-      })) {
-        return passOutput();
-      }
-      return emitRewrite(unchangedNotice, "taskoutput", { kind: "taskoutput:unchanged", originalBytes: Buffer.byteLength(rawOutput, "utf-8") });
-    }
-    if (!output.startsWith(prior.output)) {
-      storePollSnapshot2(event.sessionId, taskId, output);
-      return passOutput();
-    }
-    const delta = output.slice(prior.output.length);
-    storePollSnapshot2(event.sessionId, taskId, output);
-    if (Buffer.byteLength(delta, "utf-8") < minBytes) return passOutput();
-    const collapsedDelta = collapseRepeatedLines(delta);
-    const deltaNotice = `[token-goat: task_id ${taskId} delta since last poll]
-`;
-    const fenced = fenceUntrusted(collapsedDelta, UNTRUSTED_TOOL_TAG);
-    const body = `${deltaNotice}${fenced}`;
-    if (!isRewriteWorthwhile({
-      originalBytes: Buffer.byteLength(output, "utf-8"),
-      rewrittenBytes: Buffer.byteLength(body, "utf-8"),
-      noticeBytes: 0,
-      minNetSavingsBytes: resolveMinNetSavingsBytes()
-    })) {
-      return passOutput();
-    }
-    return emitRewrite(body, "taskoutput", { kind: "taskoutput:delta", originalBytes: Buffer.byteLength(rawOutput, "utf-8") });
+    return rewritePoll(TASK_OUTPUT_POLL, event.sessionId, taskId, extractTaskOutputText(event.raw));
   } catch {
     return passOutput();
   }
@@ -9617,8 +10108,8 @@ registerHook("post_tool_use", postTaskOutputHandler, { toolName: "TaskOutput" })
 
 // src/hooks_tool_failure.ts
 init_define_import_meta_env();
-import { existsSync as existsSync2, readFileSync as readFileSync6, statSync as statSync8, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname3, relative as relative2 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync10, statSync as statSync9, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname5, relative as relative2 } from "node:path";
 var FAILURE_SUFFIX = ".tool-failures";
 var MAX_TRACKED_FAILURES = 64;
 var SIGNATURE_ERROR_CHARS = 200;
@@ -9645,7 +10136,7 @@ function ledgerPath(sessionId) {
 }
 function readLedger(target) {
   try {
-    const parsed = JSON.parse(readFileSync6(target, "utf8"));
+    const parsed = JSON.parse(readFileSync10(target, "utf8"));
     if (parsed !== null && typeof parsed === "object") {
       const seen = parsed.seen;
       const order = parsed.order;
@@ -9659,8 +10150,8 @@ function readLedger(target) {
 }
 function writeLedger(target, ledger) {
   try {
-    ensureDirSync(dirname3(target));
-    writeFileSync3(target, JSON.stringify(ledger), "utf8");
+    ensureDirSync(dirname5(target));
+    writeFileSync5(target, JSON.stringify(ledger), "utf8");
   } catch {
   }
 }
@@ -9703,16 +10194,16 @@ function diagnoseEditFailure(event, errorText) {
   if (!isMultiple && !isNotFound) {
     return null;
   }
-  const filePath = getFilePath(event) ?? (typeof event.toolInput["path"] === "string" ? event.toolInput["path"] : void 0);
+  const filePath = getFilePath(event) ?? (typeof event.toolInput["path"] === "string" && event.toolInput["path"] !== "" ? resolveEventPath(event, event.toolInput["path"]) : void 0);
   if (!filePath) return null;
   const oldString = typeof event.toolInput["old_string"] === "string" ? event.toolInput["old_string"] : typeof event.toolInput["old_str"] === "string" ? event.toolInput["old_str"] : typeof event.toolInput["target"] === "string" ? event.toolInput["target"] : void 0;
   if (oldString === void 0 || oldString === "") return null;
-  const absPath = normalizePath(filePath);
-  if (!existsSync2(absPath)) return null;
+  const absPath = hostPathOfIndexKey(normalizePath(filePath));
+  if (!existsSync3(absPath)) return null;
   try {
-    const stat = statSync8(absPath);
+    const stat = statSync9(absPath);
     if (stat.size > MAX_EDIT_DIAGNOSE_BYTES) return null;
-    const fileContent = readFileSync6(absPath, "utf8");
+    const fileContent = readFileSync10(absPath, "utf8");
     const relDisplay = displaySafeText(relative2(process.cwd(), absPath).replace(/\\/g, "/") || absPath);
     if (isMultiple) {
       const matchLines = [];
@@ -9884,7 +10375,7 @@ function mcpOutputId(sessionId, hash) {
 }
 function mcpInputPreview(toolInput) {
   try {
-    return redactSecrets(JSON.stringify(toolInput)).text.slice(0, 120);
+    return redactSerializedJson(JSON.stringify(toolInput)).text.slice(0, 120);
   } catch {
     return "";
   }
@@ -9903,12 +10394,7 @@ function storeMcpOutput(sessionId, toolName, toolInput, resultText) {
     output: redactedOutput,
     exitCode: 0,
     storedAt: Date.now(),
-    // Sized off the redacted output, not the raw pre-redaction resultText (rawSizeBytes is only
-    // the cache-eligibility gate above) -- mirrors bash_output_cache.ts's storeBashOutput, whose
-    // sizeBytes is likewise computed from redactedOutput. Sizing off the raw text here left
-    // mcp-audit's per-call token estimate and `mcp-history`'s byte column reporting a stale byte
-    // count for any entry a secret was actually stripped from, out of sync with the stored/served
-    // (redacted, shorter) output.
+    // Sized off the redacted output, not the raw pre-redaction resultText (rawSizeBytes is only the cache-eligibility gate above) -- mirrors bash_output_cache.ts's storeBashOutput, whose sizeBytes is likewise computed from redactedOutput. Sizing off the raw text here left mcp-audit's per-call token estimate and `mcp-history`'s byte column reporting a stale byte count for any entry a secret was actually stripped from, out of sync with the stored/served (redacted, shorter) output.
     sizeBytes: Buffer.byteLength(redactedOutput, "utf-8")
   };
   if (!storeBlob(BASH_OUTPUT_SUBDIR, id, entry)) return null;
@@ -10267,9 +10753,58 @@ function compressMcpResultWithPacks(toolName, resultText) {
 
 // src/hooks_mcp.ts
 var MCP_OVERSIZED_THRESHOLD_BYTES = 25e3;
+var TOKEN_GOAT_MCP_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "read",
+  "symbol",
+  "section",
+  "outline",
+  "skeleton",
+  "refs",
+  "brief",
+  "map",
+  "changed",
+  "grep",
+  "imports",
+  "exports",
+  "semantic",
+  "index_status",
+  "handoff_create",
+  "handoff_apply",
+  "retrieve_text"
+]);
+function isTokenGoatMcpTool(toolName) {
+  const lower = toolName.toLowerCase();
+  let rest = lower;
+  if (rest.startsWith("mcp__")) {
+    rest = rest.slice(5);
+  } else if (rest.startsWith("mcp_")) {
+    rest = rest.slice(4);
+  } else {
+    if (lower.startsWith("token_goat_") || lower.startsWith("token-goat-") || lower.startsWith("tg_")) {
+      const tool2 = lower.replace(/^(token_goat_|token-goat-|tg_)/, "");
+      return TOKEN_GOAT_MCP_TOOL_NAMES.has(tool2);
+    }
+    return false;
+  }
+  const sepIdx = rest.indexOf("__");
+  let server = "";
+  let tool = "";
+  if (sepIdx !== -1) {
+    server = rest.slice(0, sepIdx);
+    tool = rest.slice(sepIdx + 2);
+  } else {
+    const singleIdx = rest.indexOf("_");
+    if (singleIdx !== -1) {
+      server = rest.slice(0, singleIdx);
+      tool = rest.slice(singleIdx + 1);
+    }
+  }
+  const isTgServer = server === "token_goat" || server === "token-goat" || server === "tg" || server === "token_goat_mcp" || server === "token-goat-mcp";
+  return isTgServer && TOKEN_GOAT_MCP_TOOL_NAMES.has(tool);
+}
 function preMcpHandler(event) {
   const toolName = getToolName(event);
-  if (!toolName || !event.sessionId) return passOutput();
+  if (!toolName || !event.sessionId || isTokenGoatMcpTool(toolName)) return passOutput();
   const toolInput = getToolInput(event);
   if (!isMcpReadOnly(toolName, toolInput)) return passOutput();
   const ttlMs = loadConfig().hints.mcp_dedup_ttl_secs * 1e3;
@@ -10283,7 +10818,7 @@ function preMcpHandler(event) {
 }
 function postMcpHandler(event) {
   const toolName = getToolName(event);
-  if (!toolName || !toolName.startsWith("mcp__")) return passOutput();
+  if (!toolName || !toolName.startsWith("mcp__") || isTokenGoatMcpTool(toolName)) return passOutput();
   const toolInput = getToolInput(event);
   const resultText = extractToolResultText(event.raw);
   if (!resultText) return passOutput();
@@ -10568,16 +11103,17 @@ registerHook("post_tool_use", postBrowserImageHandler, { toolPattern: "^mcp__" }
 // src/hooks_agent_spawn.ts
 init_define_import_meta_env();
 import { createHash as createHash2 } from "node:crypto";
-import * as fs2 from "node:fs";
-import * as path5 from "node:path";
+import * as fs4 from "node:fs";
+import * as path7 from "node:path";
 var BRIEFING_TARGET_TOKENS = 550;
-function buildSubagentBriefing() {
+function buildSubagentBriefing(projectRoot) {
   try {
     const head = [];
     head.push("");
     head.push("## Session briefing (for context)");
     try {
-      const map2 = buildProjectMap(process.cwd(), { compact: true });
+      if (projectRoot === null) throw new Error("no project root");
+      const map2 = buildProjectMap(projectRoot, { compact: true });
       const mapText = formatProjectMap(map2, map2.compact);
       head.push(mapText);
     } catch {
@@ -10641,6 +11177,32 @@ function findDuplicateOutstandingPrompt(prompt) {
 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(fs4.readFileSync(path7.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();
+  }
+}
 function isAgentTool(toolName) {
   return toolName === "Agent" || toolName === "task" || toolName === "Task";
 }
@@ -10650,9 +11212,11 @@ function preAgentHandler(event) {
   const prompt = toolInput["prompt"];
   if (typeof prompt !== "string" || prompt.trim() === "") return passOutput();
   try {
+    const scopedDeny = buildScopedSpawnDeny(toolInput);
+    if (scopedDeny) return scopedDeny;
     const duplicateOf = findDuplicateOutstandingPrompt(prompt);
     recordOutstandingAgentSpawn(prompt);
-    const briefing = buildSubagentBriefing();
+    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: "${neutralizeSpokenMarkers(truncateForWarning(duplicateOf, 80))}"). This is advisory only -- proceeding is fine if intentional.` : "";
@@ -10794,8 +11358,8 @@ function parseAgentDefinition(text, fallbackName) {
   return { name: name2, restricted: false };
 }
 function findRestrictedAgentNames(roots) {
-  const projectAgentsRoot = path5.join(process.cwd(), ".claude", "agents");
-  const scanRoots = roots ?? [path5.join(claudeConfigDir(), "agents"), projectAgentsRoot];
+  const projectAgentsRoot = path7.join(process.cwd(), ".claude", "agents");
+  const scanRoots = roots ?? [path7.join(claudeConfigDir(), "agents"), projectAgentsRoot];
   const names = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
   let filesSeen = 0;
@@ -10803,7 +11367,7 @@ function findRestrictedAgentNames(roots) {
     if (depth > ROSTER_WALK_MAX_DEPTH || filesSeen >= ROSTER_WALK_MAX_FILES) return;
     let real;
     try {
-      real = fs2.realpathSync(dir);
+      real = fs4.realpathSync(dir);
     } catch {
       return;
     }
@@ -10813,16 +11377,16 @@ function findRestrictedAgentNames(roots) {
     visited.add(key);
     let entries;
     try {
-      entries = fs2.readdirSync(dir, { withFileTypes: true });
+      entries = fs4.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (filesSeen >= ROSTER_WALK_MAX_FILES) return;
-      const full = path5.join(dir, entry.name);
+      const full = path7.join(dir, entry.name);
       let stat;
       try {
-        stat = fs2.statSync(full);
+        stat = fs4.statSync(full);
       } catch {
         continue;
       }
@@ -10834,30 +11398,30 @@ function findRestrictedAgentNames(roots) {
       filesSeen++;
       let text;
       try {
-        text = fs2.readFileSync(full, "utf-8");
+        text = fs4.readFileSync(full, "utf-8");
       } catch {
         continue;
       }
-      const parsed = parseAgentDefinition(text, path5.basename(entry.name, path5.extname(entry.name)));
+      const parsed = parseAgentDefinition(text, path7.basename(entry.name, path7.extname(entry.name)));
       if (parsed !== null && parsed.restricted) names.add(parsed.name);
     }
   };
   for (const root of scanRoots) {
-    const isProjectRoot = roots === void 0 && path5.resolve(root) === path5.resolve(projectAgentsRoot);
+    const isProjectRoot = roots === void 0 && path7.resolve(root) === path7.resolve(projectAgentsRoot);
     if (!isProjectRoot) {
       walk(root, 0, null);
       continue;
     }
     let rootIsLink;
     try {
-      rootIsLink = fs2.lstatSync(root).isSymbolicLink();
+      rootIsLink = fs4.lstatSync(root).isSymbolicLink();
     } catch {
       continue;
     }
     if (rootIsLink) continue;
     let confineTo;
     try {
-      confineTo = fs2.realpathSync(root);
+      confineTo = fs4.realpathSync(root);
     } catch {
       continue;
     }
@@ -10867,7 +11431,8 @@ function findRestrictedAgentNames(roots) {
 }
 function buildUnrestrictedSpawnAdvisory(toolInput) {
   try {
-    if (getHarnessName() === "copilot_cli") return "";
+    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 "";
@@ -10883,6 +11448,71 @@ function buildUnrestrictedSpawnAdvisory(toolInput) {
     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$/;
+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 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;
+    if (resultText.length < loadConfig().agent_report.min_bytes) return passOutput();
+    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, "");
+    const { final, worthwhile } = planReportCompaction(resultText, recallHint, notice);
+    if (!worthwhile) return passOutput();
+    if (storeMcpOutput(event.sessionId, "task", toolInput, resultText) !== id) return passOutput();
+    if (redactedReport.count > 0) recordStat("secret_redacted", 0, redactedReport.count, void 0, "agent");
+    const updatedOutput = `${final}
+
+${notice}`;
+    recordReportCompaction(resultText, updatedOutput);
+    return emitRewrite(updatedOutput, "agent", void 0, "counted-elsewhere");
+  } catch {
+    return passOutput();
+  }
+}
 function postAgentHandler(event) {
   try {
     if (!isAgentTool(event.toolName) || !event.sessionId) return passOutput();
@@ -10892,6 +11522,7 @@ function postAgentHandler(event) {
     }
     const redactedReport = redactSecrets(extractToolResultText(event.raw));
     const resultText = redactedReport.text;
+    if (REWRITTEN_REPORT_RE.test(resultText)) return passOutput();
     const agentReportCfg = loadConfig().agent_report;
     const spawnAdvisory = buildUnrestrictedSpawnAdvisory(event.toolInput);
     if (!resultText || resultText.length < agentReportCfg.min_bytes) {
@@ -10902,25 +11533,14 @@ function postAgentHandler(event) {
     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 = `[token-goat] This subagent report (${toKB(resultText.length)}KB) is cached for later recall: ${recallHint}${spawnAdvisory === "" ? "" : `
-${spawnAdvisory}`}`;
-    const collapsed = collapseFencedBlocks(resultText, recallHint, agentReportCfg.fence_collapse_min_lines, agentReportCfg.fence_collapse_keep_lines);
-    const deduped = dedupeFencedBlocks(collapsed, resultText, recallHint);
-    const final = collapseBlankRunsInFences(deduped);
-    const originalBytes = Buffer.byteLength(resultText, "utf-8");
+    const notice = reportNotice(resultText, recallHint, spawnAdvisory);
+    const { final, worthwhile } = planReportCompaction(resultText, recallHint, notice);
     if (final !== resultText) {
-      const worthwhile = isRewriteWorthwhile({
-        originalBytes,
-        rewrittenBytes: Buffer.byteLength(final, "utf-8"),
-        noticeBytes: Buffer.byteLength(notice, "utf-8"),
-        minNetSavingsBytes: resolveMinNetSavingsBytes()
-      });
       if (worthwhile) {
         const updatedOutput = `${final}
 
 ${notice}`;
-        const savedBytes = originalBytes - Buffer.byteLength(updatedOutput, "utf-8");
-        if (savedBytes > 0) recordStat("agent_report_compact", savedBytes, savedTokensFromBytes(savedBytes));
+        recordReportCompaction(resultText, updatedOutput);
         return emitRewrite(updatedOutput, "agent", void 0, "counted-elsewhere");
       }
       recordStat("agent_report_compact_declined", 0, 0);
@@ -10930,6 +11550,8 @@ ${notice}`;
     return passOutput();
   }
 }
+registerHook("subagent_start", subagentStartHandler);
+registerHook("subagent_stop", subagentReportRewriteHandler, { advisory: true });
 registerHook("pre_tool_use", preAgentHandler, { toolName: "Agent" });
 registerHook("pre_tool_use", preAgentHandler, { toolName: "task" });
 registerHook("pre_tool_use", preAgentHandler, { toolName: "Task" });
@@ -10950,7 +11572,7 @@ function buildEvent(eventName, payload) {
   const rawSession = obj["session_id"] ?? obj["sessionId"];
   const sessionId = typeof rawSession === "string" ? rawSession : "";
   const rawAgentId = obj["agent_id"] ?? obj["agentId"];
-  const agentId = typeof rawAgentId === "string" && rawAgentId !== "" ? rawAgentId : void 0;
+  const agentId = eventName !== "subagent_start" && typeof rawAgentId === "string" && rawAgentId !== "" ? rawAgentId : void 0;
   const rawTraceparent = obj["traceparent"] ?? obj["traceParent"] ?? process.env["TRACEPARENT"] ?? process.env["traceparent"];
   const traceparent = typeof rawTraceparent === "string" && rawTraceparent.trim() !== "" ? rawTraceparent.trim() : void 0;
   const rawTracestate = obj["tracestate"] ?? obj["traceState"] ?? process.env["TRACESTATE"] ?? process.env["tracestate"];
@@ -10966,21 +11588,41 @@ function harnessForNormalization() {
   if (detected === "qwen") return "qwen";
   if (detected === "copilot_cli") return "copilot_cli";
   if (detected === "vscode") return "vscode";
+  if (detected === "antigravity") return "antigravity";
   return "claude";
 }
 function safeSuggestions(output) {
   if (output.hookType === "deny") return { hookType: "deny", message: stripUnsafeSuggestions(output.message) };
-  if (output.hookType === "context") return { hookType: "context", context: stripUnsafeSuggestions(output.context) };
+  if (output.hookType === "context") return { hookType: "context", context: stripUnsafeSuggestions(output.context), ...output.notice !== void 0 ? { notice: output.notice } : {} };
+  if (output.hookType === "rewriteOutput" && output.context !== void 0) return { ...output, context: stripUnsafeSuggestions(output.context) };
   return output;
 }
 var relayQueue = Promise.resolve();
-function relayInProcess(eventName, rawPayload, harnessWaitMs) {
+var RELAY_QUEUE_WAIT_MS = 12e4;
+function afterPredecessor(previous) {
+  return new Promise((resolve3) => {
+    const timer = setTimeout(resolve3, RELAY_QUEUE_WAIT_MS);
+    timer.unref();
+    void previous.then(() => {
+      clearTimeout(timer);
+      resolve3();
+    });
+  });
+}
+var NATIVE_FALLBACK_ENV = "TOKEN_GOAT_NATIVE_FALLBACK";
+function nativeFallbackDetail(env = process.env) {
+  const reason = env[NATIVE_FALLBACK_ENV];
+  return reason !== void 0 && /^[a-z0-9-]{1,40}$/.test(reason) ? `native-fallback:${reason}` : void 0;
+}
+function relayInProcess(eventName, rawPayload, harnessWaitMs, opts = {}) {
   const receivedAt = Date.now();
-  const run = relayQueue.then(() => relayOne(eventName, rawPayload, harnessWaitMs, receivedAt));
+  const detail = opts.detail ?? nativeFallbackDetail();
+  const probe = process.env[HOOK_PROBE_ENV] === "1";
+  const run = afterPredecessor(relayQueue).then(() => relayOne(eventName, rawPayload, harnessWaitMs, receivedAt, opts.elapsedMs ?? (() => performance.now()), opts.afterReply, detail, probe));
   relayQueue = run.catch(() => void 0);
   return run;
 }
-async function relayOne(eventName, rawPayload, harnessWaitMs, receivedAt) {
+async function relayOne(eventName, rawPayload, harnessWaitMs, receivedAt, elapsedMs, afterReply, detail, probe = false) {
   if (!isHookEventName(eventName)) {
     return "{}";
   }
@@ -10989,8 +11631,16 @@ async function relayOne(eventName, rawPayload, harnessWaitMs, receivedAt) {
     const payload = eventName === "pre_tool_use" || eventName === "post_tool_use" ? normalizePayload(rawPayload, harnessForNormalization()) : rawPayload;
     const event = buildEvent(eventName, payload);
     if (shouldSuppressDuplicateVscodeHook(event, harness)) return "{}";
-    if (!process.env["CLAUDE_CODE_SESSION_ID"] && event.sessionId) {
-      process.env["CLAUDE_CODE_SESSION_ID"] = event.sessionId;
+    const envSessionId = process.env["CLAUDE_CODE_SESSION_ID"];
+    const seededSessionId = relaySeededSessionId();
+    if (!envSessionId || envSessionId === seededSessionId) {
+      if (event.sessionId) {
+        process.env["CLAUDE_CODE_SESSION_ID"] = event.sessionId;
+        setRelaySeededSessionId(event.sessionId);
+      } else if (seededSessionId !== void 0) {
+        delete process.env["CLAUDE_CODE_SESSION_ID"];
+        setRelaySeededSessionId(void 0);
+      }
     }
     const rawTranscriptPath = event.raw["transcript_path"];
     if (typeof rawTranscriptPath === "string" && rawTranscriptPath !== "") {
@@ -11007,7 +11657,7 @@ async function relayOne(eventName, rawPayload, harnessWaitMs, receivedAt) {
       loadSessionState(stateKey);
     } catch {
     }
-    const output = safeSuggestions(sharpenRepeatedDeny(event, applyCallStreak(event, await runHook(event), receivedAt)));
+    const output = applyProbeMarker(event.eventName, safeSuggestions(sharpenRepeatedDeny(event, applyCallStreak(event, await runHook(event), receivedAt))));
     if (event.sessionId) {
       commitPendingContext(stateKey, output.hookType === "context" ? output.context : null);
     }
@@ -11019,7 +11669,12 @@ async function relayOne(eventName, rawPayload, harnessWaitMs, receivedAt) {
   } catch {
     return "{}";
   } finally {
-    recordStat(`hook:${eventName}`, 0, 0, void 0, void 0, void 0, harnessWaitMs ?? performance.now());
+    const durationMs = harnessWaitMs ?? elapsedMs();
+    const record = () => {
+      if (!probe) recordStat(`hook:${eventName}`, 0, 0, void 0, detail, void 0, durationMs);
+    };
+    if (afterReply) afterReply(record);
+    else record();
   }
 }
 async function relay(eventName) {
@@ -11045,6 +11700,9 @@ async function relay(eventName) {
 
 export {
   buildEvent,
+  RELAY_QUEUE_WAIT_MS,
+  NATIVE_FALLBACK_ENV,
+  nativeFallbackDetail,
   relayInProcess,
   relay
 };