token-goat 2.6.33 → 2.6.35

package/dist/{token-goat-chunk-L6FVTDPD.mjs → token-goat-chunk-Y2NH6DGZ.mjs}

@@ -2,13 +2,15 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   canRunWrappedShell,
+  compressOutput,
   dedupeConsecutive,
   detectFromCommand,
+  filterByName,
   hasBareBackgroundOrNewline,
   isRewriteWorthwhile,
   resolveMinNetSavingsBytes,
   shlexSplit
-} from "./token-goat-chunk-RQQ4SY2P.mjs";
+} from "./token-goat-chunk-DQIT5JIF.mjs";
 import {
   BASH_OUTPUT_SUBDIR,
   HOOK_EVENTS,
@@ -27,7 +29,7 @@ import {
   storeBashOutput,
   storeWebOutput,
   summarizeOutputDelta
-} from "./token-goat-chunk-OHQ7RBLL.mjs";
+} from "./token-goat-chunk-SIHYQCTM.mjs";
 import {
   BODY_FIRST_TOOL_RESPONSE_KEYS,
   OUTPUT_FIRST_TOOL_RESPONSE_KEYS,
@@ -117,11 +119,12 @@ import {
   wasCliReadThisSession,
   wasFileReadThisSession,
   wasHintShown
-} from "./token-goat-chunk-TDYTBCT4.mjs";
+} from "./token-goat-chunk-I2KCEGIP.mjs";
 import {
   VERSION,
   detectHarness,
   detectLanguage,
+  displaySafePath,
   extractErrorMessage,
   foldPath,
   getDb,
@@ -135,7 +138,7 @@ import {
   runGit,
   shortFingerprint,
   toKB
-} from "./token-goat-chunk-WFRR2DBG.mjs";
+} from "./token-goat-chunk-K7W3P2TJ.mjs";
 import "./token-goat-chunk-AO2QD2AG.mjs";
 import "./token-goat-chunk-AEX54RUZ.mjs";
 
@@ -314,9 +317,9 @@ function postEditHandlerInner(event) {
     } catch {
     }
     if (meetsSavingsFloor(editedSize)) {
-      const escapedPath = normalized.replace(/`/g, "\\`").replace(/"/g, '\\"');
+      const escapedPath = displaySafePath(normalized).replace(/`/g, "\\`").replace(/"/g, '\\"');
       return contextOutput(
-        editedBasename + ' was edited. Use `token-goat section "' + escapedPath + '::HeadingName"` to re-read a specific section rather than the full file.'
+        displaySafePath(editedBasename) + ' was edited. Use `token-goat section "' + escapedPath + '::HeadingName"` to re-read a specific section rather than the full file.'
       );
     }
   }
@@ -575,7 +578,7 @@ import crypto from "node:crypto";
 var TRACKED_SKILL = "token-goat";
 var MAX_COMMANDS_SHOWN = 8;
 async function currentCommandNames() {
-  const { buildProgram } = await import("./token-goat-chunk-HPWPUBAK.mjs");
+  const { buildProgram } = await import("./token-goat-chunk-YF67EWRH.mjs");
   return flattenCommandNames(buildCommandManifest(buildProgram()));
 }
 async function recordSkillVersionSnapshot(sessionId, skillName) {
@@ -7054,6 +7057,10 @@ function stripCdPrefix(cmd) {
   const stripped = cmd.replace(/^(?:cd\s+(?:"[^"]*"|'[^']*'|\S+)\s*&&\s*)+/, "");
   return stripped.trim() || cmd;
 }
+function stripTrailingStderrRedirect(cmd) {
+  const stripped = cmd.replace(/\s*2>&1\s*$/, "");
+  return stripped.trim() || cmd;
+}
 function hasTestRunScopeOrBudget(cmd) {
   const hasTimeout = /(?:^|\s)(?:timeout(?:\.exe)?\s+\S+|--(?:test)?timeout(?:=|\s)\S+)/i.test(cmd);
   const hasSelector = /(?:\s::\S+|\s(?:-k|-t|-run|--(?:testNamePattern|last-failed|test|project))(?:=|\s)|\b(?:tests?|spec)\S*\.(?:[cm]?[jt]sx?|py|go|rs)\b|(?:^|\s)\.\/\S+)/i.test(cmd);
@@ -7145,6 +7152,182 @@ function isHeadMovingGitCommand(cmd) {
 }
 var ORIG_HEAD_ELIGIBLE_GIT_RE = /^\s*git\s+(?:pull|merge|rebase)\b/i;
 var ORIG_HEAD_REFLOG_MSG_RE = /^(merge\s|rebase\s\(|pull\s)/i;
+var GIT_RESTORE_RE = /^\s*git\s+restore\b/i;
+var GIT_RESTORE_STAGED_ONLY_RE = /(?:^|\s)(?:--staged|-S)(?:\s|$)/;
+var GIT_STASH_APPLY_RE = /^\s*git\s+stash\s+(?:pop|apply)\b/i;
+var PATCH_APPLY_SEGMENT_RE = /^\s*(?:\S*[/\\])?(?:git\s+apply|patch)\b/i;
+var PATCH_APPLY_INSPECT_ONLY_RE = /(?:^|\s)--(?:check|stat|numstat|summary|dry-run)(?:\s|=|$)/i;
+function isFormatterWriteSegment(segment) {
+  return /(?:^|\s|[/\\])(?:prettier|eslint)\b/i.test(segment) && /(?:^|\s)--(?:write|fix)(?:\s|$)/i.test(segment);
+}
+function 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 === "|" || 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 safeShlexSplit(segment) {
+  try {
+    return shlexSplit(segment);
+  } catch {
+    return null;
+  }
+}
+function segmentCommandIs(segment, name2) {
+  return new RegExp("^\\s*(?:\\S*[/\\\\])?" + name2 + "(?:\\.exe)?\\b", "i").test(segment);
+}
+function extractSedInPlaceFiles(segment) {
+  if (!segmentCommandIs(segment, "sed")) return [];
+  const tokens = safeShlexSplit(segment);
+  if (tokens === null) return [];
+  const rest = tokens.slice(1);
+  const inPlaceIdx = rest.findIndex((t) => t === "--in-place" || t.startsWith("--in-place=") || /^-[a-zA-Z]*i/.test(t));
+  if (inPlaceIdx === -1) return [];
+  const files = [];
+  let scriptTaken = rest.some((t) => t === "-e" || t === "-f" || t.startsWith("--expression") || t.startsWith("--file"));
+  for (let i = 0; i < rest.length; i++) {
+    const t = rest[i];
+    if (i === inPlaceIdx) {
+      if (t === "-i" && rest[i + 1] === "") i++;
+      continue;
+    }
+    if (t === "-e" || t === "-f" || t === "--expression" || t === "--file") {
+      i++;
+      continue;
+    }
+    if (t.length > 1 && t.startsWith("-")) continue;
+    if (!scriptTaken) {
+      scriptTaken = true;
+      continue;
+    }
+    files.push(t);
+  }
+  return files;
+}
+function extractTeeFiles(segment) {
+  if (!segmentCommandIs(segment, "tee")) return [];
+  const tokens = safeShlexSplit(segment);
+  if (tokens === null) return [];
+  return tokens.slice(1).filter((t) => t.length > 0 && !t.startsWith("-"));
+}
+function extractRedirectTargets(segment) {
+  const targets = [];
+  const re = /(?:^|\s)[0-9]?>>?\s*("[^"]*"|'[^']*'|[^\s|&<>]+)/g;
+  let m;
+  while ((m = re.exec(segment)) !== null) {
+    const raw = m[1];
+    targets.push(raw.length >= 2 && (raw[0] === '"' || raw[0] === "'") ? raw.slice(1, -1) : raw);
+  }
+  return targets;
+}
+function extractGitRestorePathspecs(cmd) {
+  const m = /^\s*git\s+restore\b(.*)$/i.exec(cmd);
+  if (m === null) return [];
+  const tokens = safeShlexSplit(m[1] ?? "");
+  if (tokens === null) return [];
+  const dashDash = tokens.indexOf("--");
+  if (dashDash !== -1) return tokens.slice(dashDash + 1);
+  const specs = [];
+  let skipNext = false;
+  for (const t of tokens) {
+    if (skipNext) {
+      skipNext = false;
+      continue;
+    }
+    if (t === "-s" || t === "--source") {
+      skipNext = true;
+      continue;
+    }
+    if (t.startsWith("-")) continue;
+    specs.push(t);
+  }
+  return specs;
+}
+function gitRepoRoot(gitDir) {
+  const toplevel = runGit(["rev-parse", "--show-toplevel"], { cwd: gitDir, timeoutMs: 5e3 });
+  return toplevel.exitCode === 0 && toplevel.stdout.trim() !== "" ? toplevel.stdout.trim() : gitDir;
+}
+function expandGitPathspecs(specs, gitDir) {
+  if (specs.length === 0) return [];
+  const listed = runGit(["ls-files", "--full-name", "--", ...specs], { cwd: gitDir, timeoutMs: 5e3 });
+  if (listed.exitCode !== 0) return [];
+  const repoRoot = gitRepoRoot(gitDir);
+  return listed.stdout.split("\n").map((l) => l.trim()).filter((l) => l.length > 0).map((rel) => resolveIndexPath(rel, repoRoot));
+}
+function workingTreeStatusPaths(gitDir) {
+  const status = runGit(["status", "--porcelain"], { cwd: gitDir, timeoutMs: 5e3 });
+  if (status.exitCode !== 0) return [];
+  const repoRoot = gitRepoRoot(gitDir);
+  const out = [];
+  for (const line of status.stdout.split("\n")) {
+    if (line.length < 4) continue;
+    let rel = line.slice(3).trim();
+    if (rel.length === 0) continue;
+    const arrow = rel.lastIndexOf(" -> ");
+    if (arrow !== -1) rel = rel.slice(arrow + 4);
+    if (rel.startsWith('"')) {
+      try {
+        rel = JSON.parse(rel);
+      } catch {
+        continue;
+      }
+    }
+    out.push(resolveIndexPath(rel, repoRoot));
+  }
+  return out;
+}
+function enqueueRewrittenPath(absPath) {
+  if (/(?:^|[/\\])(?:NUL|nul)$/.test(absPath) || absPath.replace(/\\/g, "/").endsWith("/dev/null")) return;
+  try {
+    if (!statSync3(absPath).isFile()) return;
+  } catch {
+    return;
+  }
+  enqueueDirtyPathSafe(absPath, { alreadyResolved: true });
+}
+function enqueueNonHeadMovingRewrites(cmd, rawCmd, cwd) {
+  const atCwd = (f) => resolveIndexPath(resolveCdHintPath(rawCmd, f, cwd), cwd);
+  const paths = [];
+  let needsStatusSweep = GIT_STASH_APPLY_RE.test(cmd);
+  if (GIT_RESTORE_RE.test(cmd) && !GIT_RESTORE_STAGED_ONLY_RE.test(cmd)) {
+    paths.push(...expandGitPathspecs(extractGitRestorePathspecs(cmd), cwd));
+  }
+  for (const segment of splitShellSegments(cmd)) {
+    if (PATCH_APPLY_SEGMENT_RE.test(segment) && !PATCH_APPLY_INSPECT_ONLY_RE.test(segment)) needsStatusSweep = true;
+    if (isFormatterWriteSegment(segment)) needsStatusSweep = true;
+    for (const f of extractSedInPlaceFiles(segment)) paths.push(atCwd(f));
+    for (const f of extractTeeFiles(segment)) paths.push(atCwd(f));
+    for (const f of extractRedirectTargets(segment)) paths.push(atCwd(f));
+  }
+  if (needsStatusSweep) paths.push(...workingTreeStatusPaths(cwd));
+  for (const p of paths) enqueueRewrittenPath(p);
+}
 function isTempPath(fp) {
   const norm = fp.replace(/\\/g, "/");
   return /^\/tmp\//i.test(norm) || /\/var\/folders\//i.test(norm) || /AppData\/Local\/Temp\//i.test(norm) || norm.startsWith("/c/Users/") && norm.includes("/AppData/Local/Temp/") || isUnderSystemTemp(fp);
@@ -7259,9 +7442,126 @@ function extractWslCatFile(cmd) {
   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);
+}
 function extractPythonFileRead(cmd) {
   if (!/^python3?\b/.test(cmd)) return null;
-  if (/open\s*\([^)]*,\s*['"][wa]/i.test(cmd) || /\.write\s*\(/.test(cmd)) return null;
+  if (pythonOpenWritesAFile(cmd) || pythonWritesThroughFileObject(cmd)) return null;
   const outputOpen = /open\s*\(\s*r?['"]([^'"]+\.output)['"]/i.exec(cmd);
   if (outputOpen?.[1]) {
     const filePath = outputOpen[1];
@@ -7272,7 +7572,7 @@ function extractPythonFileRead(cmd) {
   const heredocMatch = /^python3?\s+-\s+<<\s*'?(\w+)'?\s*\n([\s\S]*?)\n\1\s*$/.exec(cmd);
   if (heredocMatch) {
     const body = heredocMatch[2] ?? "";
-    if (/open\s*\([^)]*,\s*['"][wa]/i.test(body) || /\.write\s*\(/.test(body) || /\.writelines\s*\(/.test(body)) return null;
+    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);
     if (heredocOpen?.[1]) {
       const filePath = heredocOpen[1];
@@ -7280,7 +7580,7 @@ function extractPythonFileRead(cmd) {
       const isDoc = /\.(?:md|mdx|rst|txt)$/i.test(filePath);
       return { filePath, isDoc, isTranscript: false };
     }
-    if (/open\s*\(/.test(body)) {
+    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);
       if (literal2?.[1]) {
         const filePath = literal2[1];
@@ -7301,7 +7601,7 @@ function extractPythonFileRead(cmd) {
     const isDoc = /\.(?:md|mdx|rst|txt)$/i.test(filePath);
     return { filePath, isDoc, isTranscript: false };
   }
-  if (/open\s*\(/.test(cmd)) {
+  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 (literal2) {
       const filePath = literal2[1] ?? "";
@@ -7348,6 +7648,30 @@ function extractSedRange(cmd) {
   if (isTempPath(filePath)) return null;
   return { filePath, ranges };
 }
+function extractAwkRange(cmd) {
+  const m = /^awk\s+(?:'([^']+)'|"([^"]+)")\s+(?:"([^"]+)"|'([^']+)'|(\S+))(?:\s+2>\/dev\/null)?\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*$/.exec(program);
+  const rng = /^\s*NR\s*==\s*(\d+)\s*,\s*NR\s*==\s*(\d+)\s*$/.exec(program);
+  const hit = cmp ?? rng;
+  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 extractLineRangeRead(cmd) {
+  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 SYMBOL_BEARING_LANGUAGES = /* @__PURE__ */ new Set([
   "python",
   "typescript",
@@ -7378,11 +7702,11 @@ var SYMBOL_BEARING_LANGUAGES = /* @__PURE__ */ new Set([
   "salesforce_metadata",
   "salesforce_markup"
 ]);
-function sedRangeHint(filePath, ranges) {
+function sedRangeHint(filePath, ranges, tool) {
   const lang = detectLanguage(filePath);
   const rangeReads = ranges.map(([s, e]) => '`token-goat read "' + filePath + "@" + s + "-" + e + '"`');
   const allReads = rangeReads.length === 2 ? rangeReads.join(" and ") : rangeReads.length >= 3 ? rangeReads.slice(0, -1).join(", ") + ", and " + rangeReads[rangeReads.length - 1] : rangeReads[0];
-  const prefix = "`sed -n` line-range reads bypass read hooks. ";
+  const prefix = "`" + (tool === "awk" ? "awk" : "sed -n") + "` line-range reads bypass read hooks. ";
   if (lang === "markdown") {
     return prefix + 'For Markdown, `token-goat section "' + filePath + '::<heading>"` extracts a whole section by name (robust to line shifts); or ' + allReads + " for exactly those lines.";
   }
@@ -7407,7 +7731,7 @@ function findRangeOverlap(prior, start, end) {
   return best;
 }
 function sedOverlapHint(filePath, prior, start, end) {
-  const base = "You already read lines " + prior[0] + "-" + prior[1] + " of " + filePath + " via an earlier `sed` this session; this read (" + start + "-" + end + ") overlaps. ";
+  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]);
@@ -7583,12 +7907,151 @@ function extractRgStructuralSearch(cmd) {
 function extractGrepPipeChain(cmd) {
   return /^(?:rg|grep)\b.*\|\s*(?:rg|grep)\b/.test(cmd);
 }
+function splitCommandWords(cmd) {
+  const words = [];
+  let cur = "";
+  let quote = null;
+  let started = false;
+  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 (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);
+      cur = "";
+      started = false;
+      continue;
+    }
+    cur += ch;
+    started = true;
+  }
+  if (started) words.push(cur);
+  return words;
+}
+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 m = /(https?:\/\/[^\s'"]+)/.exec(cmd);
-  return m?.[1] ?? null;
+  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\s+(symbol|read|section|skill-body|skill-compact|map)(?:\s+(.*))?$/.exec(cmd);
+  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();
@@ -7667,9 +8130,9 @@ function extractCurlDownload(cmd) {
   const outputPath = outputMatch[1] ?? outputMatch[2] ?? outputMatch[3];
   if (!outputPath) return null;
   if (curlHasUnsafeFlags(cmd)) return null;
-  const urlMatch = /(https?:\/\/[^\s'"]+)/.exec(cmd);
-  if (!urlMatch?.[1]) return null;
-  return { url: urlMatch[1], outputPath };
+  const url = extractCurlUrl(cmd);
+  if (url === null) return null;
+  return { url, outputPath };
 }
 function isTscCommand(cmd) {
   return /^\s*tsc(\s|$)/i.test(cmd);
@@ -7708,11 +8171,12 @@ function maybeCompressRewrite(event, rawCmd, cmd) {
   }
   if (!cfg.enabled) return null;
   if (!canRunWrappedShell()) return null;
-  const detected = detectFromCommand(cmd, getCwd(event));
+  const gateCmd = stripTrailingStderrRedirect(cmd);
+  const detected = detectFromCommand(gateCmd, getCwd(event));
   let filterName;
   if (detected !== null) {
     filterName = detected.filter.name;
-  } else if (isCompressibleSingleCommand(cmd)) {
+  } else if (isCompressibleSingleCommand(gateCmd)) {
     filterName = "generic";
   } else {
     return null;
@@ -7721,9 +8185,34 @@ 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 } };
 }
+async function maybeCompressCompoundOutput(cmd, output, exitCode, cwd, cacheMinBytes) {
+  if (process.env["TOKEN_GOAT_BASH_COMPRESS"] === "0") return null;
+  if (isCompressibleSingleCommand(cmd)) return null;
+  if (exitCode !== null && exitCode !== 0) return null;
+  let cfg;
+  try {
+    cfg = loadConfig().bash_compress;
+  } catch {
+    return null;
+  }
+  if (!cfg.enabled || cfg.disabled_filters.includes("generic")) return null;
+  if (Buffer.byteLength(output, "utf-8") < cacheMinBytes) return null;
+  const filter3 = filterByName("generic");
+  if (filter3 === null) return null;
+  const compressed = compressOutput(filter3, output, "", exitCode ?? 0, [], {
+    maxLines: cfg.max_lines,
+    maxBytes: cfg.max_bytes
+  });
+  const minNet = resolveMinNetSavingsBytes();
+  if (!compressed.worthApplying(minNet)) return null;
+  const id = await storeBashOutput(cmd, output, exitCode ?? 0, cwd);
+  recordStat("bash_compress:generic", compressed.bytesSaved, compressed.tokensSaved);
+  const body = compressed.withMarker(minNet) + "\n[token-goat] full output: bash-output " + id + " --full";
+  return { hookType: "rewriteOutput", updatedOutput: body };
+}
 function unwrapCompressCommand(executed) {
   const t = executed.trim();
-  if (!/^token-goat\s+compress\b/.test(t)) return null;
+  if (!/^(?:token-goat|tg)\s+compress\b/.test(t)) return null;
   let argv;
   try {
     argv = shlexSplit(t);
@@ -7775,6 +8264,28 @@ function detectUnbalancedShellSyntax(cmd) {
       i = j;
       continue;
     }
+    if (ch === "$" && cmd[i + 1] === "'") {
+      let j = i + 2;
+      let closed = false;
+      while (j < cmd.length) {
+        if (cmd[j] === "\\") {
+          j += 2;
+          continue;
+        }
+        if (cmd[j] === "'") {
+          j++;
+          closed = true;
+          break;
+        }
+        j++;
+      }
+      if (!closed) {
+        inSingle = true;
+        break;
+      }
+      i = j;
+      continue;
+    }
     if (ch === "#" && (i === 0 || /\s/.test(cmd[i - 1] ?? ""))) {
       const nl2 = cmd.indexOf("\n", i);
       i = nl2 === -1 ? cmd.length : nl2 + 1;
@@ -7929,9 +8440,9 @@ function preBashHandlerInner(event) {
       "Use `token-goat outline <file>` to see symbol names and line counts without loading files."
     );
   }
-  const sedRange = extractSedRange(cmd);
+  const sedRange = extractLineRangeRead(cmd);
   if (sedRange !== null) {
-    const { filePath, ranges } = sedRange;
+    const { filePath, ranges, tool } = sedRange;
     const hintPath = cdStripped ? resolveCdHintPath(rawCmd, filePath, hintCwd) : filePath;
     recordStat("session_hint", 0, 0);
     const sedDedupKey = resolveIndexPath(hintPath, preHookCwd ?? process.cwd());
@@ -7947,7 +8458,7 @@ function preBashHandlerInner(event) {
       }
     }
     const hints = [...overlapHints];
-    if (freshRanges.length > 0) hints.push(sedRangeHint(hintPath, freshRanges));
+    if (freshRanges.length > 0) hints.push(sedRangeHint(hintPath, freshRanges, tool));
     return contextOutput(hints.join(" "));
   }
   const catJsonPipe = extractCatJsonPipe(cmd);
@@ -8200,7 +8711,7 @@ function preBashHandlerInner(event) {
       );
     }
   }
-  if (!isBuildCommand(cmd) && detectFromCommand(cmd, preHookCwd ?? void 0) === null) return passOutput();
+  if (!isBuildCommand(cmd) && detectFromCommand(stripTrailingStderrRedirect(cmd), preHookCwd ?? void 0) === null) return passOutput();
   const cmdHash = shortFingerprint(stripOutputPipeline(cmd));
   const outputId = getBashOutputId(cmdHash);
   const entryRaw = outputId !== null ? getBashOutput(outputId) : null;
@@ -8315,8 +8826,7 @@ async function postBashHandler(event) {
       }
       const mutationDiff = runGit(["diff", "--name-only", diffBase, "HEAD"], { cwd: gitDir, timeoutMs: 5e3 });
       if (mutationDiff.exitCode === 0) {
-        const toplevel = runGit(["rev-parse", "--show-toplevel"], { cwd: gitDir, timeoutMs: 5e3 });
-        const repoRoot = toplevel.exitCode === 0 && toplevel.stdout.trim() !== "" ? toplevel.stdout.trim() : gitDir;
+        const repoRoot = gitRepoRoot(gitDir);
         for (const rel of mutationDiff.stdout.split("\n")) {
           const trimmed = rel.trim();
           if (trimmed.length === 0) continue;
@@ -8324,6 +8834,9 @@ async function postBashHandler(event) {
         }
       }
     }
+    if (exitCode === null || exitCode === 0) {
+      enqueueNonHeadMovingRewrites(cmd, rawCmd, cwd ?? process.cwd());
+    }
     const curlDl = extractCurlDownload(cmd);
     if (curlDl !== null && (exitCode === null || exitCode === 0)) {
       const resolvedOutputPath = resolveIndexPath(curlDl.outputPath, cwd ?? process.cwd());
@@ -8379,7 +8892,11 @@ async function postBashHandler(event) {
       recordBashOutput(gitScopedCacheHash, gitScopedCacheId, Buffer.byteLength(output, "utf-8"));
     }
     const isMonitoring = getMonitoringRecallHint(cmd) !== null;
-    if (!isMonitoring && !isBuildCommand(cmd) && !isCurlGetCommand(cmd)) return passOutput();
+    if (!isMonitoring && !isBuildCommand(cmd) && !isCurlGetCommand(cmd)) {
+      const compound = await maybeCompressCompoundOutput(cmd, output, exitCode, cwd, cacheMinBytes);
+      if (compound !== null) return compound;
+      return passOutput();
+    }
     if (Buffer.byteLength(output, "utf-8") < cacheMinBytes) return passOutput();
     const cacheKey = isCurlGetCommand(cmd) ? extractCurlUrl(cmd) ?? cmd : stripOutputPipeline(cmd);
     const simpleHash = shortFingerprint(cacheKey);
@@ -8971,8 +9488,21 @@ function compressGWorkspaceMcpResult(toolName, resultText) {
   const summarized = summarizeAttachments(trimmed);
   return finishWithGenericPass(resultText, summarized);
 }
+var DATA_URL_BASE64_RE = /data:([a-zA-Z0-9.+-]+\/[a-zA-Z0-9.+-]+);base64,([A-Za-z0-9+/=]+)/g;
+var MIN_BASE64_PAYLOAD_LEN = 100;
+function stripBase64DataUrls(resultText) {
+  let changed = false;
+  const out = resultText.replace(DATA_URL_BASE64_RE, (match, mime, payload) => {
+    if (payload.length < MIN_BASE64_PAYLOAD_LEN) return match;
+    changed = true;
+    return `data:${mime};base64,<stripped ${payload.length} bytes>`;
+  });
+  return changed ? out : null;
+}
 function compressMcpResultWithPacks(toolName, resultText) {
-  return compressGithubMcpResult(toolName, resultText) ?? compressBrowserMcpResult(toolName, resultText) ?? compressGWorkspaceMcpResult(toolName, resultText);
+  const base64Stripped = stripBase64DataUrls(resultText);
+  const text = base64Stripped ?? resultText;
+  return compressGithubMcpResult(toolName, text) ?? compressBrowserMcpResult(toolName, text) ?? compressGWorkspaceMcpResult(toolName, text) ?? base64Stripped;
 }
 
 // src/hooks_mcp.ts
@@ -9492,6 +10022,9 @@ async function relayInProcess(eventName, rawPayload) {
 async function relay(eventName) {
   try {
     if (!isHookEventName(eventName)) {
+      console.error(
+        `[relay] unknown hook event '${eventName}'; nothing ran. Valid events: ${HOOK_EVENTS.join(", ")}`
+      );
       process.stdout.write("{}");
       return;
     }