token-goat 2.9.6 → 2.9.9

package/dist/{token-goat-chunk-EIZYCVBM.mjs → token-goat-chunk-P5SQX2VK.mjs}

@@ -18,9 +18,10 @@ import {
   storeWebOutput,
   summarizeResidentContext,
   taskListPruneHint
-} from "./token-goat-chunk-7GJBID7S.mjs";
+} from "./token-goat-chunk-QCHD2ENV.mjs";
 import {
   BASH_OUTPUT_SUBDIR,
+  GENERIC_SERVED_OUTPUT_KEY,
   OUTLINE_MAX_REPLACEMENT_RATIO,
   OUTLINE_MIN_HEADINGS,
   WEB_FETCH_KEY_SEP,
@@ -124,12 +125,12 @@ import {
   wasCliReadThisSession,
   wasFileReadThisSession,
   wasHintShown
-} from "./token-goat-chunk-3HJQR4OO.mjs";
+} from "./token-goat-chunk-BYDDWQ2T.mjs";
 import {
   bashOutputCapBytes,
   canRunWrappedShell,
   deliveredOutputBytes
-} from "./token-goat-chunk-LXIC7MTW.mjs";
+} from "./token-goat-chunk-OBDTBOQA.mjs";
 import {
   BODY_FIRST_TOOL_RESPONSE_KEYS,
   ENV_KEYS,
@@ -168,11 +169,13 @@ import {
   getToolName,
   globalDbPath,
   hasBareBackgroundOrNewline,
+  hasUnquotedOperator,
   isMcpErrorResponse,
   isRewriteWorthwhile,
   isUnderSystemTemp,
   loadConfig,
   makeDedupHintHandlers,
+  neutralizeSpokenMarkers,
   normalizePath,
   passOutput,
   recordStat,
@@ -191,7 +194,7 @@ import {
   stripAnsiEscapes,
   toDisplayPath,
   toKB
-} from "./token-goat-chunk-T2OE7MYM.mjs";
+} from "./token-goat-chunk-KIEOFWLL.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -352,17 +355,66 @@ function foldGrepContentHandler(event) {
     return passOutput();
   }
 }
+var DOC_EXT_RE = /\.(?:md|mdx|rst|txt)$/i;
+var SOURCE_EXT_RE = /\.(?:java|py|ts|tsx|js|jsx|go|rb|rs|cpp|cc|cxx|c|h|hpp|kt|swift|cs|php|scala|clj|css|scss|sass|less)$/i;
+var STRUCTURAL_DOC_PATTERN_RE = /^(?:\^)?#+\s*/;
+var STRUCTURAL_SOURCE_PATTERN_RE = /^(?:\^|\s)*(?:def|class|function|async\s+def|async\s+function|export\s+(?:default\s+)?(?:class|function|interface|type|const|enum)|func|fn|struct|interface|impl|type)\b/i;
+function extractGrepStructuralSearch(toolInput) {
+  const pattern = typeof toolInput["pattern"] === "string" ? toolInput["pattern"].trim() : "";
+  if (!pattern) return null;
+  let rawPath = null;
+  if (typeof toolInput["path"] === "string" && toolInput["path"].trim() !== "") {
+    rawPath = toolInput["path"].trim();
+  } else if (typeof toolInput["paths"] === "string" && toolInput["paths"].trim() !== "") {
+    rawPath = toolInput["paths"].trim();
+  } else if (Array.isArray(toolInput["paths"]) && toolInput["paths"].length === 1 && typeof toolInput["paths"][0] === "string") {
+    rawPath = toolInput["paths"][0].trim();
+  }
+  if (!rawPath) return null;
+  if (/[*?[{]/.test(rawPath)) return null;
+  if (DOC_EXT_RE.test(rawPath) && STRUCTURAL_DOC_PATTERN_RE.test(pattern)) {
+    return { filePath: rawPath, isDoc: true, isSource: false };
+  }
+  if (SOURCE_EXT_RE.test(rawPath) && STRUCTURAL_SOURCE_PATTERN_RE.test(pattern)) {
+    return { filePath: rawPath, isDoc: false, isSource: true };
+  }
+  return null;
+}
+function preGrepHandler(event) {
+  try {
+    if (getToolName(event) !== "Grep") return passOutput();
+    const toolInput = getToolInput(event);
+    const structSearch = extractGrepStructuralSearch(toolInput);
+    if (structSearch !== null) {
+      recordStat("session_hint", 0, 0);
+      const { isDoc } = structSearch;
+      const filePath = displaySafePath(structSearch.filePath);
+      const hint = isDoc ? 'Scanning a document for headings loads large match output. Use `token-goat section "' + filePath + '::SectionHeading"` to read one section or `token-goat outline "' + filePath + '"` to see the document outline.' : 'Scanning a source file for symbols loads large match output. Use `token-goat skeleton "' + filePath + '"` to see the file structure or `token-goat read "' + filePath + '::SymbolName"` to inspect a specific symbol.';
+      return contextOutput(hint);
+    }
+    return preGrepDedupHandler(event);
+  } catch {
+    return passOutput();
+  }
+}
 function postGrepHandler(event) {
   const dedupResult = dedupPostHandler(event);
   const foldResult = foldGrepContentHandler(event);
   if (foldResult.hookType === "rewriteOutput") return foldResult;
   return dedupResult;
 }
-registerHook("pre_tool_use", preGrepDedupHandler, { toolName: "Grep" });
+registerHook("pre_tool_use", preGrepHandler, { toolName: "Grep" });
 registerHook("post_tool_use", postGrepHandler, { toolName: "Grep" });
 
 // src/hooks_glob.ts
 init_define_import_meta_env();
+function isBroadCatchAllGlob(pattern, pathArg) {
+  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("\\");
+}
 function globSignature(toolInput) {
   const pattern = toolInput["pattern"];
   if (typeof pattern !== "string" || pattern === "") return null;
@@ -377,7 +429,24 @@ var { post: postGlobHandler, pre: preGlobDedupHandler } = makeDedupHintHandlers(
   minMatchesConfigKey: "glob_dedup_min_matches",
   statName: "glob_dedup_hint"
 });
-registerHook("pre_tool_use", preGlobDedupHandler, { toolName: "Glob" });
+function preGlobHandler(event) {
+  try {
+    if (getToolName(event) !== "Glob") return passOutput();
+    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)) {
+      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.'
+      );
+    }
+    return preGlobDedupHandler(event);
+  } catch {
+    return passOutput();
+  }
+}
+registerHook("pre_tool_use", preGlobHandler, { toolName: "Glob" });
 registerHook("post_tool_use", postGlobHandler, { toolName: "Glob" });
 
 // src/hooks_edit.ts
@@ -567,8 +636,8 @@ function buildManifest(sessionId, cwd) {
     "### Web URLs fetched",
     webFetches.map(([key, cacheId]) => {
       const [url = key, prompt = ""] = key.split(WEB_FETCH_KEY_SEP);
-      const promptSuffix = prompt ? `, prompt: ${JSON.stringify(prompt)}` : "";
-      return `- ${url} (cacheId: ${cacheId}${promptSuffix})`;
+      const promptSuffix = prompt ? `, prompt: ${neutralizeSpokenMarkers(JSON.stringify(prompt))}` : "";
+      return `- ${displaySafeText(url)} (cacheId: ${cacheId}${promptSuffix})`;
     }),
     MAX_ROWS
   );
@@ -673,15 +742,20 @@ function buildMemEpochSection() {
   ];
 }
 var MANIFEST_PREAMBLE = "When summarizing this session, keep the file paths and symbol names below exactly as written -- they are the handles the next turn needs to resume work. Do not paraphrase them into prose.";
+var BUDGET_ESCALATION_MARKER = "TG-BUDGET-ESCALATION:";
+function summaryBudgetDirective(budgetChars) {
+  if (budgetChars <= 0) return "";
+  return ` Aim for at most ${budgetChars} characters. Prefer a shorter summary that keeps every path, symbol, command and decision over a longer one that reproduces tool output verbatim: cite the recall id (\`token-goat bash-output <id> --full\`) rather than quoting the output again. If this session genuinely cannot be summarized within that target without losing state the next turn needs, exceed it and open the summary with a single line reading \`${BUDGET_ESCALATION_MARKER} <one-sentence reason>\`.`;
+}
 function preCompactHandler(event) {
-  const out = loadConfig().compact_assist.enabled ? contextOutput(`${MANIFEST_PREAMBLE}
+  const out = loadConfig().compact_assist.enabled ? contextOutput(`${MANIFEST_PREAMBLE}${summaryBudgetDirective(loadConfig().compact_assist.summary_budget_chars)}
 
 ${buildManifest(event.sessionId, getCwd(event))}`) : passOutput();
   markCompacted();
   return out;
 }
 registerHook("pre_compact", preCompactHandler);
-var MANIFEST_SURVIVAL_SAMPLE = 12;
+var MANIFEST_SURVIVAL_SAMPLE = 64;
 function manifestPathSample(sessionId) {
   const ownFiles = [...getSessionFiles().values()];
   const siblingFiles = sessionId !== void 0 ? listSiblingSessionStates(sessionId).flatMap((s) => s.files) : [];
@@ -701,12 +775,15 @@ function postCompactHandler(event) {
   const haystack = foldPath(summary);
   const survived = sample.filter((p) => haystack.includes(foldPath(p))).length;
   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;
+  const escalated = summary.includes(BUDGET_ESCALATION_MARKER) ? 1 : 0;
   recordStat(
     "compact_summary",
     0,
     0,
     void 0,
-    `trigger=${trigger} bytes=${bytes} est_tokens=${savedTokensFromBytes(bytes)} manifest_paths=${survived}/${sample.length}`
+    `trigger=${trigger} bytes=${bytes} est_tokens=${savedTokensFromBytes(bytes)} manifest_paths=${survived}/${sample.length} budget=${budget} over=${over} escalated=${escalated}`
   );
   return passOutput();
 }
@@ -721,7 +798,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-3ZAMYHQG.mjs");
+  const { buildProgram } = await import("./token-goat-chunk-DRH4CVGF.mjs");
   return flattenCommandNames(buildCommandManifest(buildProgram()));
 }
 async function recordSkillVersionSnapshot(sessionId, skillName) {
@@ -7321,6 +7398,16 @@ function resolveSkillContext(event) {
   }
   return { skillName };
 }
+function planHeadingTree(body, bodyBytes, skillName) {
+  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.";
+  return { sectionsList, treeBytes, phrase };
+}
 async function preSkillHandler(event) {
   try {
     const ctx = resolveSkillContext(event);
@@ -7334,7 +7421,7 @@ async function preSkillHandler(event) {
     if (await hasSessionOutput(event.sessionId, skillName)) {
       const cachedBytes = await sessionOutputBodyBytes(event.sessionId, skillName);
       const denyCredit = cachedBytes !== null ? Math.min(cachedBytes, PER_FILE_COUNTERFACTUAL_CEILING) : 0;
-      recordStat("session_hint", denyCredit, savedTokensFromBytes(denyCredit));
+      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 + " '<heading>'` to recall a section, `token-goat skill-body " + skillName + " --compact` to recall the compact slice, or `token-goat skill-body " + skillName + "` for the full body instead of re-loading it."
       );
@@ -7344,35 +7431,33 @@ async function preSkillHandler(event) {
       try {
         const body = await readFile(sourcePath, "utf-8");
         const bodyBytes = Buffer.byteLength(body, "utf-8");
-        const compact = bodyBytes > OVERSIZED_FIRST_LOAD_THRESHOLD_BYTES ? extractCompactFromMarker(body) : null;
-        if (compact !== null) {
-          const compactBytes = Buffer.byteLength(compact, "utf-8");
-          if (compactBytes * 2 <= bodyBytes && compactBytes <= COMPACT_INLINE_MAX_BYTES) {
-            const savedBytes = bodyBytes - compactBytes;
-            recordStat("skill_compact_inlined", savedBytes, savedTokensFromBytes(savedBytes));
-            return denyOutput(
-              "Skill `" + skillName + "` is large (" + bodyBytes + " bytes); its compact slice (" + compactBytes + " bytes) is inlined below instead of the full body. For a specific section, run `token-goat skill-section " + skillName + " '<heading>'`, or `token-goat skill-body " + skillName + "` if you need the full body.\n\n" + compact
-            );
-          }
-          recordStat("skill_oversized_first_load");
-          return denyOutput(
-            "Skill `" + skillName + "` is large (" + bodyBytes + " bytes) and has a compact slice available. Use `token-goat skill-section " + skillName + " '<heading>'` to load a specific section, `token-goat skill-body " + skillName + " --compact` to load the compact slice, or `token-goat skill-body " + skillName + "` for the full body."
-          );
-        } else if (bodyBytes > OVERSIZED_FIRST_LOAD_THRESHOLD_BYTES) {
-          const headings = extractMarkdownHeadings(body);
-          if (headings.length >= OUTLINE_MIN_HEADINGS) {
-            const { sectionsList } = formatHeadingTreeParts(headings, skillName);
-            const treeBytes = Buffer.byteLength(sectionsList, "utf-8");
-            if (treeBytes <= bodyBytes * OUTLINE_MAX_REPLACEMENT_RATIO) {
-              const savedBytes = bodyBytes - treeBytes;
-              recordStat("skill_heading_tree_inlined", savedBytes, savedTokensFromBytes(savedBytes));
-              const totalHeadings = extractMarkdownHeadings(body, Number.MAX_SAFE_INTEGER).length;
-              const headingCountPhrase = 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.";
+        if (bodyBytes > OVERSIZED_FIRST_LOAD_THRESHOLD_BYTES) {
+          const compact = extractCompactFromMarker(body);
+          if (compact !== null) {
+            const compactBytes = Buffer.byteLength(compact, "utf-8");
+            if (compactBytes * 2 <= bodyBytes && compactBytes <= COMPACT_INLINE_MAX_BYTES) {
+              const savedBytes = bodyBytes - compactBytes;
+              recordStat("skill_compact_inlined", savedBytes, savedTokensFromBytes(savedBytes));
               return denyOutput(
-                "Skill `" + skillName + "` is large (" + bodyBytes + " bytes) with no compact slice; " + headingCountPhrase + " Use `token-goat skill-section " + skillName + " '<heading>'` to load a specific section, or `token-goat skill-body " + skillName + "` for the full body.\n\n" + fenceUntrustedFileContent(sectionsList)
+                "Skill `" + skillName + "` is large (" + bodyBytes + " bytes); its compact slice (" + compactBytes + " bytes) is inlined below instead of the full body. For a specific section, run `token-goat skill-section " + skillName + " '<heading>'`, or `token-goat skill-body " + skillName + "` if you need the full body.\n\n" + compact
               );
             }
           }
+          const tree = planHeadingTree(body, bodyBytes, skillName);
+          if (tree !== null) {
+            const replaced = compact !== null ? Buffer.byteLength(compact, "utf-8") : bodyBytes;
+            const savedBytes = Math.max(0, replaced - tree.treeBytes);
+            recordStat("skill_heading_tree_inlined", savedBytes, savedTokensFromBytes(savedBytes), void 0, "skill=" + skillName + " marker=" + (compact !== null ? "unusable" : "none"));
+            return denyOutput(
+              "Skill `" + skillName + "` is large (" + bodyBytes + " bytes)" + (compact !== null ? ", and its compact slice is too large to inline; " : " with no compact slice; ") + tree.phrase + " Use `token-goat skill-section " + skillName + " '<heading>'` to load a specific section" + (compact !== null ? ", `token-goat skill-body " + skillName + " --compact` to load the compact slice" : "") + ", or `token-goat skill-body " + skillName + "` for the full body.\n\n" + fenceUntrustedFileContent(tree.sectionsList)
+            );
+          }
+          if (compact !== null) {
+            recordStat("skill_oversized_first_load");
+            return denyOutput(
+              "Skill `" + skillName + "` is large (" + bodyBytes + " bytes) and has a compact slice available. Use `token-goat skill-section " + skillName + " '<heading>'` to load a specific section, `token-goat skill-body " + skillName + " --compact` to load the compact slice, or `token-goat skill-body " + skillName + "` for the full body."
+            );
+          }
         }
       } catch {
       }
@@ -7743,6 +7828,7 @@ function extractCatFilesMulti(cmd) {
 }
 var POWERSHELL_WRAP_RE = /^(?:powershell|pwsh)(?:\.exe)?(?:\s+-[a-zA-Z]+(?:\s+\S+)?)*\s+(?:-Command|-c|-EncodedCommand)\s+(?:"([^"]*)"|'([^']*)')\s*$/i;
 var PS_GETCONTENT_INNER_RE = /^(?:Get-Content|gc|cat|type)(?:\s+(?:-[a-zA-Z]+|--[a-zA-Z-]+))*\s+(?:"([^"]+)"|'([^']+)'|(\S+?))(?:\s+-[a-zA-Z].*)?\s*$/i;
+var PS_FILE_METHOD_RE = /\[(?:System\.)?IO\.File\]::(?:ReadAllText|ReadAllLines|ReadAllBytes|ReadLines|OpenText)\(\s*['"]([^'"]+)['"]/i;
 var PS_TEMP_READ_FLOOD_BYTES = 16 * 1024;
 function isLargeFileOnDisk(filePath, floor) {
   try {
@@ -7765,6 +7851,24 @@ function extractPowerShellWrappedGetContent(cmd) {
   if (isTempPath(filePath) && !isLargeFileOnDisk(filePath, PS_TEMP_READ_FLOOD_BYTES)) return null;
   return { filePath, ...flags };
 }
+function extractPowerShellFileMethodRead(cmd) {
+  let inner = cmd.trim();
+  const w = POWERSHELL_WRAP_RE.exec(inner);
+  if (w) {
+    inner = (w[1] ?? w[2] ?? "").trim();
+  }
+  const m = PS_FILE_METHOD_RE.exec(inner);
+  if (!m?.[1]) return null;
+  const filePath = m[1];
+  if (isOrchestratorStateFile(filePath)) return null;
+  if (isTempPath(filePath) && !isLargeFileOnDisk(filePath, PS_TEMP_READ_FLOOD_BYTES)) return null;
+  const flags = classifyFileExtensions(filePath);
+  if (flags === null) {
+    const { isDoc, isConfig, isSql } = classifyDocConfig(filePath);
+    return { filePath, isDoc, isConfig, isSql };
+  }
+  return { filePath, isDoc: flags.isDoc, isConfig: flags.isConfig, isSql: flags.isSql };
+}
 function extractRgSymbolSearch(cmd) {
   if (!/^(?:rg|grep)\s+/.test(cmd)) return null;
   if (!/-n\b/.test(cmd)) return null;
@@ -7918,57 +8022,75 @@ function pythonOpenPathsAreAllLiteral(text) {
   const calls = pythonOpenCalls(text);
   return calls.length > 0 && calls.every((call) => call.pathLiteral !== null);
 }
+var KNOWN_PYTHON_EXT_STR = "java|py|ts|tsx|js|jsx|go|rb|rs|cpp|cc|cxx|c|h|hpp|kt|swift|cs|php|scala|clj|css|scss|sass|less|md|mdx|rst|txt|json|yaml|yml|toml|xml|html|htm|conf|cfg|ini|properties|sql|ps1|psm1|env";
+var OPEN_EXT = new RegExp(`\\.(?:${KNOWN_PYTHON_EXT_STR})$`, "i");
 function extractPythonFileRead(cmd) {
-  if (!/^python3?\b/.test(cmd)) return null;
-  if (pythonOpenWritesAFile(cmd) || pythonWritesThroughFileObject(cmd)) return null;
-  const outputOpen = /open\s*\(\s*r?['"]([^'"]+\.output)['"]/i.exec(cmd);
+  let inner = cmd.trim();
+  const w = POWERSHELL_WRAP_RE.exec(inner);
+  if (w) {
+    inner = (w[1] ?? w[2] ?? "").trim();
+  }
+  const psHereMatch = /^@'([\s\S]*?)'@\s*\|\s*(?:python3?|py)(?:\.exe)?(?:\s+-\S*|\s+-)?\s*$/i.exec(inner) ?? /^@"([\s\S]*?)"@\s*\|\s*(?:python3?|py)(?:\.exe)?(?:\s+-\S*|\s+-)?\s*$/i.exec(inner);
+  let pythonBody = null;
+  if (psHereMatch) {
+    pythonBody = (psHereMatch[1] ?? "").trim();
+  } else if (/^(?:python3?|py)(?:\.exe)?\b/i.test(inner)) {
+    pythonBody = inner;
+  }
+  if (pythonBody === null) return null;
+  if (pythonOpenWritesAFile(pythonBody) || pythonWritesThroughFileObject(pythonBody)) return null;
+  const outputOpen = /open\s*\(\s*r?['"]([^'"]+\.output)['"]/i.exec(pythonBody);
   if (outputOpen?.[1]) {
     const filePath = outputOpen[1];
     if (isOrchestratorStateFile(filePath)) return null;
-    return { filePath, isDoc: false, isOutputFile: true };
+    return { filePath, isDoc: false, isConfig: false, isEnv: false, isSql: false, isOutputFile: true };
   }
-  const OPEN_EXT = /\.(?:java|py|ts|tsx|js|jsx|go|rb|rs|cpp|cc|cxx|c|h|hpp|kt|swift|cs|php|scala|clj|md|mdx|rst|txt|json|yaml|yml|toml|xml|conf|cfg|ini|properties|ps1|psm1)/i;
-  const heredocMatch = /^python3?\s+-\s+<<\s*'?(\w+)'?\s*\n([\s\S]*?)\n\1\s*$/.exec(cmd);
+  const classifyResult = (filePath) => {
+    const flags = classifyFileExtensions(filePath);
+    if (flags !== null) {
+      return { filePath, isDoc: flags.isDoc, isConfig: flags.isConfig, isEnv: flags.isEnv, isSql: flags.isSql, isOutputFile: false };
+    }
+    const { isDoc, isConfig, isSql } = classifyDocConfig(filePath);
+    const isEnv = /\.env(\.\w+)?$/i.test(filePath);
+    return { filePath, isDoc, isConfig, isEnv, isSql, isOutputFile: false };
+  };
+  const heredocMatch = /^python3?\s+-\s+<<\s*'?(\w+)'?\s*\n([\s\S]*?)\n\1\s*$/.exec(pythonBody);
   if (heredocMatch) {
     const body = heredocMatch[2] ?? "";
     if (pythonOpenWritesAFile(body) || pythonWritesThroughFileObject(body)) return null;
-    const heredocOpen = /open\s*\(\s*r?['"]([^'"]+\.(?:java|py|ts|tsx|js|jsx|go|rb|rs|cpp|cc|cxx|c|h|hpp|kt|swift|cs|php|scala|clj|md|mdx|rst|txt|json|yaml|yml|toml|xml|conf|cfg|ini|properties))['"]/i.exec(body);
+    const heredocOpen = new RegExp(`open\\s*\\(\\s*r?['"]([^'"]+\\.(?:${KNOWN_PYTHON_EXT_STR}))['"]`, "i").exec(body);
     if (heredocOpen?.[1]) {
       const filePath = heredocOpen[1];
       if (isOrchestratorStateFile(filePath)) return null;
-      const isDoc = /\.(?:md|mdx|rst|txt)$/i.test(filePath);
-      return { filePath, isDoc, isOutputFile: false };
+      return classifyResult(filePath);
     }
     if (/open\s*\(/.test(body) && !pythonOpenPathsAreAllLiteral(body)) {
-      const literal2 = /['"]([^'"]+\.(?:java|py|ts|tsx|js|jsx|go|rb|rs|cpp|cc|cxx|c|h|hpp|kt|swift|cs|php|scala|clj|md|mdx|rst|txt|json|yaml|yml|toml|xml|conf|cfg|ini|properties))['"]/i.exec(body);
+      const literal2 = new RegExp(`['"]([^'"]+\\.(?:${KNOWN_PYTHON_EXT_STR}))['"]`, "i").exec(body);
       if (literal2?.[1]) {
         const filePath = literal2[1];
         if (isOrchestratorStateFile(filePath)) return null;
         if (OPEN_EXT.test(filePath)) {
-          const isDoc = /\.(?:md|mdx|rst|txt)$/i.test(filePath);
-          return { filePath, isDoc, isOutputFile: false };
+          return classifyResult(filePath);
         }
       }
     }
     return null;
   }
-  const direct = /open\(['"]([^'"]+\.(?:java|py|ts|tsx|js|jsx|go|rb|rs|cpp|cc|cxx|c|h|hpp|kt|swift|cs|php|scala|clj|md|mdx|rst|txt|json|yaml|yml|toml|xml|conf|cfg|ini|properties))['"]/i.exec(cmd);
+  const direct = new RegExp(`open\\s*\\(\\s*r?['"]([^'"]+\\.(?:${KNOWN_PYTHON_EXT_STR}))['"]`, "i").exec(pythonBody);
   if (direct) {
     const filePath = direct[1] ?? "";
     if (!filePath) return null;
     if (isOrchestratorStateFile(filePath)) return null;
-    const isDoc = /\.(?:md|mdx|rst|txt)$/i.test(filePath);
-    return { filePath, isDoc, isOutputFile: false };
+    return classifyResult(filePath);
   }
-  if (/open\s*\(/.test(cmd) && !pythonOpenPathsAreAllLiteral(cmd)) {
-    const literal2 = /['"]([^'"]+\.(?:java|py|ts|tsx|js|jsx|go|rb|rs|cpp|cc|cxx|c|h|hpp|kt|swift|cs|php|scala|clj|md|mdx|rst|txt|json|yaml|yml|toml|xml|conf|cfg|ini|properties))['"]/i.exec(cmd);
+  if (/open\s*\(/.test(pythonBody) && !pythonOpenPathsAreAllLiteral(pythonBody)) {
+    const literal2 = new RegExp(`['"]([^'"]+\\.(?:${KNOWN_PYTHON_EXT_STR}))['"]`, "i").exec(pythonBody);
     if (literal2) {
       const filePath = literal2[1] ?? "";
       if (filePath) {
         if (isOrchestratorStateFile(filePath)) return null;
         if (OPEN_EXT.test(filePath)) {
-          const isDoc = /\.(?:md|mdx|rst|txt)$/i.test(filePath);
-          return { filePath, isDoc, isOutputFile: false };
+          return classifyResult(filePath);
         }
       }
     }
@@ -8291,7 +8413,7 @@ function extractToolResultsFile(cmd) {
   return null;
 }
 function extractDirectoryListing(cmd) {
-  return /^eza\s+.*--long\s+\S+/.test(cmd) || /^eza\s+.*--tree/.test(cmd) || /^tree(\s|$)/.test(cmd) || /^ls\s+(?:\S+\s+)*-[a-zA-Z]*R[a-zA-Z]*(?:\s|$)/.test(cmd) || /^ls\s+(?:-[la]+\s+)?(\S+)\s*[|]\s*head/.test(cmd) || /^ls\s+(?:-[la]+\s+)?(\S+)\s*[|]\s*grep/.test(cmd) || /^ls\s+(?:-[la]+\s+)?(\S+)\s*[|]\s*wc/.test(cmd);
+  return /^eza\s+.*--long\s+\S+/.test(cmd) || /^eza\s+.*--tree/.test(cmd) || /^tree(\s|$)/.test(cmd) || /^ls\s+(?:\S+\s+)*-[a-zA-Z]*R[a-zA-Z]*(?:\s|$)/.test(cmd) || /^ls\s+(?:-[la]+\s+)?(\S+)\s*[|]\s*head/.test(cmd) || /^ls\s+(?:-[la]+\s+)?(\S+)\s*[|]\s*grep/.test(cmd) || /^ls\s+(?:-[la]+\s+)?(\S+)\s*[|]\s*wc/.test(cmd) || /^(?:Get-ChildItem|gci|dir)\b.*(?:-Recurse|-r\b|\/s\b)/i.test(cmd);
 }
 function extractForLoopWcL(cmd) {
   return /^for\s+\w+\s+in\s+.*;\s*do\s+wc\s+-l/.test(cmd);
@@ -8606,6 +8728,73 @@ function maybeCompressRewrite(event, rawCmd, cmd) {
   const wrapped = `token-goat compress -f ${filterName} --timeout ${cfg.timeout_seconds} -c ${shellQuoteSingle(rawCmd)}`;
   return { hookType: "rewriteInput", updatedInput: { ...event.toolInput, command: wrapped } };
 }
+var PIPELINE_PASSTHROUGH_HEADS = /* @__PURE__ */ new Set(["head", "tail", "cat", "tee", "less", "more"]);
+var CI_BUILD_TEST_FILTER_NAMES = /* @__PURE__ */ new Set([
+  "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_BUILD_TEST_FILTER_NAMES.has(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) {
+        return filterByName("generic-ci");
+      }
+    }
+    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 : detected.filter;
+}
 function pureFileReadPath(cmd) {
   const single = extractCatFile(cmd)?.filePath ?? extractHeadFile(cmd)?.filePath ?? extractTailFile(cmd)?.filePath ?? extractLineRangeRead(cmd)?.filePath;
   if (single !== void 0) return single;
@@ -8629,10 +8818,10 @@ function deliveredLineNumbers(cmd, lineCount) {
   if (singleFileCompoundReadPath(cmd) !== null) return Array.from({ length: lineCount }, () => null);
   return null;
 }
-function elideServedShellLines(cmd, output, priorIds) {
+function elideServedShellLines(cmd, output, priorIds, unknownLineNumbers = false) {
   if (priorIds.length === 0) return null;
   const lines = output.split("\n");
-  const numbers = deliveredLineNumbers(cmd, lines.length);
+  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 = [];
@@ -8750,6 +8939,26 @@ async function maybeCollapseIdenticalRead(cmd, rawCmd, output, exitCode, cwd, ca
   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, output, exitCode, cwd, cacheMinBytes) {
+  if (process.env["TOKEN_GOAT_BASH_COMPRESS"] === "0") 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);
+    if (elided !== null && isRewriteWorthwhile({ originalBytes, rewrittenBytes: Buffer.byteLength(elided, "utf-8"), noticeBytes: 0, minNetSavingsBytes: resolveMinNetSavingsBytes() })) {
+      rewrittenText = elided;
+    }
+  }
+  const storedId = await storeBashOutput(cmd, rewrittenText ?? output, exitCode ?? 0, cwd);
+  recordFileServedOutput(GENERIC_SERVED_OUTPUT_KEY, storedId);
+  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, output, exitCode, cwd, cacheMinBytes) {
   if (process.env["TOKEN_GOAT_BASH_COMPRESS"] === "0") return null;
   if (isCompressibleSingleCommand(cmd)) return null;
@@ -8762,7 +8971,8 @@ async function maybeCompressCompoundOutput(cmd, output, exitCode, cwd, cacheMinB
   }
   if (!cfg.enabled || cfg.disabled_filters.includes("generic")) return null;
   if (Buffer.byteLength(output, "utf-8") < cacheMinBytes) return null;
-  const filter3 = filterByName("generic");
+  const shaped = pipelineShapeFilter(cmd, cwd);
+  const filter3 = shaped !== null && !cfg.disabled_filters.includes(shaped.name) ? shaped : filterByName("generic");
   if (filter3 === null) return null;
   const compressed = compressOutput(filter3, output, "", exitCode ?? 0, [], {
     maxLines: cfg.max_lines,
@@ -8784,7 +8994,7 @@ async function maybeCompressCompoundOutput(cmd, output, exitCode, cwd, cacheMinB
     return null;
   }
   await storeBashOutput(cmd, output, exitCode ?? 0, cwd);
-  return emitRewrite(body, "bash", { kind: "bash_compress:generic", originalBytes: deliveredOutputBytes(compressed.originalBytes) });
+  return emitRewrite(body, "bash", { kind: `bash_compress:${filter3.name}`, originalBytes: deliveredOutputBytes(compressed.originalBytes) });
 }
 function maybeStripAnsiOnly(output) {
   if (!output.includes("\x1B")) return null;
@@ -9079,7 +9289,7 @@ function preBashHandlerInner(event) {
     recordStat("session_hint", 0, 0);
     const hints = [];
     for (const { filePath, ranges, tool } of sedReads) {
-      const hintPath = cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath;
+      const hintPath = displaySafePath(cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath);
       const sedDedupKey = resolveIndexPath(hintPath, preHookCwd ?? process.cwd());
       const overlapHints = [];
       const freshRanges = [];
@@ -9100,7 +9310,7 @@ function preBashHandlerInner(event) {
   const catJsonPipe = extractCatJsonPipe(cmd);
   if (catJsonPipe !== null) {
     const { filePath } = catJsonPipe;
-    const hintPath = cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath;
+    const hintPath = displaySafePath(cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath);
     recordStat("session_hint", 0, 0);
     return contextOutput(
       '`cat | jq` loads the whole file. Use `token-goat config-get "' + hintPath + '" KEY_NAME` or `token-goat section "' + hintPath + '::sectionName"` to slice one value.'
@@ -9109,7 +9319,7 @@ function preBashHandlerInner(event) {
   const catResult = extractCatFile(cmd);
   if (catResult !== null) {
     const { filePath, isDoc, isEnv, isConfig, isSql, cmd0, advisoryOnly } = catResult;
-    const hintPath = cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath;
+    const hintPath = displaySafePath(cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath);
     recordStat("session_hint", 0, 0);
     if (isSql) {
       return contextOutput(
@@ -9124,7 +9334,7 @@ function preBashHandlerInner(event) {
     recordStat("session_hint", 0, 0);
     const cmd0 = catMulti[0].cmd0;
     const perPath = catMulti.map(({ filePath, isDoc, isEnv, isConfig, isSql }) => {
-      const hintPath = cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath;
+      const hintPath = displaySafePath(cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath);
       const how = isSql ? 'token-goat section "' + hintPath + '::table_name"' : isEnv || isConfig ? 'token-goat config-get "' + hintPath + '" KEY_NAME' : isDoc ? 'token-goat section "' + hintPath + '::SectionHeading"' : 'token-goat read "' + hintPath + '::SymbolName"';
       return "  " + hintPath + " -> `" + how + "`";
     });
@@ -9134,7 +9344,7 @@ function preBashHandlerInner(event) {
   const psGetContentResult = extractPowerShellWrappedGetContent(cmd);
   if (psGetContentResult !== null) {
     const { filePath, isDoc, isEnv, isConfig, isSql } = psGetContentResult;
-    const hintPath = cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath;
+    const hintPath = displaySafePath(cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath);
     recordStat("session_hint", 0, 0);
     const lead = "`Get-Content` via a `powershell -Command` wrapper bypasses read hooks and loads the entire file into context. ";
     if (isSql) {
@@ -9146,7 +9356,7 @@ function preBashHandlerInner(event) {
   const wslCatResult = extractWslCatFile(cmd);
   if (wslCatResult !== null) {
     const { filePath, isDoc, isEnv, isConfig, isSql } = wslCatResult;
-    const hintPath = cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath;
+    const hintPath = displaySafePath(cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath);
     recordStat("session_hint", 0, 0);
     if (isSql) {
       return contextOutput(
@@ -9158,8 +9368,8 @@ function preBashHandlerInner(event) {
   }
   const pyRead = extractPythonFileRead(cmd);
   if (pyRead !== null) {
-    const { filePath, isDoc, isOutputFile } = pyRead;
-    const hintPath = cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath;
+    const { filePath, isDoc, isConfig, isEnv, isSql, isOutputFile } = pyRead;
+    const hintPath = displaySafePath(cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath);
     recordStat("session_hint", 0, 0);
     if (isOutputFile) {
       if (taskOutputIsJsonlTranscript(filePath)) {
@@ -9170,41 +9380,46 @@ function preBashHandlerInner(event) {
         "This `.output` file is a background command's stdout. Use `token-goat bash-output --file \"" + hintPath + '"` to narrow it with `--grep PATTERN`, `--tail N` or `--head N`, instead of reading the whole file.'
       );
     }
-    const hint = isDoc ? 'Use `token-goat section "' + hintPath + '::SectionHeading"` to read one section.' : 'Use `token-goat read "' + hintPath + '::SymbolName"` to extract a specific symbol.';
+    if (isSql) {
+      return contextOutput(
+        'Python `open()` file reads bypass read hooks. Use `token-goat section "' + hintPath + '::table_name"` to pull one CREATE TABLE / CREATE TYPE block.'
+      );
+    }
+    const hint = surgicalHintFor(hintPath, isEnv, isConfig, isDoc);
     return cdStripped ? contextOutput("Python `open()` file reads bypass read hooks. " + hint) : denyOutput("Python `open()` file reads bypass read hooks. " + hint);
   }
   const tailResult = extractTailFile(cmd);
   if (tailResult !== null) {
     const { filePath, isDoc, isConfig, isSql } = tailResult;
-    const hintPath = cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath;
+    const hintPath = displaySafePath(cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath);
     recordStat("session_hint", 0, 0);
     return contextOutput("`tail` bypasses read hooks. " + surgicalHintForConfigDoc(hintPath, isConfig, isDoc, isSql));
   }
   const headResult = extractHeadFile(cmd);
   if (headResult !== null) {
     const { filePath, isDoc, isConfig, isSql, n } = headResult;
-    const hintPath = cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath;
+    const hintPath = displaySafePath(cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath);
     recordStat("session_hint", 0, 0);
     return contextOutput(leadingLinesHint("`head` bypasses read hooks. ", hintPath, 1, n, { isConfig, isDoc, isSql }, preHookCwd));
   }
   const gcTailResult = extractGetContentTail(cmd);
   if (gcTailResult !== null) {
     const { filePath, isDoc, isConfig, isSql } = gcTailResult;
-    const hintPath = cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath;
+    const hintPath = displaySafePath(cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath);
     recordStat("session_hint", 0, 0);
     return contextOutput("`Get-Content -Tail` bypasses read hooks. " + surgicalHintForConfigDoc(hintPath, isConfig, isDoc, isSql));
   }
   const gcSelectResult = extractGetContentSelectFirst(cmd);
   if (gcSelectResult !== null) {
     const { filePath, isDoc, isConfig, isSql, n } = gcSelectResult;
-    const hintPath = cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath;
+    const hintPath = displaySafePath(cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath);
     recordStat("session_hint", 0, 0);
     return contextOutput(leadingLinesHint("`Select-Object -First` bypasses read hooks. ", hintPath, 1, n, { isConfig, isDoc, isSql }, preHookCwd));
   }
   const nodeRead = extractNodeFileRead(cmd);
   if (nodeRead !== null) {
     const { filePath, isDoc, isConfig, isSql } = nodeRead;
-    const hintPath = cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath;
+    const hintPath = displaySafePath(cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath);
     const lead = "Node.js `fs.readFileSync()` bypasses read hooks. ";
     if (isSql) {
       recordStat("session_hint", 0, 0);
@@ -9214,6 +9429,19 @@ function preBashHandlerInner(event) {
     recordStat("session_hint", 0, 0);
     return cdStripped ? contextOutput(lead + hint) : denyOutput(lead + hint);
   }
+  const psMethodRead = extractPowerShellFileMethodRead(cmd);
+  if (psMethodRead !== null) {
+    const { filePath, isDoc, isConfig, isSql } = psMethodRead;
+    const hintPath = displaySafePath(cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath);
+    const lead = "PowerShell `[IO.File]::ReadAllText()` bypasses read hooks. ";
+    if (isSql) {
+      recordStat("session_hint", 0, 0);
+      return contextOutput(lead + 'Use `token-goat section "' + hintPath + '::table_name"` to pull one CREATE TABLE / CREATE TYPE block.');
+    }
+    const hint = isDoc ? 'Use `token-goat section "' + hintPath + '::SectionHeading"` to read one section.' : isConfig ? 'Use `token-goat config-get "' + hintPath + '" KEY_NAME` or `token-goat section "' + hintPath + '::sectionName"` to read a specific value.' : 'Use `token-goat read "' + hintPath + '::SymbolName"` to extract a specific symbol.';
+    recordStat("session_hint", 0, 0);
+    return cdStripped ? contextOutput(lead + hint) : denyOutput(lead + hint);
+  }
   if (extractGrepPipeChain(cmd)) {
     recordStat("session_hint", 0, 0);
     return contextOutput(
@@ -9223,7 +9451,7 @@ function preBashHandlerInner(event) {
   const mdHeadingGrep = extractMarkdownHeadingGrep(cmd);
   if (mdHeadingGrep !== null) {
     const { filePath } = mdHeadingGrep;
-    const hintPath = cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath;
+    const hintPath = displaySafePath(cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath);
     recordStat("session_hint", 0, 0);
     return contextOutput(
       'Use `token-goat outline "' + hintPath + '"` to get all headings with line ranges \u2014 then `token-goat section "' + hintPath + '::Heading"` to read one section.'
@@ -9240,7 +9468,7 @@ function preBashHandlerInner(event) {
   const rgStructural = extractRgStructuralSearch(cmd);
   if (rgStructural !== null) {
     const { filePath } = rgStructural;
-    const hintPath = cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath;
+    const hintPath = displaySafePath(cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath);
     recordStat("session_hint", 0, 0);
     return contextOutput(
       'Searching for code definitions with `rg`/`grep` is slower than surgical reads. Use `token-goat skeleton "' + hintPath + '"` to see all symbols with line numbers, or `token-goat outline "' + hintPath + '"` for symbols with docstrings and line ranges.'
@@ -9444,6 +9672,21 @@ function recordBashFileReadsForSessionCache(cmd, cwd) {
     recordFileRead(resolve(wslCat.filePath));
     return;
   }
+  const nodeRead = extractNodeFileRead(cmd);
+  if (nodeRead !== null) {
+    recordFileRead(resolve(nodeRead.filePath));
+    return;
+  }
+  const psMethod = extractPowerShellFileMethodRead(cmd);
+  if (psMethod !== null) {
+    recordFileRead(resolve(psMethod.filePath));
+    return;
+  }
+  const pyRead = extractPythonFileRead(cmd);
+  if (pyRead !== null && !pyRead.isOutputFile) {
+    recordFileRead(resolve(pyRead.filePath));
+    return;
+  }
 }
 async function postBashHandler(event) {
   try {
@@ -9539,6 +9782,10 @@ async function postBashHandler(event) {
       if (identical !== null) return identical;
       const compound = await maybeCompressCompoundOutput(cmd, output, exitCode, cwd, cacheMinBytes);
       if (compound !== null) return compound;
+      if (!isFileRead && extractLineRangeReadsCompound(cmd) === null) {
+        const genericElision = await maybeElideServedGenericOutput(cmd, output, exitCode, cwd, cacheMinBytes);
+        if (genericElision !== null) return genericElision;
+      }
       return maybeStripAnsiOnly(output) ?? passOutput();
     }
     if (Buffer.byteLength(output, "utf-8") < cacheMinBytes) return passOutput();
@@ -9747,8 +9994,8 @@ registerHook("post_tool_use", postTaskOutputHandler, { toolName: "TaskOutput" })
 
 // src/hooks_tool_failure.ts
 init_define_import_meta_env();
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2 } from "node:path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, statSync as statSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, relative } from "node:path";
 var FAILURE_SUFFIX = ".tool-failures.json";
 var MAX_TRACKED_FAILURES = 64;
 var SIGNATURE_ERROR_CHARS = 200;
@@ -9795,9 +10042,74 @@ function writeLedger(target, ledger) {
   }
 }
 function repeatFailureNotice(toolName) {
-  const tool = toolName === void 0 || toolName === "" ? "This tool" : toolName;
+  const tool = toolName === void 0 || toolName === "" ? "This tool" : displaySafeText(toolName);
   return `[token-goat] ${tool} just failed with the same error as an earlier call this session. Retrying it unchanged will fail the same way -- change the arguments, the tool, or the approach.`;
 }
+var MAX_EDIT_DIAGNOSE_BYTES = 10 * 1024 * 1024;
+function diagnoseEditFailure(event, errorText) {
+  const toolName = getToolName(event);
+  if (!toolName || !/^(edit|str_replace_editor)$/i.test(toolName)) {
+    return null;
+  }
+  const isMultiple = /multiple matches|not unique|found \d+ matches|matches \d+ times|more than one match/i.test(errorText);
+  const isNotFound = /no match|not found|could not find|zero matches|string to replace.*not found/i.test(errorText);
+  if (!isMultiple && !isNotFound) {
+    return null;
+  }
+  const filePath = getFilePath(event) ?? (typeof event.toolInput["path"] === "string" ? 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;
+  try {
+    const stat = statSync4(absPath);
+    if (stat.size > MAX_EDIT_DIAGNOSE_BYTES) return null;
+    const fileContent = readFileSync3(absPath, "utf8");
+    const relDisplay = displaySafeText(relative(process.cwd(), absPath).replace(/\\/g, "/") || absPath);
+    if (isMultiple) {
+      const matchLines = [];
+      let pos = 0;
+      while (pos < fileContent.length) {
+        const idx = fileContent.indexOf(oldString, pos);
+        if (idx === -1) break;
+        const line = fileContent.slice(0, idx).split("\n").length;
+        matchLines.push(line);
+        pos = idx + Math.max(1, oldString.length);
+      }
+      if (matchLines.length > 1) {
+        const lineList = matchLines.slice(0, 5).join(", ");
+        const overflow = matchLines.length > 5 ? ` (+${matchLines.length - 5} more)` : "";
+        return `[token-goat] Edit failed: string matched ${matchLines.length} times in ${relDisplay} on lines ${lineList}${overflow}. Include 2-3 lines of surrounding context to make old_str unique.`;
+      }
+    }
+    if (isNotFound) {
+      const normOld = oldString.replace(/\r\n/g, "\n");
+      const normFile = fileContent.replace(/\r\n/g, "\n");
+      if (normFile.includes(normOld)) {
+        return `[token-goat] Edit failed: string not found in ${relDisplay}, but matches with normalized line endings. Check CRLF vs LF line endings or whitespace.`;
+      }
+      const firstLine = oldString.split(/\r?\n/)[0]?.trim() ?? "";
+      if (firstLine.length >= 10) {
+        const fileLines = fileContent.split("\n");
+        const similarLines = [];
+        for (let i = 0; i < fileLines.length; i++) {
+          const lineText = fileLines[i];
+          if (lineText !== void 0 && lineText.includes(firstLine)) {
+            similarLines.push(i + 1);
+            if (similarLines.length >= 3) break;
+          }
+        }
+        if (similarLines.length > 0) {
+          return `[token-goat] Edit failed: string not found in ${relDisplay}. A similar line was found on line ${similarLines.join(", ")} \u2014 view that range to copy exact text.`;
+        }
+      }
+      return `[token-goat] Edit failed: string not found in ${relDisplay}. View the target lines to copy the exact current content and indentation.`;
+    }
+  } catch {
+  }
+  return null;
+}
 function postToolUseFailureHandler(event) {
   try {
     if (!event.sessionId) return passOutput();
@@ -9809,6 +10121,7 @@ function postToolUseFailureHandler(event) {
     const signature = failureSignature(toolName, errorText);
     const ledger = readLedger(target);
     const priorState = ledger.seen[signature];
+    const editDiagnostic = diagnoseEditFailure(event, errorText);
     if (priorState === void 0) {
       ledger.seen[signature] = false;
       ledger.order.push(signature);
@@ -9817,11 +10130,19 @@ function postToolUseFailureHandler(event) {
         if (evicted !== void 0) delete ledger.seen[evicted];
       }
       writeLedger(target, ledger);
+      if (editDiagnostic !== null) {
+        ledger.seen[signature] = true;
+        writeLedger(target, ledger);
+        return contextOutput(editDiagnostic);
+      }
       return passOutput();
     }
     if (priorState) return passOutput();
     ledger.seen[signature] = true;
     writeLedger(target, ledger);
+    if (editDiagnostic !== null) {
+      return contextOutput(editDiagnostic);
+    }
     return contextOutput(repeatFailureNotice(toolName));
   } catch {
     return passOutput();
@@ -10723,13 +11044,16 @@ var SPAWN_RESTRICT_HINT_KEY = "agent-spawn-restrict-hint";
 var SPAWN_RESTRICT_MAX_NAMES = 3;
 var ROSTER_WALK_MAX_DEPTH = 4;
 var ROSTER_WALK_MAX_FILES = 400;
+var AGENT_NAME_RE = /^[A-Za-z0-9._:-]{1,64}$/;
 function parseAgentDefinition(text, fallbackName) {
   const fmMatch = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(text);
   if (!fmMatch) return null;
   const fm = fmMatch[1];
   const nameMatch = /^name:(.*)$/m.exec(fm);
   const rawName = nameMatch ? nameMatch[1].trim().replace(/^["']|["']$/g, "") : "";
-  const name2 = rawName !== "" ? rawName : fallbackName;
+  const resolved = AGENT_NAME_RE.test(rawName) ? rawName : fallbackName;
+  if (!AGENT_NAME_RE.test(resolved)) return null;
+  const name2 = resolved;
   const toolsMatch = /^tools:(.*)$/m.exec(fm);
   if (!toolsMatch) return { name: name2, restricted: false };
   const inline = toolsMatch[1].trim();
@@ -10743,7 +11067,7 @@ function parseAgentDefinition(text, fallbackName) {
   return { name: name2, restricted: false };
 }
 function findRestrictedAgentNames(roots) {
-  const scanRoots = roots ?? [path2.join(os.homedir(), ".claude", "agents")];
+  const scanRoots = roots ?? [path2.join(os.homedir(), ".claude", "agents"), path2.join(process.cwd(), ".claude", "agents")];
   const names = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
   let filesSeen = 0;
@@ -10803,7 +11127,7 @@ function buildUnrestrictedSpawnAdvisory(toolInput) {
     if (names.length === 0) return "";
     markHintShown(SPAWN_RESTRICT_HINT_KEY);
     recordStat("session_hint", 0, 0, void 0, "agent-spawn-restrict");
-    const shown = names.slice(0, SPAWN_RESTRICT_MAX_NAMES).join(", ");
+    const shown = neutralizeSpokenMarkers(names.slice(0, SPAWN_RESTRICT_MAX_NAMES).join(", "));
     const more = names.length > SPAWN_RESTRICT_MAX_NAMES ? ` and ${names.length - SPAWN_RESTRICT_MAX_NAMES} more` : "";
     return `[token-goat] This spawn ran as general-purpose (the default when subagent_type is omitted), which is unrestricted: its lane starts by paying for every tool and MCP schema on the machine. Tools-restricted agent definitions exist here: ${shown}${more}. A future spawn that fits one of them can pass that name as subagent_type to start with a much smaller prefix. Advisory only: this spawn has already run, and this notice saved nothing.`;
   } catch {