token-goat 2.9.26 → 2.9.29

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

@@ -0,0 +1,1382 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  DELIVERS_CONTENT_RE,
+  commandPathIsTouchable,
+  leadWithCommand
+} from "./token-goat-chunk-E5TK5DNO.mjs";
+import {
+  getFileLineRanges
+} from "./token-goat-chunk-TDUT2CL6.mjs";
+import {
+  hasBareBackgroundOrNewline,
+  hasUnquotedOperator,
+  isRedirectAmpersand
+} from "./token-goat-chunk-2WOUYWLM.mjs";
+import {
+  isUnderSystemTemp
+} from "./token-goat-chunk-TGOXNAHW.mjs";
+import {
+  FALSY_ENV_VALUES
+} from "./token-goat-chunk-IVE6U7KV.mjs";
+import {
+  escapeRegExp,
+  safeSlice
+} from "./token-goat-chunk-XYWPOSCN.mjs";
+import {
+  TOOL_RESULTS_ID_CHARS,
+  normalizePath,
+  resolveIndexPath
+} from "./token-goat-chunk-NMTKNYGF.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/tool_error_class.ts
+init_define_import_meta_env();
+
+// src/bash_extractors.ts
+init_define_import_meta_env();
+import { statSync, openSync, readSync, closeSync } from "node:fs";
+function outlineCommand(shown) {
+  return 'token-goat outline "' + shown + '"';
+}
+function structuredDataHint(hintPath, target, reason = "") {
+  const ext = /\.(json|ya?ml)$/i.exec(hintPath)?.[1];
+  if (ext === void 0) return null;
+  const fmt = ext.toLowerCase() === "json" ? "json" : "yaml";
+  const outline = "token-goat " + fmt + '-outline "' + hintPath + '"';
+  const query = (path2) => "token-goat " + fmt + '-query "' + hintPath + '" "' + path2 + '"';
+  if (target === null || /["'`$\\]/.test(target)) {
+    return leadWithCommand(outline, "to list the top-level keys with their type and size (`--filter TEXT` narrows a large one), then `" + query("KEY") + "` to read one value (`\"['a.b']\"` for a key holding a dot)", reason);
+  }
+  const path = /^[\w-]+$/.test(target) ? target : "['" + target + "']";
+  return leadWithCommand(query(path), "to read that value, or `" + outline + "` for every top-level key with its type and size", reason);
+}
+function sqlTableHint(hintPath, target, reason = "") {
+  return leadWithCommand('token-goat read "' + hintPath + "::" + target.name + '"', "to pull one CREATE TABLE / CREATE TYPE block", reason);
+}
+function surgicalHintFor(hintPath, isEnv, isConfig, isDoc, isXml, target, reason = "") {
+  const outline = outlineCommand(hintPath);
+  if (isXml) return leadWithCommand('token-goat xml-outline "' + hintPath + '"', 'to inspect structure, or `token-goat xml-query "' + hintPath + '" "<selector>"` to query specific nodes', reason);
+  if (isEnv) return leadWithCommand('token-goat config-get "' + hintPath + '" ' + target.name, "to read a specific variable", reason);
+  if (isConfig) {
+    const structured = structuredDataHint(hintPath, target.real ? target.name : null, reason);
+    if (structured !== null) return structured;
+    return target.slice === "key" ? leadWithCommand('token-goat config-get "' + hintPath + '" ' + target.name, "to read a specific value, or `" + outline + "` for every key with line ranges", reason) : leadWithCommand('token-goat section "' + hintPath + "::" + target.name + '"', "to read one table, or `" + outline + "` for every key with line ranges", reason);
+  }
+  if (isDoc) return leadWithCommand('token-goat section "' + hintPath + "::" + target.name + '"', "to read one section, or `" + outline + "` for every heading with line ranges", reason);
+  return target.real ? leadWithCommand('token-goat read "' + hintPath + "::" + target.name + '"', "to read one function or class, or `" + outline + "` for all of them", reason) : leadWithCommand(outline, "to list every function and class with its line range", reason);
+}
+function surgicalHintForConfigDoc(filePath, isConfig, isDoc, isSql, isXml, target, reason = "") {
+  if (isXml || isConfig || isDoc) return surgicalHintFor(filePath, false, isConfig, isDoc, isXml, target, reason);
+  if (isSql) return sqlTableHint(filePath, target, reason);
+  return leadWithCommand(outlineCommand(filePath), 'or `token-goat skeleton "' + filePath + '"` to see the file structure', reason);
+}
+function splitShellSegments(cmd) {
+  const segments = [];
+  let cur = "";
+  let quote = null;
+  for (let i = 0; i < cmd.length; i++) {
+    const ch = cmd[i];
+    if (quote !== null) {
+      cur += ch;
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      cur += ch;
+      continue;
+    }
+    if (ch === "\\" && i + 1 < cmd.length) {
+      cur += ch + cmd[i + 1];
+      i++;
+      continue;
+    }
+    if (ch === "&" && isRedirectAmpersand(cmd, i)) {
+      cur += ch;
+      continue;
+    }
+    if (ch === "|" || ch === ";" || ch === "\n" || ch === "&") {
+      segments.push(cur);
+      cur = "";
+      if ((ch === "|" || ch === "&") && cmd[i + 1] === ch) i++;
+      continue;
+    }
+    cur += ch;
+  }
+  segments.push(cur);
+  return segments.map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function isTempPath(fp) {
+  const norm = fp.replace(/\\/g, "/");
+  return /^\/tmp\//i.test(norm) || /\/var\/folders\//i.test(norm) || // Anchored to a local drive root on purpose. Unanchored, this clause said yes to `//host/share/AppData/Local/Temp/x.md`, and the caller's answer to yes is to stat the path -- which on Windows opens an SMB session to whatever host a command named. A temp directory is somewhere on a local volume; nothing that starts with two separators is one.
+  /^[a-z]:\/(?:[^/]+\/)*AppData\/Local\/Temp\//i.test(norm) || norm.startsWith("/c/Users/") && norm.includes("/AppData/Local/Temp/") || isUnderSystemTemp(fp);
+}
+function isOrchestratorStateFile(filePath) {
+  const basename = (filePath.includes("/") ? filePath.split("/").at(-1) : filePath.split("\\").at(-1)) ?? filePath;
+  return /^\.improve-state-/.test(basename);
+}
+function extractCatSourceFile(cmd) {
+  const m = /^cat\s+(\S+\.(?: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))\s*$/.exec(cmd);
+  return m?.[1] ?? null;
+}
+function classifyFileExtensions(filePath) {
+  const basename = (filePath.includes("/") ? filePath.split("/").at(-1) : filePath.split("\\").at(-1)) ?? filePath;
+  const isEnvFile = /^\.env(\.\w+)?$/i.test(basename);
+  const hasKnownExt = /\.(?: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|dtsx|ampkg|xaml|conf|cfg|ini|properties|sql|ps1|psm1|env)$/i.test(filePath);
+  if (!hasKnownExt && !isEnvFile) return null;
+  const isSql = /\.sql$/i.test(filePath);
+  const isDoc = /\.(?:md|mdx|rst|txt)$/i.test(filePath);
+  const isEnv = isEnvFile || /\.env$/i.test(filePath);
+  const isConfig = /\.(?:json|yaml|yml|toml|conf|cfg|ini|properties)$/i.test(filePath);
+  const isXml = /\.(?:xml|dtsx|ampkg|xaml)$/i.test(filePath);
+  return { isDoc, isEnv, isConfig, isSql, isXml };
+}
+function classifyDocConfig(filePath) {
+  const isDoc = /\.(?:md|mdx|rst|txt)$/i.test(filePath);
+  const isConfig = /\.(?:json|yaml|yml|toml|conf|cfg|ini|properties)$/i.test(filePath);
+  const isSql = /\.sql$/i.test(filePath);
+  const isXml = /\.(?:xml|dtsx|ampkg|xaml)$/i.test(filePath);
+  return { isDoc, isConfig, isSql, isXml };
+}
+function classifyCatPath(filePath, cmd0) {
+  if (isTempPath(filePath)) return null;
+  const flags = classifyFileExtensions(filePath);
+  if (flags === null) return null;
+  return { filePath, ...flags, cmd0 };
+}
+function extractCatFile(cmd) {
+  if (/-(?:TotalCount|Head|First|Tail)\b/i.test(cmd)) return null;
+  const m = /^(cat|bat|type|Get-Content|gc)(?:\s+(?:-[a-zA-Z]+|--[a-zA-Z-]+))*\s+(?:"([^"]+)"|'([^']+)'|(\S+?))(?:\s+-[a-zA-Z].*?)?(?:\s+2>(&1|\/dev\/null))?\s*$/i.exec(cmd);
+  if (!m) return null;
+  const cmd0 = m[1];
+  const filePath = m[2] ?? m[3] ?? m[4];
+  if (filePath === void 0) return null;
+  const r = classifyCatPath(filePath, cmd0);
+  if (r === null) return null;
+  return { ...r, advisoryOnly: m[5] === "/dev/null" };
+}
+function extractCatFilesMulti(cmd) {
+  if (/[|<>;&`]/.test(cmd) || cmd.includes("$(")) return null;
+  const m = /^(cat|bat|type|Get-Content|gc)\s+(.+?)\s*$/i.exec(cmd);
+  if (!m) return null;
+  const cmd0 = m[1];
+  const tokens = m[2].match(/"[^"]+"|'[^']+'|\S+/g) ?? [];
+  const paths = tokens.filter((t) => !/^-/.test(t)).map((t) => t.replace(/^["']|["']$/g, ""));
+  if (paths.length < 2) return null;
+  const out = paths.map((p) => classifyCatPath(p, cmd0)).filter((r) => r !== null);
+  return out.length >= 2 ? out : null;
+}
+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;
+function writesBackSamePath(cmd, filePath, methods) {
+  return new RegExp(`(?:${methods})\\(\\s*['"]${escapeRegExp(filePath)}['"]`, "i").test(cmd);
+}
+var NODE_WRITE_METHODS = "writeFileSync|appendFileSync";
+var PS_WRITE_METHODS = "WriteAllText|WriteAllLines|WriteAllBytes|AppendAllText|AppendAllLines";
+var PS_TEMP_READ_FLOOD_BYTES = 16 * 1024;
+function isLargeFileOnDisk(filePath, floor) {
+  try {
+    return statSync(filePath).size >= floor;
+  } catch {
+    return false;
+  }
+}
+function extractPowerShellWrappedGetContent(cmd, event) {
+  const w = POWERSHELL_WRAP_RE.exec(cmd);
+  if (!w) return null;
+  const inner = (w[1] ?? w[2] ?? "").trim();
+  if (!inner) return null;
+  if (/-(?:TotalCount|Head|First|Tail)\b/i.test(inner)) return null;
+  const m = PS_GETCONTENT_INNER_RE.exec(inner);
+  if (!m) return null;
+  const filePath = m[1] ?? m[2] ?? m[3];
+  if (filePath === void 0) return null;
+  const flags = classifyFileExtensions(filePath);
+  if (flags === null) return null;
+  if (isTempPath(filePath)) {
+    if (!commandPathIsTouchable(filePath, event)) return null;
+    if (!isLargeFileOnDisk(filePath, PS_TEMP_READ_FLOOD_BYTES)) return null;
+  }
+  return { filePath, ...flags };
+}
+function extractPowerShellFileMethodRead(cmd, event) {
+  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 (writesBackSamePath(inner, filePath, PS_WRITE_METHODS)) return null;
+  if (isTempPath(filePath)) {
+    if (!commandPathIsTouchable(filePath, event)) return null;
+    if (!isLargeFileOnDisk(filePath, PS_TEMP_READ_FLOOD_BYTES)) return null;
+  }
+  const flags = classifyFileExtensions(filePath);
+  if (flags === null) {
+    const { isDoc, isConfig, isSql, isXml } = classifyDocConfig(filePath);
+    return { filePath, isDoc, isEnv: false, isConfig, isSql, isXml };
+  }
+  return { filePath, isDoc: flags.isDoc, isEnv: flags.isEnv, isConfig: flags.isConfig, isSql: flags.isSql, isXml: flags.isXml };
+}
+function extractRgSymbolSearch(cmd) {
+  if (!/^(?:rg|grep)\s+/.test(cmd)) return null;
+  if (!/-n\b/.test(cmd)) return null;
+  const patternMatch = /["']([^"']+)["']/.exec(cmd);
+  const pattern = patternMatch?.[1];
+  if (!pattern) return null;
+  if (!/^[A-Za-z_][A-Za-z0-9_]*(\|[A-Za-z_][A-Za-z0-9_]*)*$/.test(pattern)) return null;
+  const fileMatch = /(?:^|\s)(?:"([^"]+\.(?:ts|tsx|js|jsx|py|go|rs|java|rb|php|swift|kt|cpp|cc|cxx|c|h))"|'([^']+\.(?:ts|tsx|js|jsx|py|go|rs|java|rb|php|swift|kt|cpp|cc|cxx|c|h))'|([^\s"'|<>]+\.(?:ts|tsx|js|jsx|py|go|rs|java|rb|php|swift|kt|cpp|cc|cxx|c|h)))(?:\s|$|\|)/i.exec(cmd);
+  if (!fileMatch) return null;
+  const filePath = fileMatch[1] ?? fileMatch[2] ?? fileMatch[3];
+  if (!filePath) return null;
+  if (isTempPath(filePath)) return null;
+  if (/(?:^|\s)-[a-zA-Z]*[rR][a-zA-Z]*(?=\s|$)/.test(cmd) || /(?:^|\s)--recursive(?=\s|$)/.test(cmd)) return null;
+  return { filePath, identifier: pattern };
+}
+function extractCatJsonPipe(cmd) {
+  const m = /^cat\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s*\|\s*jq\b/.exec(cmd);
+  if (m) {
+    const filePath = m[1] ?? m[2] ?? m[3];
+    if (filePath && !isTempPath(filePath) && /\.(?:json|yaml|yml|toml)$/i.test(filePath)) {
+      return { filePath, isDirectJq: false };
+    }
+  }
+  const jqDirect = /^jq(?:\s+(?:-[a-zA-Z]+|--[a-zA-Z0-9-]+(?:=\S+)?))*\s+(?:"[^"]*"|'[^']*'|(?:\.[a-zA-Z0-9_.*[\]]+))\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s*$/.exec(cmd);
+  if (jqDirect) {
+    const filePath = jqDirect[1] ?? jqDirect[2] ?? jqDirect[3];
+    if (filePath && !isTempPath(filePath) && /\.(?:json|yaml|yml|toml)$/i.test(filePath)) {
+      return { filePath, isDirectJq: true };
+    }
+  }
+  return null;
+}
+function extractPowerShellJsonPipeline(cmd) {
+  let inner = cmd.trim();
+  const w = POWERSHELL_WRAP_RE.exec(inner);
+  if (w) {
+    inner = (w[1] ?? w[2] ?? "").trim();
+  }
+  if (!/\bConvertFrom-Json\b/i.test(inner)) return null;
+  const parseTarget = (segment) => {
+    const readAll = /\[(?:System\.)?IO\.File\]::ReadAllText\(\s*['"]?([^'")\s]+)['"]?\s*\)/i.exec(segment);
+    if (readAll) {
+      const p = readAll[1];
+      return p && /\.(?:json|txt|log|temp)$/i.test(p) ? p : null;
+    }
+    const tokens = segment.trim().split(/\s+/);
+    const cmdlets = /* @__PURE__ */ new Set(["get-content", "gc", "cat", "type"]);
+    const idx = tokens.findIndex((t) => cmdlets.has(t.toLowerCase()));
+    if (idx === -1) return null;
+    let argIdx = idx + 1;
+    while (argIdx < tokens.length) {
+      const tok = tokens[argIdx];
+      if (!tok) break;
+      if (tok.startsWith("-")) {
+        const flag = tok.toLowerCase();
+        if (flag === "-path" && argIdx + 1 < tokens.length) {
+          const next = tokens[argIdx + 1];
+          if (next && !next.startsWith("-")) {
+            const clean2 = next.replace(/^['"]|['"]$/g, "");
+            return /\.(?:json|txt|log|temp)$/i.test(clean2) ? clean2 : null;
+          }
+        }
+        if ((flag === "-encoding" || flag === "-totalcount") && argIdx + 1 < tokens.length) {
+          argIdx += 2;
+          continue;
+        }
+        argIdx++;
+        continue;
+      }
+      const clean = tok.replace(/^['"(]|['")]$/g, "");
+      return /\.(?:json|txt|log|temp)$/i.test(clean) ? clean : null;
+    }
+    return null;
+  };
+  const pipeIdx = inner.search(/\|\s*ConvertFrom-Json\b/i);
+  if (pipeIdx !== -1) {
+    const upstream = inner.slice(0, pipeIdx).trim();
+    return { filePath: parseTarget(upstream) };
+  }
+  const parenMatch = /ConvertFrom-Json\s*\(([^)]+)\)/i.exec(inner);
+  if (parenMatch) {
+    const inside = parenMatch[1] ?? "";
+    return { filePath: parseTarget(inside) };
+  }
+  if (/ConvertFrom-Json\s*\(/i.test(inner)) {
+    return { filePath: null };
+  }
+  return null;
+}
+function extractWslCatFile(cmd) {
+  const wslMatch = /^wsl(?:\s+-d\s+\S+)?\s+bash\s+-c\s+"cat(?:\s+(?:-[a-zA-Z]+|--[a-zA-Z-]+))*\s+\/mnt\/([a-z])\/([^"]*)"/.exec(cmd);
+  if (!wslMatch) return null;
+  const drive = wslMatch[1]?.toUpperCase();
+  const pathRest = wslMatch[2];
+  if (!drive || !pathRest) return null;
+  const filePath = drive + ":/" + pathRest;
+  if (isTempPath(filePath)) return null;
+  const flags = classifyFileExtensions(filePath);
+  if (flags === null) return null;
+  return { filePath, ...flags };
+}
+function pythonScanText(text) {
+  const dashC = /^python3?\s+-c\s*(['"])([\s\S]*)\1\s*$/.exec(text);
+  if (dashC) {
+    const source = dashC[2] ?? "";
+    return { source, masked: maskPythonStrings(source) };
+  }
+  if (/^python3?\b/.test(text)) return { source: text, masked: text };
+  return { source: text, masked: maskPythonStrings(text) };
+}
+function maskPythonStrings(text) {
+  const out = text.split("");
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch !== "'" && ch !== '"') {
+      i += 1;
+      continue;
+    }
+    const triple = text.slice(i, i + 3);
+    const delim = triple === ch + ch + ch ? triple : ch;
+    let j = i + delim.length;
+    while (j < text.length) {
+      if (text[j] === "\\") {
+        j += 2;
+        continue;
+      }
+      if (text.slice(j, j + delim.length) === delim) break;
+      out[j] = " ";
+      j += 1;
+    }
+    i = j + delim.length;
+  }
+  return out.join("");
+}
+function pythonOpenCalls(text) {
+  const { source, masked } = pythonScanText(text);
+  const calls = [];
+  for (const opener of masked.matchAll(/\bopen\s*\(/g)) {
+    const start = (opener.index ?? 0) + opener[0].length;
+    const args = [];
+    let current = "";
+    let depth = 0;
+    let quote = "";
+    let closed = false;
+    for (let i = start; i < source.length; i++) {
+      const ch = source[i] ?? "";
+      if (quote !== "") {
+        if (ch === "\\") {
+          current += ch + (source[i + 1] ?? "");
+          i += 1;
+          continue;
+        }
+        if (ch === quote) quote = "";
+        current += ch;
+        continue;
+      }
+      if (ch === "'" || ch === '"') {
+        quote = ch;
+        current += ch;
+        continue;
+      }
+      if (ch === "(" || ch === "[" || ch === "{") {
+        depth += 1;
+        current += ch;
+        continue;
+      }
+      if (ch === ")" && depth === 0) {
+        args.push(current);
+        closed = true;
+        break;
+      }
+      if (ch === ")" || ch === "]" || ch === "}") {
+        depth -= 1;
+        current += ch;
+        continue;
+      }
+      if (ch === "," && depth === 0) {
+        args.push(current);
+        current = "";
+        continue;
+      }
+      current += ch;
+    }
+    if (!closed) continue;
+    const literalOf = (arg) => {
+      const m = /^\s*r?(['"])([^'"]*)\1\s*$/.exec(arg);
+      return m?.[2] ?? null;
+    };
+    const keyword = args.find((a) => /^\s*mode\s*=/.test(a));
+    const positional = args[1] !== void 0 && /^\s*[A-Za-z_]\w*\s*=[^=]/.test(args[1]) ? void 0 : args[1];
+    const modeArg = keyword !== void 0 ? keyword.replace(/^\s*mode\s*=/, "") : positional;
+    calls.push({
+      pathLiteral: args.length > 0 ? literalOf(args[0] ?? "") : null,
+      hasMode: modeArg !== void 0,
+      modeLiteral: modeArg === void 0 ? null : literalOf(modeArg)
+    });
+  }
+  return calls;
+}
+function pythonOpenWritesAFile(text) {
+  return pythonOpenCalls(text).some(
+    (call) => call.hasMode && (call.modeLiteral === null || /[wax+]/.test(call.modeLiteral))
+  );
+}
+function pythonWritesThroughFileObject(text) {
+  const { masked } = pythonScanText(text);
+  for (const call of masked.matchAll(/\.write(?:lines)?\s*\(/g)) {
+    const receiver = masked.slice(0, call.index ?? 0);
+    if (/(?:^|[^\w.])(?:sys\s*\.\s*)?(?:stdout|stderr|stdin)(?:\s*\.\s*buffer)?$/.test(receiver)) continue;
+    return true;
+  }
+  return false;
+}
+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|dtsx|ampkg|xaml|html|htm|conf|cfg|ini|properties|sql|ps1|psm1|env";
+var OPEN_EXT = new RegExp(`\\.(?:${KNOWN_PYTHON_EXT_STR})$`, "i");
+function extractPythonFileRead(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, isConfig: false, isEnv: false, isSql: false, isOutputFile: true };
+  }
+  const classifyResult = (filePath) => {
+    const flags = classifyFileExtensions(filePath);
+    if (flags !== null) {
+      return { filePath, isDoc: flags.isDoc, isConfig: flags.isConfig, isEnv: flags.isEnv, isSql: flags.isSql, isXml: flags.isXml, isOutputFile: false };
+    }
+    const { isDoc, isConfig, isSql, isXml } = classifyDocConfig(filePath);
+    const isEnv = /\.env(\.\w+)?$/i.test(filePath);
+    return { filePath, isDoc, isConfig, isEnv, isSql, isXml, 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 = 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;
+      return classifyResult(filePath);
+    }
+    if (/open\s*\(/.test(body) && !pythonOpenPathsAreAllLiteral(body)) {
+      const literal = new RegExp(`['"]([^'"]+\\.(?:${KNOWN_PYTHON_EXT_STR}))['"]`, "i").exec(body);
+      if (literal?.[1]) {
+        const filePath = literal[1];
+        if (isOrchestratorStateFile(filePath)) return null;
+        if (OPEN_EXT.test(filePath)) {
+          return classifyResult(filePath);
+        }
+      }
+    }
+    return null;
+  }
+  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;
+    return classifyResult(filePath);
+  }
+  if (/open\s*\(/.test(pythonBody) && !pythonOpenPathsAreAllLiteral(pythonBody)) {
+    const literal = new RegExp(`['"]([^'"]+\\.(?:${KNOWN_PYTHON_EXT_STR}))['"]`, "i").exec(pythonBody);
+    if (literal) {
+      const filePath = literal[1] ?? "";
+      if (filePath) {
+        if (isOrchestratorStateFile(filePath)) return null;
+        if (OPEN_EXT.test(filePath)) {
+          return classifyResult(filePath);
+        }
+      }
+    }
+  }
+  return null;
+}
+function extractHeadFile(cmd) {
+  const direct = /^head(?:\s+-n\s+(\d+)|\s+-(\d+))?\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s*$/.exec(cmd);
+  const piped = direct === null ? /^cat(?:\s+(?:-[a-zA-Z]+|--[a-zA-Z-]+))*\s+(?:"([^"]+)"|'([^']+)'|(\S+?))(?:\s+2>(?:&1|\/dev\/null))?\s*\|\s*head(?:\s+-n\s+(\d+)|\s+-(\d+))?\s*$/.exec(cmd) : null;
+  if (direct === null && piped === null) return null;
+  const n = parseInt((direct !== null ? direct[1] ?? direct[2] : piped[4] ?? piped[5]) ?? "0", 10);
+  if (n <= 10) return null;
+  const filePath = direct !== null ? direct[3] ?? direct[4] ?? direct[5] : piped[1] ?? piped[2] ?? piped[3];
+  if (filePath === void 0) return null;
+  if (isTempPath(filePath)) return null;
+  if (!/\.(?:ts|tsx|js|jsx|py|go|java|rs|rb|cs|md|mdx|rst|txt|json|yaml|yml|toml|sql|sh|xml|dtsx|ampkg|xaml)$/i.test(filePath)) return null;
+  const { isDoc, isConfig, isSql, isXml } = classifyDocConfig(filePath);
+  return { filePath, isDoc, isConfig, isSql, isXml, n };
+}
+function extractSedRange(cmd) {
+  const m = /^sed\s+-n\s+(?:['"]((?:\d+,\d+p)(?:;\d+,\d+p)*)['"]|(\d+,\d+p))\s+(?:"([^"]+)"|'([^']+)'|(\S+))(?:\s+2>(?:\/dev\/null|&1))?\s*$/.exec(cmd);
+  if (!m) return null;
+  const addressList = m[1] ?? m[2];
+  if (addressList === void 0) return null;
+  const ranges = [];
+  for (const clause of addressList.split(";")) {
+    const cm = /^(\d+),(\d+)p$/.exec(clause ?? "");
+    if (!cm) return null;
+    const start = parseInt(cm[1], 10);
+    const end = parseInt(cm[2], 10);
+    if (start < 1 || end < start) return null;
+    ranges.push([start, end]);
+  }
+  if (ranges.length === 0) return null;
+  const filePath = m[3] ?? m[4] ?? m[5];
+  if (filePath === void 0) return null;
+  if (isTempPath(filePath)) return null;
+  return { filePath, ranges };
+}
+function extractAwkRange(cmd) {
+  const m = /^awk\s+(?:'([^']+)'|"([^"]+)")\s+(?:"([^"]+)"|'([^']+)'|(\S+))(?:\s+2>(?:\/dev\/null|&1))?\s*$/.exec(cmd);
+  if (!m) return null;
+  const program = m[1] ?? m[2];
+  if (program === void 0) return null;
+  const cmp = /^\s*NR\s*>=\s*(\d+)\s*&&\s*NR\s*<=\s*(\d+)\s*(\{.*\})?\s*$/.exec(program);
+  const rng = /^\s*NR\s*==\s*(\d+)\s*,\s*NR\s*==\s*(\d+)\s*(\{.*\})?\s*$/.exec(program);
+  const hit = cmp ?? rng;
+  const action = hit?.[3];
+  if (action !== void 0 && !/^\{\s*(?:print(?:\s+NR\s*"[^"%]*"\s*\$0|\s+\$0)?|printf\s*"%d[^%"]*%s\\n"\s*,\s*NR\s*,\s*\$0)\s*\}$/.test(action)) return null;
+  if (!hit) return null;
+  const start = parseInt(hit[1], 10);
+  const end = parseInt(hit[2], 10);
+  if (start < 1 || end < start) return null;
+  const filePath = m[3] ?? m[4] ?? m[5];
+  if (filePath === void 0) return null;
+  if (isTempPath(filePath)) return null;
+  return { filePath, ranges: [[start, end]] };
+}
+function normalizeCatSedPipe(cmd) {
+  const m = /^cat(?:\s+(?:-[a-zA-Z]+|--[a-zA-Z-]+))*\s+(?:"([^"]+)"|'([^']+)'|(\S+?))(?:\s+2>(?:&1|\/dev\/null))?\s*\|\s*sed\s+-n\s+('[^']+'|"[^"]+"|\d+,\d+p)\s*$/.exec(cmd);
+  if (!m) return null;
+  const filePath = m[1] ?? m[2] ?? m[3];
+  if (filePath === void 0 || filePath.includes('"')) return null;
+  return "sed -n " + m[4] + ' "' + filePath + '"';
+}
+function extractLineRangeRead(cmd) {
+  const catSed = normalizeCatSedPipe(cmd);
+  if (catSed !== null) cmd = catSed;
+  const sed = extractSedRange(cmd);
+  if (sed !== null) return { ...sed, tool: "sed" };
+  const awk = extractAwkRange(cmd);
+  if (awk !== null) return { ...awk, tool: "awk" };
+  return null;
+}
+var FORMATTING_STAGE_RE = /^(?:fold|cut|cat|nl|head|tail)(?:\s+(?:-\S+|[\d,+-]+))*\s*$/;
+function extractLineRangeReadsCompound(cmd) {
+  const cleaned = cmd.replace(/\s2>(?:&1|\/dev\/null)/g, "");
+  const segments = splitShellSegments(cleaned);
+  if (segments.length < 2) return null;
+  const reads = [];
+  for (const seg of segments) {
+    const r = extractLineRangeRead(seg);
+    if (r !== null) {
+      reads.push(r);
+      continue;
+    }
+    if (/^echo\b[^<>]*$/.test(seg)) continue;
+    if (FORMATTING_STAGE_RE.test(seg)) continue;
+    return null;
+  }
+  if (reads.length === 0) return null;
+  const merged = /* @__PURE__ */ new Map();
+  for (const r of reads) {
+    const prev = merged.get(r.filePath);
+    if (prev !== void 0) prev.ranges.push(...r.ranges);
+    else merged.set(r.filePath, { filePath: r.filePath, ranges: [...r.ranges], tool: r.tool });
+  }
+  return [...merged.values()];
+}
+function sedRangeHint(filePath, ranges, tool, sub) {
+  return "`" + (tool === "awk" ? "awk" : "sed -n") + "` line-range reads bypass read hooks. " + substituteSentence(filePath, ranges, sub);
+}
+function substituteSentence(filePath, ranges, sub) {
+  const spans = ranges.map(([s, e]) => s + "-" + e).join(", ");
+  const reads = sub.commands.map((c) => "`" + c + "`");
+  const allReads = reads.length === 2 ? reads.join(" and ") : reads.length >= 3 ? reads.slice(0, -1).join(", ") + ", and " + reads[reads.length - 1] : reads[0];
+  return "Lines " + spans + " of " + filePath + " cost " + sub.requestedBytes + " bytes; " + allReads + " returns the same content as " + sub.replacementBytes + " bytes, resolved to whole regions and robust to line shifts.";
+}
+function leadingLinesHint(lead, hintPath, start, end, preHookCwd, substitute) {
+  const key = resolveIndexPath(hintPath, preHookCwd ?? process.cwd());
+  const prior = findRangeOverlap(getFileLineRanges(key), start, end);
+  if (prior !== null) return sedOverlapHint(hintPath, prior, start, end);
+  if (substitute === null) return null;
+  return lead + substituteSentence(hintPath, [[start, end]], substitute);
+}
+function findRangeOverlap(prior, start, end) {
+  let best = null;
+  let bestOverlap = 0;
+  for (const range of prior) {
+    const overlap = Math.min(range[1], end) - Math.max(range[0], start) + 1;
+    if (overlap > bestOverlap) {
+      bestOverlap = overlap;
+      best = range;
+    }
+  }
+  return best;
+}
+function sedOverlapHint(filePath, prior, start, end) {
+  const base = "You already read lines " + prior[0] + "-" + prior[1] + " of " + filePath + " via an earlier line-range read this session; this read (" + start + "-" + end + ") overlaps. ";
+  const segments = [];
+  if (start < prior[0]) segments.push([start, Math.min(end, prior[0] - 1)]);
+  if (end > prior[1]) segments.push([Math.max(start, prior[1] + 1), end]);
+  if (segments.length === 0) {
+    return base + "These lines were already served - recall them from your earlier output instead of re-reading.";
+  }
+  const reads = segments.map(([s, e]) => '`token-goat read "' + filePath + "@" + s + "-" + e + '"`').join(" and ");
+  return base + "For only the new lines, " + reads + ".";
+}
+function extractNodeFileRead(cmd) {
+  if (!/^node\s+-e/.test(cmd)) return null;
+  const readSync2 = /readFileSync\(['"]([^'"]+\.(?:ts|tsx|js|jsx|py|go|java|rs|rb|cs|md|mdx|rst|txt|json|yaml|yml|toml|xml|conf|cfg|ini|properties|sql))['"]/i.exec(cmd);
+  if (readSync2?.[1]) {
+    const filePath = readSync2[1];
+    if (isOrchestratorStateFile(filePath)) return null;
+    if (isTempPath(filePath)) return null;
+    if (writesBackSamePath(cmd, filePath, NODE_WRITE_METHODS)) return null;
+    const { isDoc, isConfig, isSql } = classifyDocConfig(filePath);
+    return { filePath, isDoc, isConfig, isSql };
+  }
+  const requireM = /require\(['"]([^'"]+\.json)['"]\)/i.exec(cmd);
+  if (requireM?.[1]) {
+    const filePath = requireM[1];
+    if (filePath.includes("node_modules")) return null;
+    if (isOrchestratorStateFile(filePath)) return null;
+    if (isTempPath(filePath)) return null;
+    if (writesBackSamePath(cmd, filePath, NODE_WRITE_METHODS)) return null;
+    return { filePath, isDoc: false, isConfig: true, isSql: false };
+  }
+  return null;
+}
+function extractTailFile(cmd) {
+  if (/-f\b/.test(cmd)) return null;
+  if (/-c\b/.test(cmd)) return null;
+  if (/-n\s*\+/.test(cmd)) return null;
+  const direct = /^tail(?:\s+-n\s+(\d+)|\s+-(\d+))?\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s*$/.exec(cmd);
+  const piped = direct === null ? /^cat(?:\s+(?:-[a-zA-Z]+|--[a-zA-Z-]+))*\s+(?:"([^"]+)"|'([^']+)'|(\S+?))(?:\s+2>(?:&1|\/dev\/null))?\s*\|\s*tail(?:\s+-n\s+(\d+)|\s+-(\d+))?\s*$/.exec(cmd) : null;
+  if (direct === null && piped === null) return null;
+  const n = parseInt((direct !== null ? direct[1] ?? direct[2] : piped[4] ?? piped[5]) ?? "0", 10);
+  if (n <= 10) return null;
+  const filePath = direct !== null ? direct[3] ?? direct[4] ?? direct[5] : piped[1] ?? piped[2] ?? piped[3];
+  if (!filePath) return null;
+  if (isTempPath(filePath)) return null;
+  if (!/\.(?:ts|tsx|js|jsx|py|go|java|rs|rb|cs|md|mdx|rst|txt|json|yaml|yml|toml|sql|sh|xml|dtsx|ampkg|xaml)$/i.test(filePath)) return null;
+  const { isDoc, isConfig, isSql, isXml } = classifyDocConfig(filePath);
+  return { filePath, isDoc, isConfig, isSql, isXml };
+}
+function extractGetContentTail(cmd) {
+  const tailMatch = /-Tail\s+(\d+)/i.exec(cmd);
+  if (!tailMatch) return null;
+  const n = parseInt(tailMatch[1], 10);
+  if (n <= 10) return null;
+  const getnMatch = /^(Get-Content|gc)\s+/i.exec(cmd);
+  if (!getnMatch) return null;
+  const afterCmd = cmd.slice(getnMatch[0].length).replace(/-Path\s+/i, "");
+  const beforeTail = afterCmd.split(/-Tail/i)[0]?.trim() ?? "";
+  const afterTail = afterCmd.split(/-Tail\s+\d+/i)[1]?.trim() ?? "";
+  const filePath = (beforeTail || afterTail).replace(/^["']|["']$/g, "");
+  if (!filePath) return null;
+  if (isTempPath(filePath)) return null;
+  if (!/\.(?:ts|tsx|js|jsx|py|go|java|rs|rb|cs|md|mdx|rst|txt|json|yaml|yml|toml|sql|sh|ps1|psm1|xml|dtsx|ampkg|xaml)$/i.test(filePath)) return null;
+  const { isDoc, isConfig, isSql, isXml } = classifyDocConfig(filePath);
+  return { filePath, isDoc, isConfig, isSql, isXml };
+}
+function extractGetContentSelectFirst(cmd) {
+  const m = /^(Get-Content|gc)\s+([^|]+)\s*\|\s*(Select-Object|select)\s+(-First\s+(\d+))/i.exec(cmd);
+  if (!m) return null;
+  const filePath = (m[2]?.trim() ?? "").replace(/^-Path\s+/i, "").replace(/^["']|["']$/g, "");
+  const n = parseInt(m[5] ?? "0", 10);
+  if (n <= 10) return null;
+  if (!filePath) return null;
+  if (isTempPath(filePath)) return null;
+  if (!/\.(?:ts|tsx|js|jsx|py|go|java|rs|rb|cs|md|mdx|rst|txt|json|yaml|yml|toml|sql|sh|ps1|psm1|xml|dtsx|ampkg|xaml)$/i.test(filePath)) return null;
+  const { isDoc, isConfig, isSql, isXml } = classifyDocConfig(filePath);
+  return { filePath, isDoc, isConfig, isSql, isXml, n };
+}
+function extractGetContentHead(cmd) {
+  const headMatch = /-(?:TotalCount|Head|First)\s+(\d+)/i.exec(cmd);
+  if (!headMatch) return null;
+  const n = parseInt(headMatch[1], 10);
+  if (n <= 10) return null;
+  const getnMatch = /^(Get-Content|gc)\s+/i.exec(cmd);
+  if (!getnMatch) return null;
+  const afterCmd = cmd.slice(getnMatch[0].length).replace(/-Path\s+/i, "");
+  const beforeHead = afterCmd.split(/-(?:TotalCount|Head|First)/i)[0]?.trim() ?? "";
+  const afterHead = afterCmd.split(/-(?:TotalCount|Head|First)\s+\d+/i)[1]?.trim() ?? "";
+  const cleanedBefore = beforeHead.replace(/-(?:Encoding|Delimiter|Wait)\s+\S+/gi, "").replace(/-[a-zA-Z]+/g, "").trim();
+  const cleanedAfter = afterHead.replace(/-(?:Encoding|Delimiter|Wait)\s+\S+/gi, "").replace(/-[a-zA-Z]+/g, "").trim();
+  const filePath = (cleanedBefore || cleanedAfter).replace(/^["']|["']$/g, "");
+  if (!filePath) return null;
+  if (isTempPath(filePath)) return null;
+  if (!/\.(?:ts|tsx|js|jsx|py|go|java|rs|rb|cs|md|mdx|rst|txt|json|yaml|yml|toml|sql|sh|ps1|psm1|xml|dtsx|ampkg|xaml)$/i.test(filePath)) return null;
+  const { isDoc, isConfig, isSql, isXml } = classifyDocConfig(filePath);
+  return { filePath, isDoc, isConfig, isSql, isXml, n };
+}
+var JSONL_TRANSCRIPT_HEAD_RE = /^\{\s*"(?:(?:parentUuid|isSidechain)"\s*:|type"\s*:\s*"fork-context-ref")/;
+function taskOutputIsJsonlTranscript(outPath) {
+  let fd = null;
+  try {
+    fd = openSync(normalizePath(outPath), "r");
+    const buf = Buffer.alloc(64);
+    const read = readSync(fd, buf, 0, buf.length, 0);
+    return JSONL_TRANSCRIPT_HEAD_RE.test(buf.subarray(0, read).toString("utf-8").trim());
+  } catch {
+    return false;
+  } finally {
+    if (fd !== null) {
+      try {
+        closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+function extractTasksOutput(cmd) {
+  const taskOutputRe = /(?:^|[/\\])tasks[/\\]([a-z0-9]+)\.output$/;
+  const catM = /^cat(?:\s+(?:-[a-zA-Z]+|--[a-zA-Z-]+))*\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s*$/.exec(cmd);
+  if (catM) {
+    const fp = catM[1] ?? catM[2] ?? catM[3];
+    if (fp) {
+      const m = taskOutputRe.exec(fp);
+      if (m) return { id: m[1], path: fp };
+    }
+  }
+  if (!/-f\b/.test(cmd) && !/-n\s*\+/.test(cmd)) {
+    const tailM = /^tail(?:\s+-n\s+(\d+)|\s+-(\d+))?\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s*$/.exec(cmd);
+    if (tailM) {
+      const fp = tailM[3] ?? tailM[4] ?? tailM[5];
+      if (fp) {
+        const m = taskOutputRe.exec(fp);
+        if (m) {
+          const nStr = tailM[1] ?? tailM[2];
+          const n = nStr !== void 0 ? parseInt(nStr, 10) : void 0;
+          return n !== void 0 ? { id: m[1], path: fp, n } : { id: m[1], path: fp };
+        }
+      }
+    }
+    const byteTailM = /^tail\s+-c\s+\d+\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s*$/.exec(cmd);
+    if (byteTailM) {
+      const fp = byteTailM[1] ?? byteTailM[2] ?? byteTailM[3];
+      if (fp) {
+        const m = taskOutputRe.exec(fp);
+        if (m) return { id: m[1], path: fp };
+      }
+    }
+  }
+  return null;
+}
+function extractToolResultsFile(cmd) {
+  const toolResultsRe = new RegExp("[/\\\\]tool-results[/\\\\](" + TOOL_RESULTS_ID_CHARS + ")\\.txt$", "i");
+  const catM = /^cat(?:\s+(?:-[a-zA-Z]+|--[a-zA-Z-]+))*\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s*$/.exec(cmd);
+  if (catM) {
+    const fp = catM[1] ?? catM[2] ?? catM[3];
+    if (fp) {
+      const m = toolResultsRe.exec(fp);
+      if (m) return { path: fp };
+    }
+  }
+  if (!/-f\b/.test(cmd) && !/-n\s*\+/.test(cmd)) {
+    const tailM = /^tail(?:\s+-n\s+(\d+)|\s+-(\d+))?\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s*$/.exec(cmd);
+    if (tailM) {
+      const fp = tailM[3] ?? tailM[4] ?? tailM[5];
+      if (fp) {
+        const m = toolResultsRe.exec(fp);
+        if (m) return { path: fp };
+      }
+    }
+    const byteTailM = /^tail\s+-c\s+\d+\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s*$/.exec(cmd);
+    if (byteTailM) {
+      const fp = byteTailM[1] ?? byteTailM[2] ?? byteTailM[3];
+      if (fp) {
+        const m = toolResultsRe.exec(fp);
+        if (m) return { path: fp };
+      }
+    }
+  }
+  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) || /^(?: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);
+}
+function extractFindCommand(cmd) {
+  if (!/^find\b/.test(cmd)) return null;
+  const isXargsGrepL = /[|]\s*xargs\s+(?:grep|rg)\s+.*-l\b/.test(cmd);
+  const nameMatch = /-name\s+['"]([^'"]+)['"]/i.exec(cmd);
+  const extGlob = nameMatch ? nameMatch[1] ?? null : null;
+  return { extGlob, isXargsGrepL };
+}
+function extractMarkdownHeadingGrep(cmd) {
+  if (!/^(?:rg|grep)\s+/.test(cmd)) return null;
+  if (!/-n\b/.test(cmd)) return null;
+  const hasHeadingPattern = /["']?\^#{1,6}["']?/.test(cmd) || /["']?\^#\+["']?/.test(cmd) || /["']?\^#\\+["']?/.test(cmd);
+  if (!hasHeadingPattern) return null;
+  const fileMatch = /(?:^|\s)(?:"([^"]+\.(?:md|markdown))"|'([^']+\.(?:md|markdown))'|([^\s"'|<>]+\.(?:md|markdown)))\s*(?:\||$)/.exec(cmd);
+  if (!fileMatch) return null;
+  const filePath = fileMatch[1] ?? fileMatch[2] ?? fileMatch[3];
+  if (!filePath) return null;
+  return { filePath };
+}
+function extractRgStructuralSearch(cmd) {
+  if (!/^(?:rg|grep)\s+/.test(cmd)) return null;
+  const hasStructural = /["']?\^?(?:def\s|class\s|function\s|func\s|fn\s|pub fn\s|import\s|from\s)/.test(cmd) || /["']\^(?:def|class|function|func|import|from)["']/.test(cmd) || /\\bdef\\b|\\bclass\\b/.test(cmd) || /["']?\^[ \t]+def\b/.test(cmd);
+  if (!hasStructural) return null;
+  const fileMatch = /(?:^|\s)(?:"([^"]+\.(?:py|ts|tsx|js|jsx|go|rs|rb|cs|java|cpp|cc|cxx|c|h|sh|bash))"|('([^']+\.(?:py|ts|tsx|js|jsx|go|rs|rb|cs|java|cpp|cc|cxx|c|h|sh|bash))')|([^\s"']+\.(?:py|ts|tsx|js|jsx|go|rs|rb|cs|java|cpp|cc|cxx|c|h|sh|bash)))\s*$/.exec(cmd);
+  if (!fileMatch) return null;
+  const filePath = fileMatch[1] ?? fileMatch[3] ?? fileMatch[4];
+  if (!filePath) return null;
+  if (isTempPath(filePath)) return null;
+  return { filePath };
+}
+function extractGrepPipeChain(cmd) {
+  return /^(?:rg|grep)\b.*\|\s*(?:rg|grep)\b/.test(cmd);
+}
+function splitCommandWords(cmd) {
+  return splitCommandWordsAt(cmd).words;
+}
+function splitCommandWordsAt(cmd) {
+  const words = [];
+  const starts = [];
+  let cur = "";
+  let quote = null;
+  let started = false;
+  let start = 0;
+  for (let i = 0; i < cmd.length; i++) {
+    const ch = cmd[i];
+    if (quote !== null) {
+      if (ch === "\\" && quote === '"' && i + 1 < cmd.length) {
+        cur += cmd[i + 1];
+        i++;
+        continue;
+      }
+      if (ch === quote) quote = null;
+      else cur += ch;
+      continue;
+    }
+    if (!started) start = i;
+    if (ch === "\\" && i + 1 < cmd.length) {
+      cur += cmd[i + 1];
+      i++;
+      started = true;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      started = true;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (started) {
+        words.push(cur);
+        starts.push(start);
+      }
+      cur = "";
+      started = false;
+      continue;
+    }
+    cur += ch;
+    started = true;
+  }
+  if (started) {
+    words.push(cur);
+    starts.push(start);
+  }
+  return { words, starts };
+}
+var COMPRESS_OPT_OUT_VAR = "TOKEN_GOAT_BASH_COMPRESS";
+var HEREDOC_OPENER_RE = /(?<!<)<<(?!<)-?[\t ]*(['"]?)([A-Za-z_]\w*)\1/g;
+function stripHeredocBodies(cmd) {
+  const kept = [];
+  const pending = [];
+  for (const line of cmd.split("\n")) {
+    if (pending.length > 0) {
+      if (line.trim() === pending[0]) pending.shift();
+      continue;
+    }
+    kept.push(line);
+    for (const m of line.matchAll(HEREDOC_OPENER_RE)) pending.push(m[2]);
+  }
+  return kept.join("\n");
+}
+var ASSIGNMENT_PREFIX_WORDS = /* @__PURE__ */ new Set(["env", "export", "time", "command", "nohup", "exec", "!", "{", "do", "then", "else"]);
+var ENV_VALUE_FLAGS = /* @__PURE__ */ new Set(["-u", "--unset", "-C", "--chdir"]);
+var ENV_PREFIX_WORDS = /* @__PURE__ */ new Set(["env"]);
+function walkCommandPrefix(words, prefixWords) {
+  const assignments = [];
+  let prefixed = false;
+  for (let i = 0; i < words.length; i++) {
+    const word = words[i];
+    const pwsh = /^\$env:([A-Za-z_]\w*)(?:=(.*))?$/i.exec(word);
+    if (pwsh !== null) {
+      assignments.push({ name: pwsh[1].toUpperCase(), value: pwsh[2] ?? (words[i + 1] === "=" ? words[i + 2] : void 0) });
+      return { command: i, assignments };
+    }
+    const posix = /^([A-Za-z_]\w*)=(.*)$/.exec(word);
+    if (posix !== null) {
+      assignments.push({ name: posix[1], value: posix[2] });
+      continue;
+    }
+    if (prefixWords.has(word)) {
+      prefixed = true;
+      continue;
+    }
+    if (prefixed && word.startsWith("-")) {
+      if (ENV_VALUE_FLAGS.has(word)) i++;
+      continue;
+    }
+    return { command: i, assignments };
+  }
+  return { command: words.length, assignments };
+}
+function stripLeadingAssignments(cmd) {
+  const { words, starts } = splitCommandWordsAt(cmd);
+  const at = starts[walkCommandPrefix(words, ENV_PREFIX_WORDS).command];
+  if (at === void 0 || at === 0) return cmd;
+  return isCompressibleSingleCommand(cmd.slice(0, at + 1)) ? cmd.slice(at) : cmd;
+}
+function commandOptsOutOfCompression(cmd) {
+  if (!cmd.toUpperCase().includes(COMPRESS_OPT_OUT_VAR)) return false;
+  const optsOut = (value) => value !== void 0 && FALSY_ENV_VALUES.has(value.trim().toLowerCase());
+  const commands = cmd.includes("<<") ? stripHeredocBodies(cmd) : cmd;
+  for (const segment of splitShellSegments(commands)) {
+    const words = splitCommandWords(segment).map((word) => word.replace(/^\(+/, ""));
+    if (walkCommandPrefix(words, ASSIGNMENT_PREFIX_WORDS).assignments.some(({ name, value }) => name === COMPRESS_OPT_OUT_VAR && optsOut(value))) return true;
+  }
+  return false;
+}
+var CURL_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "-H",
+  "--header",
+  "-A",
+  "--user-agent",
+  "-e",
+  "--referer",
+  "-b",
+  "--cookie",
+  "-c",
+  "--cookie-jar",
+  "-o",
+  "--output",
+  "--output-dir",
+  "-u",
+  "--user",
+  "-U",
+  "--proxy-user",
+  "-x",
+  "--proxy",
+  "-X",
+  "--request",
+  "-d",
+  "--data",
+  "--data-raw",
+  "--data-binary",
+  "--data-urlencode",
+  "-F",
+  "--form",
+  "-T",
+  "--upload-file",
+  "-K",
+  "--config",
+  "-w",
+  "--write-out",
+  "-m",
+  "--max-time",
+  "--connect-to",
+  "--resolve",
+  "--retry",
+  "--cacert",
+  "-E",
+  "--cert",
+  "--key",
+  "--range",
+  "-r",
+  "--interface",
+  // Options whose own value is a URL or a host. Leaving these out was the same defect as reading the first URL in the string: `curl --doh-url https://doh/ -o f https://target` answered with the DoH resolver rather than the file being fetched. `--url-query` belongs here too -- it appends query data to the request, it does not name the request target.
+  "--url-query",
+  "--doh-url",
+  "--preproxy",
+  "--proxy1.0",
+  "--socks4",
+  "--socks4a",
+  "--socks5",
+  "--socks5-hostname",
+  "--proxy-header",
+  "--noproxy",
+  "--dns-servers",
+  "--aws-sigv4",
+  "--proxy-cacert",
+  "--proxy-cert",
+  "--proxy-key",
+  "--oauth2-bearer",
+  "--hsts",
+  "--alt-svc",
+  "--etag-save",
+  "--etag-compare",
+  "--trace",
+  "--trace-ascii",
+  "--dump-header",
+  "-D"
+]);
+function extractCurlUrl(cmd) {
+  const words = splitCommandWords(cmd);
+  let positional = null;
+  for (let i = 0; i < words.length; i++) {
+    const w = words[i];
+    if (w === "--url") {
+      const next = words[i + 1];
+      if (next !== void 0 && /^https?:\/\//.test(next)) return next;
+      i++;
+      continue;
+    }
+    const eq = w.indexOf("=");
+    if (w.startsWith("--") && eq > 0) {
+      if (w.slice(0, eq) === "--url" && /^https?:\/\//.test(w.slice(eq + 1))) return w.slice(eq + 1);
+      continue;
+    }
+    if (CURL_VALUE_FLAGS.has(w)) {
+      i++;
+      continue;
+    }
+    if (w.startsWith("-") && w !== "-") continue;
+    if (/^https?:\/\//.test(w)) return w;
+    positional ??= /https?:\/\/[^\s'")}`]+/.exec(w)?.[0] ?? null;
+  }
+  if (positional !== null) return positional;
+  return null;
+}
+function extractTgSurgicalRead(cmd, cwd) {
+  const m = /^(?:token-goat|tg)\s+(symbol|read|section|skill-body|skill-compact|map)(?:\s+(.*))?$/.exec(cmd);
+  if (!m) return null;
+  const sub = m[1];
+  const rest = (m[2] ?? "").trim();
+  if (sub === "map") {
+    return { sub, spec: rest, filePath: null };
+  }
+  if (sub === "skill-body" || sub === "skill-compact") {
+    const pathFlagMatch = /--path\s+(?:"([^"]+)"|'([^']+)'|(\S+))/.exec(rest);
+    if (pathFlagMatch !== null) {
+      const rawPathArg = pathFlagMatch[1] ?? pathFlagMatch[2] ?? pathFlagMatch[3] ?? "";
+      const resolvedPath = resolveIndexPath(rawPathArg, cwd ?? process.cwd());
+      const spec2 = rest.slice(0, pathFlagMatch.index) + "--path " + resolvedPath + rest.slice(pathFlagMatch.index + pathFlagMatch[0].length);
+      return { sub, spec: spec2, filePath: null };
+    }
+    return { sub, spec: rest, filePath: null };
+  }
+  const specMatch = /^(?:"([^"]+)"|'([^']+)'|(\S+))/.exec(rest);
+  const rawSpec = specMatch?.[1] ?? specMatch?.[2] ?? specMatch?.[3] ?? null;
+  if (rawSpec === null) return null;
+  let filePath = null;
+  let spec = rawSpec;
+  if (sub === "read" || sub === "section") {
+    const rangeMatch = /^(.+)@(\d+)(?:-(\d+))?$/.exec(rawSpec);
+    const rangeSuffix = rangeMatch !== null ? "@" + rangeMatch[2] + (rangeMatch[3] !== void 0 ? "-" + rangeMatch[3] : "") : "";
+    const specWithoutRange = rangeMatch !== null ? rangeMatch[1] : rawSpec;
+    const colonIdx = specWithoutRange.indexOf("::");
+    const rawFilePath = colonIdx === -1 ? specWithoutRange : specWithoutRange.slice(0, colonIdx);
+    filePath = resolveIndexPath(rawFilePath, cwd ?? process.cwd());
+    spec = (colonIdx === -1 ? filePath : filePath + specWithoutRange.slice(colonIdx)) + rangeSuffix;
+  }
+  return { sub, spec, filePath };
+}
+function curlHasUnsafeFlags(cmd) {
+  if (/-X\s+(?:POST|PUT|PATCH|DELETE|HEAD|OPTIONS)/i.test(cmd)) return true;
+  if (/--request(?:\s+|=)(?:POST|PUT|PATCH|DELETE|HEAD|OPTIONS)/i.test(cmd)) return true;
+  if (/(?:^|\s)(?:-d|--data(?:-raw|-binary|-urlencode)?|-F|--form)\b/.test(cmd)) return true;
+  if (/(?:^|\s)(?:-u|--user)\b/.test(cmd)) return true;
+  if (/(?:-H|--header)(?:\s+|=)['"]?Authorization/i.test(cmd)) return true;
+  return false;
+}
+function isCurlGetCommand(cmd) {
+  if (!/^curl\b/.test(cmd)) return false;
+  return !curlHasUnsafeFlags(cmd);
+}
+function isReadOnlyGhApi(cmd) {
+  if (!/^gh\s+api\b/.test(cmd)) return false;
+  if (/\bgraphql\b/.test(cmd)) return false;
+  if (/(?:-H|--header)(?:\s+|=)['"]?Authorization/i.test(cmd)) return false;
+  if (/(?:-X|--method)(?:\s+|=)GET\b/i.test(cmd)) return true;
+  if (/(?:-X|--method)(?:\s+|=)(?:POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\b/i.test(cmd)) return false;
+  if (/\s(?:-f|-F|--field|--raw-field|--input)\b/.test(cmd)) return false;
+  return true;
+}
+var GH_VIEW_BATCH_HINT_KEY = "gh-view-field-batch";
+var GH_VIEW_RE = /^gh\s+(pr|issue)\s+view\b(.*)$/i;
+function extractGhViewForBatchAdvisory(cmd) {
+  const m = GH_VIEW_RE.exec(cmd);
+  if (!m) return null;
+  const sub = (m[1] ?? "").toLowerCase() === "issue" ? "issue" : "pr";
+  const rest = m[2] ?? "";
+  if (/--json\s+\S*,/.test(rest)) return null;
+  const refMatch = /^\s+(?!-)(\S+)/.exec(rest);
+  const ref = refMatch?.[1];
+  return { sub, ref };
+}
+function buildGhViewBatchAdvisory(sub, ref) {
+  const target = ref ? ref + " " : "";
+  const fields = sub === "pr" ? "number,title,state,body,labels,reviews,files" : "number,title,state,body,labels,comments";
+  const example = "gh " + sub + " view " + target + "--json " + fields;
+  return "`gh " + sub + " view` field queries can be batched: fetch every field you need in one round-trip with `" + example + "` (slice it with `--jq`) instead of querying field-by-field across multiple calls.";
+}
+function extractCurlDownload(cmd) {
+  if (!/^curl\b/.test(cmd)) return null;
+  const outputMatch = /(?:^|\s)(?:-o|--output)\s+(?:"([^"]+)"|'([^']+)'|(\S+))/.exec(cmd);
+  if (!outputMatch) return null;
+  const outputPath = outputMatch[1] ?? outputMatch[2] ?? outputMatch[3];
+  if (!outputPath) return null;
+  if (curlHasUnsafeFlags(cmd)) return null;
+  const url = extractCurlUrl(cmd);
+  if (url === null) return null;
+  return { url, outputPath };
+}
+function isTscCommand(cmd) {
+  return /^\s*tsc(\s|$)/i.test(cmd);
+}
+function isDevServerCommand(cmd) {
+  return /^\s*(vite\s+dev|next\s+dev|nuxt\s+dev)\b/i.test(cmd);
+}
+function buildRecallHint(cmd, outputId) {
+  const cmdPreview = cmd.length > 60 ? cmd.slice(0, 57) + "..." : cmd;
+  if (isTscCommand(cmd)) {
+    return "Output from a prior `" + cmdPreview + "` run is cached. Use `token-goat bash-output " + outputId + ' --grep "error TS"` to filter TypeScript errors, or `--grep "Cannot find"` for missing module errors.';
+  }
+  if (isDevServerCommand(cmd)) {
+    return "Dev server output cached (`" + cmdPreview + "`). Use `token-goat bash-output " + outputId + ' --tail 20` to see the latest output, or `--grep "error\\|warn"` to filter issues.';
+  }
+  return "Output from a prior `" + cmdPreview + "` run is cached. Use `token-goat bash-output " + outputId + "` (or `--tail 50`, `--grep ERROR`) to re-inspect it without re-running.";
+}
+function shellQuoteSingle(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function isCompressibleSingleCommand(cmd) {
+  if (!cmd || cmd.length > 65536) return false;
+  if (["$(", "`"].some((op) => cmd.includes(op))) return false;
+  if (hasUnquotedOperator(cmd, ["&&", "||", "|", ";", "<", ">"])) return false;
+  if (hasBareBackgroundOrNewline(cmd)) return false;
+  return true;
+}
+function extractTerminalXmlParsing(cmd) {
+  const trimmed = cmd.trim();
+  if (!trimmed) return null;
+  const selectXmlM = /\bSelect-Xml\b(?:\s+(?:-Path\s+)?["']?([^"'\s|;]+(?:\.xml|\.dtsx|\.ampkg|\.xaml))["']?)?/i.exec(trimmed);
+  if (selectXmlM) {
+    const rawPath = selectXmlM[1];
+    const filePath = rawPath && !rawPath.startsWith("-") ? rawPath : void 0;
+    return { filePath, toolOrScript: "Select-Xml" };
+  }
+  const psXmlCastM = /\[(?:xml|System\.Xml\.XmlDocument)\]/i.exec(trimmed);
+  if (psXmlCastM) {
+    const fileM = /["']([^"'\r\n]+\.(?:xml|dtsx|ampkg|xaml))["']/i.exec(trimmed) || /(?:Get-Content|gc|ReadAllText)\s+["']?([^"'\s|;)]+\.(?:xml|dtsx|ampkg|xaml))["']?/i.exec(trimmed);
+    const filePath = fileM?.[1];
+    return { filePath, toolOrScript: psXmlCastM[0] };
+  }
+  const inspectScriptM = /(?:powershell|pwsh|&|\.)?\s*["']?(\.?[/\\]?inspect_[^"'\s|;]+\.ps1)["']/i.exec(trimmed) || /\b(inspect_[^"'\s|;]+\.ps1)\b/i.exec(trimmed);
+  if (inspectScriptM) {
+    const fileM = /["']([^"'\r\n]+\.(?:xml|dtsx|ampkg|xaml))["']/i.exec(trimmed);
+    const filePath = fileM?.[1];
+    return { filePath, toolOrScript: inspectScriptM[1] ?? "inspect script" };
+  }
+  const pyXmlM = /\bpython(?:\d+(?:\.\d+)?)?(?:\.exe)?\b.*-c\s+["'].*?\b(xml\.etree|BeautifulSoup|minidom|lxml)\b/i.exec(trimmed);
+  if (pyXmlM) {
+    const fileM = /["']([^"'\r\n]+\.(?:xml|dtsx|ampkg|xaml))["']/i.exec(trimmed);
+    const filePath = fileM?.[1];
+    return { filePath, toolOrScript: `python ${pyXmlM[1]}` };
+  }
+  const cliXmlM = /\b(xmllint|xmlstarlet|xidel)\b/i.exec(trimmed);
+  if (cliXmlM) {
+    const fileM = /["']?([^"'\s|;]+\.(?:xml|dtsx|ampkg|xaml))["']?/i.exec(trimmed);
+    const rawPath = fileM?.[1];
+    const filePath = rawPath && !rawPath.startsWith("-") ? rawPath : void 0;
+    return { filePath, toolOrScript: cliXmlM[1] };
+  }
+  return null;
+}
+
+// src/tool_error_class.ts
+var UNKNOWN_REASON = "unclassified";
+var DENIAL_KIND_REASONS = {
+  "permission-rule": "hook_deny",
+  // 73 in the census: the user declined an approval prompt.
+  "user-rejected": "user_rejected",
+  // 1 in the census; kept because it is an enumerated harness value, not a text guess.
+  "automode-blocked": "auto_mode_blocked"
+};
+var TG_DENY_RE = /\[tg\]|token-goat/;
+var CONTENT_DELIVERED_REASON = "tg_content_delivered";
+function tgDenyReason(text) {
+  return DELIVERS_CONTENT_RE.test(text) ? CONTENT_DELIVERED_REASON : "tg_deny";
+}
+var HOOK_DENY_TEXT_RE = /^PreToolUse:\S+ hook error: /;
+var TEST_OR_BUILD_COMMAND_RE = /^(?:npm\s+(?:test|run\s+(?:test|build|lint|typecheck))|npx\s+(?:vitest|tsc|eslint|jest|playwright)|vitest|jest|pytest|tsc|eslint|cargo\s+(?:test|build|check|clippy)|go\s+(?:test|build|vet)|make|gradle|mvn|dotnet\s+(?:test|build)|ruff|mypy|python3?\s+-m\s+(?:pytest|unittest))\b/;
+var SEARCH_COMMAND_RE = /^(?:grep|egrep|fgrep|rg|findstr)\b/;
+function runsCommand(command, head) {
+  return splitShellSegments(command).some((segment) => head.test(stripLeadingAssignments(segment)));
+}
+var EXPECTED_PATTERNS = [
+  // 176: the Bash tool's own timeout, reported as SIGTERM's 143 plus this line.
+  { reason: "command_timeout", tools: ["Bash"], re: /^Exit code \d+\s+Command timed out after / },
+  // 289: exit 1 with no output from a search command, which is how grep and rg report zero hits.
+  { reason: "search_no_match", tools: ["Bash"], re: /^Exit code 1\s*$/, command: SEARCH_COMMAND_RE },
+  // 252: a test, build, lint or typecheck run reporting failures, which is the tool doing its job.
+  { reason: "test_or_build_failed", tools: ["Bash"], re: /^Exit code \d+/, command: TEST_OR_BUILD_COMMAND_RE },
+  // 302: an unbalanced quote or bracket in the command itself.
+  { reason: "shell_syntax_error", tools: ["Bash"], re: /unexpected EOF while looking for matching|syntax error near unexpected token/ },
+  // 29: a binary missing from PATH.
+  { reason: "command_not_found", tools: ["Bash"], re: /command not found/ },
+  // 272: the harness refusing a bare or leading `sleep` and pointing at Monitor instead.
+  { reason: "sleep_blocked", tools: ["Bash"], re: /^Blocked: (?:sleep \d+ followed by|standalone sleep)/ },
+  // 114: old_string absent from the file.
+  { reason: "edit_string_not_found", tools: ["Edit", "MultiEdit"], re: /^String to replace not found in file/ },
+  // 37: old_string present more than once with replace_all false.
+  { reason: "edit_multiple_matches", tools: ["Edit", "MultiEdit"], re: /^Found \d+ matches of the string to replace/ },
+  // 37: the harness's read-before-write guard.
+  { reason: "file_not_read_yet", tools: ["Edit", "MultiEdit", "Write"], re: /^File has not been read yet/ },
+  // 16: the file changed on disk after the last read.
+  { reason: "file_modified_since_read", tools: ["Edit", "MultiEdit", "Write"], re: /^File has been modified since read/ },
+  // 643 (578 Bash, 53 Read, 11 Grep, 1 Edit): a path that does not exist, in each tool's own wording.
+  { reason: "path_not_found", re: /No such file or directory|^File does not exist\.|^Path does not exist:/ },
+  // 1,171: an interpreter raising: a Python traceback header, the `Node.js vN.N.N` line Node prints under every uncaught error, or a named error line (`SyntaxError: ...`). After path_not_found, so a missing file stays a missing file whichever language reported it.
+  { reason: "script_exception", tools: ["Bash"], re: /^(?:Traceback \(most recent call last\):|Node\.js v\d+\.\d+\.\d+\b|[A-Z]\w*(?:Error|Exception)(?: \[\w+\])?: )/m },
+  // 14: a Read over the harness's size ceiling.
+  { reason: "file_too_large", tools: ["Read"], re: /^File content \([^)]*\) exceeds maximum allowed/ },
+  // 85: arguments the tool's schema rejected before it ran.
+  { reason: "input_validation", re: /^InputValidationError/ },
+  // 68: a StructuredOutput call that did not match the requested schema.
+  { reason: "schema_mismatch", tools: ["StructuredOutput"], re: /^Output does not match required schema/ },
+  // 35: the harness's concurrent-subagent ceiling.
+  { reason: "subagent_limit", tools: ["Agent", "Task"], re: /^Concurrent subagent limit reached/ },
+  // 37: a tool disabled for this session or a misspelled tool name.
+  { reason: "tool_unavailable", re: /^Error: No such tool available/ }
+];
+var EXPECTED_REASONS = [
+  "interrupted",
+  "tg_deny",
+  CONTENT_DELIVERED_REASON,
+  ...new Set(Object.values(DENIAL_KIND_REASONS)),
+  ...EXPECTED_PATTERNS.map((p) => p.reason)
+];
+var TOOL_USE_ERROR_OPEN = "<tool_use_error>";
+var TOOL_USE_ERROR_CLOSE = "</tool_use_error>";
+function unwrapToolError(errorText) {
+  let text = errorText.trim();
+  if (text.startsWith(TOOL_USE_ERROR_OPEN)) text = text.slice(TOOL_USE_ERROR_OPEN.length);
+  if (text.endsWith(TOOL_USE_ERROR_CLOSE)) text = text.slice(0, text.length - TOOL_USE_ERROR_CLOSE.length);
+  return text.trim();
+}
+function expected(reason) {
+  return { kind: "expected", reason };
+}
+function classifyToolError(tool, errorText, flags = {}) {
+  if (flags.isInterrupt === true) return expected("interrupted");
+  const text = unwrapToolError(errorText);
+  const denial = flags.denialKind;
+  if (denial !== void 0 && denial !== "") {
+    const reason = DENIAL_KIND_REASONS[denial] ?? "hook_deny";
+    return expected(reason === "hook_deny" && TG_DENY_RE.test(text) ? tgDenyReason(text) : reason);
+  }
+  if (HOOK_DENY_TEXT_RE.test(text)) return expected(TG_DENY_RE.test(text) ? tgDenyReason(text) : "hook_deny");
+  for (const p of EXPECTED_PATTERNS) {
+    if (p.tools !== void 0 && (tool === void 0 || !p.tools.includes(tool))) continue;
+    if (!p.re.test(text)) continue;
+    if (p.command !== void 0 && (flags.command === void 0 || !runsCommand(flags.command, p.command))) continue;
+    return expected(p.reason);
+  }
+  return { kind: "unknown", reason: UNKNOWN_REASON };
+}
+var ERROR_PREFIX_CHARS = 60;
+var EXIT_CODE_HEADER_RE = /^Exit code (\d+)\s*/;
+function errorPrefix(errorText) {
+  let text = unwrapToolError(errorText);
+  let lead = "";
+  const exit = EXIT_CODE_HEADER_RE.exec(text);
+  if (exit !== null) {
+    lead = `exit ${exit[1] ?? ""}: `;
+    text = text.slice(exit[0].length);
+  }
+  const line = text.split("\n").find((l) => l.trim() !== "") ?? "";
+  const masked = line.trim().replace(/\b[A-Za-z]:[\\/]\S*|~?\/[\w.~-]+(?:\/[\w.~-]*)+/g, "<path>").replace(/'[^'\n]*'|"[^"\n]*"|`[^`\n]*`/g, "<q>").replace(/\d+/g, "N");
+  return safeSlice(`${lead}${masked === "" ? "(empty)" : masked}`, ERROR_PREFIX_CHARS);
+}
+
+export {
+  sqlTableHint,
+  surgicalHintFor,
+  surgicalHintForConfigDoc,
+  splitShellSegments,
+  extractCatSourceFile,
+  classifyCatPath,
+  extractCatFile,
+  extractCatFilesMulti,
+  extractPowerShellWrappedGetContent,
+  extractPowerShellFileMethodRead,
+  extractRgSymbolSearch,
+  extractCatJsonPipe,
+  extractPowerShellJsonPipeline,
+  extractWslCatFile,
+  extractPythonFileRead,
+  extractHeadFile,
+  extractLineRangeRead,
+  extractLineRangeReadsCompound,
+  sedRangeHint,
+  leadingLinesHint,
+  findRangeOverlap,
+  sedOverlapHint,
+  extractNodeFileRead,
+  extractTailFile,
+  extractGetContentTail,
+  extractGetContentSelectFirst,
+  extractGetContentHead,
+  taskOutputIsJsonlTranscript,
+  extractTasksOutput,
+  extractToolResultsFile,
+  extractDirectoryListing,
+  extractForLoopWcL,
+  extractFindCommand,
+  extractMarkdownHeadingGrep,
+  extractRgStructuralSearch,
+  extractGrepPipeChain,
+  stripLeadingAssignments,
+  commandOptsOutOfCompression,
+  extractCurlUrl,
+  extractTgSurgicalRead,
+  isCurlGetCommand,
+  isReadOnlyGhApi,
+  GH_VIEW_BATCH_HINT_KEY,
+  extractGhViewForBatchAdvisory,
+  buildGhViewBatchAdvisory,
+  extractCurlDownload,
+  isTscCommand,
+  buildRecallHint,
+  shellQuoteSingle,
+  isCompressibleSingleCommand,
+  extractTerminalXmlParsing,
+  CONTENT_DELIVERED_REASON,
+  SEARCH_COMMAND_RE,
+  classifyToolError,
+  errorPrefix
+};