token-goat 2.9.19 → 2.9.21

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

@@ -0,0 +1,1816 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  DEFAULT_MAX_AGE_MS,
+  blobPath,
+  isBlobStale,
+  loadBlob,
+  redactSecrets,
+  storeBlob,
+  stripAnsiEscapes
+} from "./token-goat-chunk-PHDNWISV.mjs";
+import {
+  sanitizeFtsQuery
+} from "./token-goat-chunk-XQSSPX3X.mjs";
+import {
+  getDb
+} from "./token-goat-chunk-2ZHD3XCD.mjs";
+import {
+  shortFingerprint
+} from "./token-goat-chunk-M6CDVASA.mjs";
+import {
+  registerReset
+} from "./token-goat-chunk-EEIDFMEM.mjs";
+import {
+  globalDbPath,
+  runGit
+} from "./token-goat-chunk-TGBSMHPM.mjs";
+import {
+  normalizePath
+} from "./token-goat-chunk-NMTKNYGF.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/tool_filters/helpers.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path from "node:path";
+var DEFAULT_MAX_LINES = 1e3;
+var DEFAULT_MAX_BYTES = 64 * 1024;
+var MAX_INSPECT_BYTES = 2 * 1024 * 1024;
+var DEFAULT_MAX_INPUT_BYTES = 500 * 1024;
+var FALLBACK_MAX_LINE_CHARS = 400;
+var LONG_LINE_MAX_CHARS = 1e3;
+var ELIDED_MARKER_RE = /… \[\d+ chars elided\]/;
+var CLIPPED_MARKER_RE = / \.\.\. \[(\d+) chars clipped\] \.\.\. /;
+function getMaxInputBytes() {
+  const raw = process.env["TOKEN_GOAT_FILTER_MAX_BYTES"];
+  const v = raw ? Number.parseInt(raw, 10) : 0;
+  return Number.isFinite(v) && v > 0 ? v : DEFAULT_MAX_INPUT_BYTES;
+}
+function utf8SafeEnd(buf, n) {
+  if (n >= buf.length) return buf.length;
+  let end = n;
+  while (end > 0 && (buf[end] & 192) === 128) end--;
+  return end;
+}
+var INPUT_MAX_LINE_CHARS = 4e3;
+function clipWideLines(text, maxChars = INPUT_MAX_LINE_CHARS) {
+  if (text.length <= maxChars) return text;
+  let clipped = 0;
+  const out = text.split("\n").map((line) => {
+    if (line.length <= maxChars) return line;
+    clipped += 1;
+    const keep = Math.floor(maxChars / 2);
+    return line.slice(0, keep) + ` ... [${line.length - maxChars} chars clipped] ... ` + line.slice(line.length - (maxChars - keep));
+  });
+  return clipped === 0 ? text : out.join("\n");
+}
+function clampKeepingEnds(text, maxBytes) {
+  const buf = Buffer.from(text, "utf8");
+  if (buf.length <= maxBytes) return null;
+  const lines = text.split("\n");
+  const budget = maxBytes - Buffer.byteLength(`... [${lines.length} more lines elided by token-goat]
+`, "utf8");
+  const half = Math.floor(budget / 2);
+  let headEnd = 0;
+  for (let used = 0; headEnd < lines.length; headEnd++) {
+    const n = Buffer.byteLength(lines[headEnd], "utf8") + 1;
+    if (used + n > half) break;
+    used += n;
+  }
+  let tailStart = lines.length;
+  for (let used = 0; tailStart > headEnd; tailStart--) {
+    const n = Buffer.byteLength(lines[tailStart - 1], "utf8") + 1;
+    if (used + n > half) break;
+    used += n;
+  }
+  if (headEnd === 0 && tailStart === lines.length) return buf.subarray(0, utf8SafeEnd(buf, maxBytes)).toString("utf8");
+  const elided = tailStart - headEnd;
+  return [
+    ...lines.slice(0, headEnd),
+    `... [${elided} more line${elided === 1 ? "" : "s"} elided by token-goat]`,
+    ...lines.slice(tailStart)
+  ].join("\n");
+}
+function compressionMarker(filter, pct) {
+  return `
+[token-goat: ${filter} filter -${Math.round(pct)}%; disable via TOKEN_GOAT_BASH_COMPRESS]`;
+}
+function combineStreams(stdout, stderr) {
+  if (stderr.trim() && stdout.trim()) return `${stdout.replace(/\s+$/, "")}
+---
+${stderr.replace(/\s+$/, "")}`;
+  return stdout.trim() ? stdout.replace(/\s+$/, "") : stderr.replace(/\s+$/, "");
+}
+var ERROR_SIGNAL_RE = /error:|Error:|ERROR|FAILED|failed|fatal:|Traceback|exception:|Exception:|AssertionError|assert |panic:/i;
+var TABLE_ROW_ANOMALY_RE = /\b(?:CrashLoopBackOff|ImagePullBackOff|ErrImagePull|CreateContainerError|CreateContainerConfigError|InvalidImageName|RunContainerError|OOMKilled|Evicted|Terminating|ContainerCreating|PodInitializing|NotReady|SchedulingDisabled|Unschedulable|Pending|Failed|Error|Unknown|Unhealthy|DEGRADED|UNAVAILABLE|STOPPED|STOPPING|TERMINATED|TERMINATING|FAILED|ROLLBACK_COMPLETE|ROLLBACK_FAILED|CREATE_FAILED|UPDATE_FAILED|DELETE_FAILED|pending-install|pending-upgrade|pending-rollback|uninstalling)\b|(?<![\w-])(?:failed|unknown)(?![\w-])/;
+var TIMESTAMP_PREFIX_RE = /^\[?\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?\]?\s*|^\d{2}:\d{2}:\d{2}(?:\.\d+)?\s+/;
+var REDIRECT_TOKEN_RE = /^(\d*)(>>?|<<?).*$|^&>$|^>&.*$/;
+function maskQuotedSpans(cmd) {
+  let out = "";
+  let i = 0;
+  const n = cmd.length;
+  while (i < n) {
+    const ch = cmd[i];
+    if (ch === "\\") {
+      out += i + 1 < n ? "xx" : "x";
+      i += 2;
+      continue;
+    }
+    if (ch === "'") {
+      i += 1;
+      const end = cmd.indexOf("'", i);
+      const stop = end === -1 ? n : end;
+      out += "x".repeat(stop - i);
+      i = end === -1 ? n : end + 1;
+      continue;
+    }
+    if (ch === '"') {
+      i += 1;
+      const start = i;
+      while (i < n && cmd[i] !== '"') {
+        i += cmd[i] === "\\" && i + 1 < n ? 2 : 1;
+      }
+      out += "x".repeat(i - start);
+      if (i < n) i += 1;
+      continue;
+    }
+    out += ch;
+    i += 1;
+  }
+  return out;
+}
+function hasBareBackgroundOrNewline(cmd) {
+  if (cmd.includes("\n") || cmd.includes("\r")) return true;
+  const masked = maskQuotedSpans(cmd);
+  for (let i = 0; i < masked.length; i++) {
+    if (masked[i] !== "&") continue;
+    if (masked[i + 1] === "&") {
+      i++;
+      continue;
+    }
+    if (masked[i - 1] === "&") continue;
+    if (isRedirectAmpersand(masked, i)) continue;
+    return true;
+  }
+  return false;
+}
+function isRedirectAmpersand(cmd, index) {
+  const before = cmd[index - 1];
+  return before === "<" || before === ">" || cmd[index + 1] === ">";
+}
+function hasUnquotedOperator(cmd, ops) {
+  const masked = maskQuotedSpans(cmd);
+  return ops.some((op) => masked.includes(op));
+}
+var BYTES_ELIDED_MARKER_RE = /\n\.\.\. \[\d+ bytes elided by token-goat\]$/;
+var OWN_TRAILING_NOTICE_RE = /(?:\n(?:\[token-goat: output capped at ~\d+ tokens\]|\.\.\. \[\d+ bytes elided by token-goat\]))+$/;
+function splitOwnTrailingNotices(text) {
+  const m = OWN_TRAILING_NOTICE_RE.exec(text);
+  return m ? { body: text.slice(0, m.index), notices: m[0] } : { body: text, notices: "" };
+}
+var DIGITS_RE = /\d+/g;
+var CONTROL_CHAR_RE = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g;
+function utf8Len(s) {
+  return Buffer.byteLength(s, "utf8");
+}
+function safeDecode(text) {
+  return text.indexOf("\0") === -1 ? text : text.split("\0").join("");
+}
+function sanitizeControlChars(text) {
+  return text.replace(CONTROL_CHAR_RE, "");
+}
+function stripProgress(text) {
+  if (!text.includes("\r")) return text;
+  return text.split("\n").map((line) => {
+    const trimmed = line.endsWith("\r") ? line.slice(0, -1) : line;
+    return trimmed.includes("\r") ? trimmed.slice(trimmed.lastIndexOf("\r") + 1) : trimmed;
+  }).join("\n");
+}
+function normalise(text, opts = {}) {
+  if (!text) return "";
+  let t = text.replace(/\r\n/g, "\n");
+  if (!opts.skipProgress) t = stripProgress(t);
+  t = stripAnsiEscapes(t);
+  return sanitizeControlChars(t);
+}
+var UUID_RE = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i;
+var LONG_HEX_RE = /\b[0-9a-f]{32,}\b/i;
+var JWT_RE = /\b[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/;
+function hasHighEntropyToken(line) {
+  if (UUID_RE.test(line) || LONG_HEX_RE.test(line) || JWT_RE.test(line)) return true;
+  for (const tok of line.split(/[\s"'`,;:()[\]{}<>]+/)) {
+    if (tok.length < 24) continue;
+    if (/[a-z]/.test(tok) && /[A-Z]/.test(tok) && /[0-9]/.test(tok) && /^[A-Za-z0-9+/=_-]+$/.test(tok)) {
+      return true;
+    }
+  }
+  return false;
+}
+function dedupeConsecutive(lines, opts = {}) {
+  const minRun = opts.minRun ?? 2;
+  const fmt = opts.fmt ?? ((line, count2) => `${line}  (\xD7${count2})`);
+  const entropyBypass = opts.entropyBypass ?? false;
+  const out = [];
+  let prev = null;
+  let count = 0;
+  const flush = () => {
+    if (prev === null) return;
+    if (count >= minRun) out.push(fmt(prev, count));
+    else for (let i = 0; i < count; i++) out.push(prev);
+  };
+  for (const line of lines) {
+    if (entropyBypass && hasHighEntropyToken(line)) {
+      flush();
+      prev = null;
+      count = 0;
+      out.push(line);
+      continue;
+    }
+    if (line === prev) {
+      count += 1;
+      continue;
+    }
+    flush();
+    prev = line;
+    count = 1;
+  }
+  flush();
+  return out;
+}
+function dedupeNumericRuns(lines, opts = {}) {
+  const minRun = opts.minRun ?? 2;
+  const arr = Array.from(lines);
+  const out = [];
+  let i = 0;
+  while (i < arr.length) {
+    const key = arr[i].replace(DIGITS_RE, "#");
+    let j = i + 1;
+    while (j < arr.length && arr[j].replace(DIGITS_RE, "#") === key) j += 1;
+    const run = j - i;
+    if (run >= minRun) {
+      out.push(arr[i]);
+      out.push(`... [${run - 1} similar lines collapsed by token-goat]`);
+    } else {
+      for (let k = i; k < j; k++) out.push(arr[k]);
+    }
+    i = j;
+  }
+  return out;
+}
+function truncateMiddle(lines, maxLines, opts = {}) {
+  if (lines.length <= maxLines) return lines;
+  const headRatio = opts.headRatio ?? 0.4;
+  const markerFmt = opts.markerFmt ?? ((n) => `... [${n} lines elided by token-goat]`);
+  const headKeep = Math.max(1, Math.floor(maxLines * headRatio));
+  const tailKeep = Math.max(1, maxLines - headKeep);
+  const elided = lines.length - headKeep - tailKeep;
+  return [...lines.slice(0, headKeep), markerFmt(elided), ...lines.slice(lines.length - tailKeep)];
+}
+function truncateMiddleSmart(lines, maxLines, opts = {}) {
+  if (lines.length <= maxLines) return lines;
+  const headKeep = opts.headKeep ?? 10;
+  const tailKeep = opts.tailKeep ?? 10;
+  const errorContext = opts.errorContext ?? 2;
+  const maxErrorLines = opts.maxErrorLines ?? 10;
+  const markerFmt = opts.markerFmt ?? ((n) => `--- ${n} lines omitted ---`);
+  const errorIndices = [];
+  for (let i = 0; i < lines.length; i++) if (ERROR_SIGNAL_RE.test(lines[i])) errorIndices.push(i);
+  if (errorIndices.length === 0) return truncateMiddle(lines, maxLines, { markerFmt });
+  const total = lines.length;
+  const effHead = Math.min(headKeep, Math.floor(total / 4));
+  const effTail = Math.min(tailKeep, Math.floor(total / 4));
+  const chosenErrors = errorIndices.length <= maxErrorLines ? errorIndices : [
+    ...errorIndices.slice(0, Math.ceil(maxErrorLines / 2)),
+    ...errorIndices.slice(errorIndices.length - Math.floor(maxErrorLines / 2))
+  ];
+  const budgetForMiddle = Math.max(0, maxLines - effHead - effTail);
+  const half = Math.ceil(chosenErrors.length / 2);
+  const front = chosenErrors.slice(0, half);
+  const back = chosenErrors.slice(half).reverse();
+  const visitOrder = [];
+  for (let k = 0; k < Math.max(front.length, back.length); k++) {
+    if (k < front.length) visitOrder.push(front[k]);
+    if (k < back.length) visitOrder.push(back[k]);
+  }
+  const middle = /* @__PURE__ */ new Set();
+  outer: for (const ei of visitOrder) {
+    for (let ci = Math.max(0, ei - errorContext); ci < Math.min(total, ei + errorContext + 1); ci++) {
+      if (ci < effHead || ci >= total - effTail) continue;
+      if (middle.size >= budgetForMiddle) break outer;
+      middle.add(ci);
+    }
+  }
+  const sortedMiddle = Array.from(middle).sort((a, b) => a - b);
+  const result = [];
+  const appendSection = (indices) => {
+    for (let pos = 0; pos < indices.length; pos++) {
+      const idx = indices[pos];
+      if (pos > 0) {
+        const prevIdx = indices[pos - 1];
+        if (idx !== prevIdx + 1) result.push(markerFmt(idx - prevIdx - 1));
+      }
+      result.push(lines[idx]);
+    }
+  };
+  const headList = Array.from({ length: effHead }, (_, i) => i);
+  const tailList = Array.from({ length: effTail }, (_, i) => total - effTail + i);
+  appendSection(headList);
+  if (sortedMiddle.length) {
+    const gapAfterHead = sortedMiddle[0] - (headList.length ? headList[headList.length - 1] : -1) - 1;
+    if (gapAfterHead > 0) result.push(markerFmt(gapAfterHead));
+    appendSection(sortedMiddle);
+  }
+  if (tailList.length) {
+    const lastKept = sortedMiddle.length ? sortedMiddle[sortedMiddle.length - 1] : headList.length ? headList[headList.length - 1] : -1;
+    const gapBeforeTail = tailList[0] - lastKept - 1;
+    if (gapBeforeTail > 0) result.push(markerFmt(gapBeforeTail));
+    appendSection(tailList);
+  }
+  return result;
+}
+function capBytes(text, maxBytes) {
+  const encoded = Buffer.from(text, "utf8");
+  if (encoded.length <= maxBytes) return text;
+  const widestMarker = `
+... [${encoded.length} bytes elided by token-goat]`;
+  const budget = maxBytes - Buffer.byteLength(widestMarker, "utf8");
+  if (budget <= 0) return widestMarker.trim();
+  const kept = clampKeepingEnds(text, budget) ?? text;
+  return `${kept}
+... [${encoded.length - Buffer.byteLength(kept, "utf8")} bytes elided by token-goat]`;
+}
+function capTokens(text, maxTokens) {
+  const clean = stripAnsiEscapes(text);
+  if (clean.length / 3.5 <= maxTokens) return text;
+  const maxBytes = Math.floor(maxTokens * 3.5);
+  let truncated = clampKeepingEnds(clean, maxBytes) ?? clean;
+  if (!truncated.includes("[token-goat: output capped at")) {
+    truncated = truncated.replace(BYTES_ELIDED_MARKER_RE, "");
+    truncated += `
+[token-goat: output capped at ~${maxTokens} tokens]`;
+  }
+  return truncated;
+}
+function headTailCompress(lines, head, tail, label = "items") {
+  const total = lines.length;
+  if (total <= head + tail) return lines.join("\n");
+  const elided = total - head - tail;
+  return [...lines.slice(0, head), `... [${elided} more ${label} elided by token-goat]`, ...lines.slice(total - tail)].join(
+    "\n"
+  );
+}
+function truncateTableRows(text, maxRows, hint) {
+  const lines = text.split("\n");
+  const nonEmpty = lines.filter((l) => l.trim());
+  if (nonEmpty.length <= maxRows + 1) return text;
+  const header = nonEmpty[0];
+  const rows = nonEmpty.slice(1);
+  const wanted = /* @__PURE__ */ new Set();
+  for (let i = 0; i < rows.length && wanted.size < maxRows; i++) {
+    if (TABLE_ROW_ANOMALY_RE.test(rows[i])) wanted.add(i);
+  }
+  const anomalies = wanted.size;
+  for (let i = 0; i < rows.length && wanted.size < maxRows; i++) wanted.add(i);
+  const kept = [...wanted].sort((a, b) => a - b);
+  const elided = rows.length - kept.length;
+  const note = anomalies ? `[token-goat: ${elided} more rows; ${anomalies} row(s) kept for a not-ready status, the rest from the top; ${hint}]` : `[token-goat: ${elided} more rows; ${hint}]`;
+  return `${[header, ...kept.map((i) => rows[i])].join("\n")}
+${note}`;
+}
+function trimRepeatedPrefix(lines, pattern, keep) {
+  const out = [];
+  let matched = 0;
+  let dropped = 0;
+  for (const line of lines) {
+    if (pattern.test(line)) {
+      matched += 1;
+      if (matched <= keep) out.push(line);
+      else dropped += 1;
+    } else {
+      out.push(line);
+    }
+  }
+  if (dropped) out.push(`[token-goat: +${dropped} more lines matching ${pattern.source}]`);
+  return out;
+}
+function stripTimestamps(lines) {
+  return lines.map((ln) => ln.replace(TIMESTAMP_PREFIX_RE, ""));
+}
+function splitBlocks(text, blockRe) {
+  const blocks = [];
+  let current = [];
+  for (const line of text.split("\n")) {
+    if (blockRe.test(line)) {
+      if (current.length) blocks.push(current.join("\n"));
+      current = [line];
+    } else {
+      current.push(line);
+    }
+  }
+  if (current.length) blocks.push(current.join("\n"));
+  return blocks;
+}
+function maybeNote(notes, value, msg) {
+  if (value) notes.push(msg);
+}
+function squeezeBlankLines(text) {
+  return text.replace(/\n\s*\n\s*\n+/g, "\n\n");
+}
+function preserveStderrOnError(stdout, stderr, exitCode) {
+  if (exitCode !== 0 && stderr.trim()) {
+    return stdout.trim() ? `${stdout.replace(/\s+$/, "")}
+---
+${stderr.replace(/\s+$/, "")}` : stderr;
+  }
+  return null;
+}
+var PASSTHROUGH_PREFIXES = /* @__PURE__ */ new Set([
+  "sudo",
+  "doas",
+  "time",
+  "nice",
+  "ionice",
+  "nohup",
+  "exec",
+  "env",
+  "stdbuf",
+  "unbuffer",
+  "script"
+]);
+var TWO_TOKEN_PREFIXES = {
+  python: /* @__PURE__ */ new Set(["-m"]),
+  python3: /* @__PURE__ */ new Set(["-m"]),
+  py: /* @__PURE__ */ new Set(["-m"]),
+  // `tool` is deliberately absent: `uv tool install/upgrade/uninstall/update <bin>`
+  // produces uv's own package-management output (handled by UvFilter.matches()'s
+  // own `tool` branch on the unstripped argv) -- it must not be consumed here.
+  // `uv tool run <bin>` is the one `tool` subcommand that really does execute
+  // `<bin>` and stream its output; it gets a dedicated 3-token strip below.
+  uv: /* @__PURE__ */ new Set(["run"]),
+  uvx: /* @__PURE__ */ new Set(),
+  poetry: /* @__PURE__ */ new Set(["run"]),
+  rye: /* @__PURE__ */ new Set(["run"]),
+  pdm: /* @__PURE__ */ new Set(["run"]),
+  pipenv: /* @__PURE__ */ new Set(["run"]),
+  npx: /* @__PURE__ */ new Set(),
+  pnpm: /* @__PURE__ */ new Set(["exec", "dlx"]),
+  yarn: /* @__PURE__ */ new Set(["exec", "dlx"]),
+  bundle: /* @__PURE__ */ new Set(["exec"]),
+  hatch: /* @__PURE__ */ new Set(["run"])
+  // `tox` is deliberately absent: `tox -e py312`'s `-e py312` is an environment
+  // selector, not a launcher token, so argv[2] (`py312`) is never a real binary.
+  // ToxFilter matches on the unstripped `tox` stem directly (see misc.ts).
+};
+function pathName(p) {
+  const norm = p.replace(/\\/g, "/");
+  const idx = norm.lastIndexOf("/");
+  return idx >= 0 ? norm.slice(idx + 1) : norm;
+}
+function pathStem(p) {
+  const name = pathName(p);
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(0, dot) : name;
+}
+function positionalArgs(args, valueFlags) {
+  const out = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a.startsWith("-")) {
+      if (valueFlags?.has(a) === true && i + 1 < args.length) i++;
+      continue;
+    }
+    out.push(a);
+  }
+  return out;
+}
+var SHORT_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set(["-n", "-c", "-u", "-e"]);
+function stripPrefixes(argv) {
+  if (argv.length === 0) return [];
+  let out = [...argv];
+  for (; ; ) {
+    const before = out.length;
+    while (out.length && out[0].includes("=") && !out[0].startsWith("-")) {
+      const head = out[0].split("=", 1)[0];
+      if (head && (/[A-Za-z]/.test(head[0]) || head[0] === "_") && /^[A-Za-z0-9_]+$/.test(head)) out.shift();
+      else break;
+    }
+    while (out.length) {
+      if (!PASSTHROUGH_PREFIXES.has(pathStem(out[0]).toLowerCase())) break;
+      out.shift();
+      while (out.length && out[0].startsWith("-")) {
+        const flag = out.shift();
+        if (SHORT_FLAGS_WITH_VALUE.has(flag) && out.length) out.shift();
+      }
+    }
+    if (out.length === before) break;
+  }
+  if (out.length === 0) return out;
+  if (pathStem(out[0]).toLowerCase() === "uv" && out[1] === "tool" && out[2] === "run" && out.length > 3) {
+    return skipLauncherOptions(out.slice(3));
+  }
+  const stem = pathStem(out[0]).toLowerCase();
+  const triggers = TWO_TOKEN_PREFIXES[stem];
+  if (triggers !== void 0 && out.length >= 2) {
+    const nextTok = out[1];
+    if (triggers.size === 0 || triggers.has(nextTok)) {
+      const consume = triggers.size === 0 ? 1 : 2;
+      if (out.length > consume) out = skipLauncherOptions(out.slice(consume));
+    }
+  }
+  return out;
+}
+var LAUNCHER_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "-p",
+  "--package",
+  "-c",
+  "--call",
+  "--userconfig",
+  "--cache",
+  "--shell",
+  "--node-arg",
+  "--npm",
+  "--with",
+  "--with-requirements",
+  "--with-editable",
+  "--python",
+  "--directory",
+  "--project",
+  "--extra",
+  "--group",
+  "--index-url",
+  "--index",
+  "--find-links",
+  "--constraint",
+  "--override",
+  "--filter",
+  "--dir",
+  "--workspace-root",
+  "--shell-mode"
+]);
+function skipLauncherOptions(args) {
+  let i = 0;
+  while (i < args.length && args[i].startsWith("-") && args[i] !== "--") {
+    const flag = args[i];
+    i++;
+    if (LAUNCHER_VALUE_FLAGS.has(flag) && i < args.length) i++;
+  }
+  if (i < args.length && args[i] === "--") i++;
+  return i < args.length ? args.slice(i) : args;
+}
+var PACKAGE_MANAGER_SCRIPT_STEMS = /* @__PURE__ */ new Set(["npm", "pnpm", "yarn", "bun"]);
+var MAX_SCRIPT_RESOLUTION_DEPTH = 5;
+var COMPOUND_SCRIPT_RE = /&&|\|\||[|;]|`|\$\(/;
+var packageJsonScriptsCache = /* @__PURE__ */ new Map();
+function loadPackageScripts(candidate, stat) {
+  const cached = packageJsonScriptsCache.get(candidate);
+  if (cached && cached.mtimeMs === stat.mtimeMs) return cached.scripts;
+  let scripts = {};
+  try {
+    const parsed = JSON.parse(fs.readFileSync(candidate, "utf8"));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const raw = parsed["scripts"];
+      if (raw && typeof raw === "object" && !Array.isArray(raw)) scripts = raw;
+    }
+  } catch {
+  }
+  packageJsonScriptsCache.set(candidate, { mtimeMs: stat.mtimeMs, scripts });
+  return scripts;
+}
+function findNearestPackageScripts(startDir) {
+  let dir = startDir;
+  for (; ; ) {
+    const candidate = path.join(dir, "package.json");
+    try {
+      const stat = fs.statSync(candidate);
+      if (stat.isFile()) return loadPackageScripts(candidate, stat);
+    } catch {
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+var YARN_BUILTIN_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "access",
+  "add",
+  "audit",
+  "autoclean",
+  "bin",
+  "cache",
+  "check",
+  "config",
+  "create",
+  "dedupe",
+  "dlx",
+  "exec",
+  "explain",
+  "generate-lock-entry",
+  "global",
+  "help",
+  "import",
+  "info",
+  "init",
+  "install",
+  "licenses",
+  "link",
+  "list",
+  "login",
+  "logout",
+  "node",
+  "npm",
+  "outdated",
+  "owner",
+  "pack",
+  "patch",
+  "plugin",
+  "policies",
+  "rebuild",
+  "remove",
+  "set",
+  "stage",
+  "tag",
+  "team",
+  "unlink",
+  "unplug",
+  "up",
+  "upgrade",
+  "upgrade-interactive",
+  "version",
+  "versions",
+  "why",
+  "workspace",
+  "workspaces"
+]);
+function scriptNameFromArgs(stem, args) {
+  const [a0, a1] = args;
+  if (a0 === void 0) return null;
+  switch (stem) {
+    case "npm":
+    case "pnpm":
+      if (a0 === "test" || a0 === "t") return "test";
+      if ((a0 === "run" || a0 === "run-script") && a1 !== void 0) return a1;
+      return null;
+    case "bun":
+      if (a0 === "run" && a1 !== void 0) return a1;
+      return null;
+    case "yarn":
+      if (a0 === "run" && a1 !== void 0) return a1;
+      if (!a0.startsWith("-") && !YARN_BUILTIN_SUBCOMMANDS.has(a0)) return a0;
+      return null;
+    default:
+      return null;
+  }
+}
+function resolvePackageManagerScript(argv, cwd) {
+  try {
+    let current = argv;
+    let resolvedAny = false;
+    for (let depth = 0; depth < MAX_SCRIPT_RESOLUTION_DEPTH; depth++) {
+      if (current.length === 0) break;
+      const stem = pathStem(current[0]).toLowerCase();
+      if (!PACKAGE_MANAGER_SCRIPT_STEMS.has(stem)) break;
+      const scriptName = scriptNameFromArgs(stem, current.slice(1));
+      if (scriptName === null) break;
+      const scripts = findNearestPackageScripts(cwd);
+      if (scripts === null) break;
+      const scriptCmd = scripts[scriptName];
+      if (typeof scriptCmd !== "string" || !scriptCmd.trim()) break;
+      if (COMPOUND_SCRIPT_RE.test(scriptCmd)) break;
+      let nextArgv;
+      try {
+        nextArgv = shlexSplit(scriptCmd);
+      } catch {
+        break;
+      }
+      if (nextArgv.length === 0) break;
+      current = nextArgv;
+      resolvedAny = true;
+    }
+    return resolvedAny ? current : null;
+  } catch {
+    return null;
+  }
+}
+function shlexSplit(cmd) {
+  const tokens = [];
+  let cur = "";
+  let has = false;
+  let i = 0;
+  const n = cmd.length;
+  while (i < n) {
+    const ch = cmd[i];
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+      if (has) {
+        tokens.push(cur);
+        cur = "";
+        has = false;
+      }
+      i += 1;
+      continue;
+    }
+    has = true;
+    if (ch === "\\") {
+      if (i + 1 < n) {
+        cur += cmd[i + 1];
+        i += 2;
+      } else {
+        i += 1;
+      }
+      continue;
+    }
+    if (ch === "'") {
+      i += 1;
+      const end = cmd.indexOf("'", i);
+      if (end === -1) throw new Error("No closing quotation");
+      cur += cmd.slice(i, end);
+      i = end + 1;
+      continue;
+    }
+    if (ch === '"') {
+      i += 1;
+      let buf = "";
+      while (i < n && cmd[i] !== '"') {
+        if (cmd[i] === "\\" && i + 1 < n && (cmd[i + 1] === '"' || cmd[i + 1] === "\\")) {
+          buf += cmd[i + 1];
+          i += 2;
+        } else {
+          buf += cmd[i];
+          i += 1;
+        }
+      }
+      if (i >= n) throw new Error("No closing quotation");
+      cur += buf;
+      i += 1;
+      continue;
+    }
+    cur += ch;
+    i += 1;
+  }
+  if (has) tokens.push(cur);
+  return tokens;
+}
+function capLongLines(lines, maxChars = FALLBACK_MAX_LINE_CHARS) {
+  return lines.map((line) => {
+    if (line.length <= maxChars) return line;
+    if (ELIDED_MARKER_RE.test(line)) return line;
+    const priorClip = CLIPPED_MARKER_RE.exec(line);
+    let cut = maxChars;
+    const high = line.charCodeAt(cut - 1);
+    const low = line.charCodeAt(cut);
+    if (high >= 55296 && high <= 56319 && low >= 56320 && low <= 57343) cut -= 1;
+    const carried = priorClip !== null && priorClip.index >= cut ? Number(priorClip[1]) - priorClip[0].length : 0;
+    return `${line.slice(0, cut)}  \u2026 [${line.length - cut + carried} chars elided]`;
+  });
+}
+var GREP_MAX_LINE_CHARS = 1e3;
+var _GREP_PREFIX_BUDGET = 160;
+var _GREP_LINE_PREFIX_RE = /^(?:(?:[A-Za-z]:)?[^:\n]{0,200}?[:-]\d+[:-]|\d+[:-])/;
+var _GREP_BAIL_SHORT = /* @__PURE__ */ new Set(["e", "f", "i", "v", "y", "z", "S", "U"]);
+var _GREP_BAIL_LONG = /* @__PURE__ */ new Set([
+  "--regexp",
+  "--file",
+  "--ignore-case",
+  "--invert-match",
+  "--null-data",
+  "--smart-case",
+  "--multiline"
+]);
+var _GREP_VALUE_SHORT = /* @__PURE__ */ new Set(["A", "B", "C", "m", "d", "D"]);
+var _GREP_RG_VALUE_SHORT = /* @__PURE__ */ new Set(["g", "t", "T", "M", "j", "r"]);
+var _GREP_VALUE_LONG = /* @__PURE__ */ new Set([
+  "--max-count",
+  "--context",
+  "--after-context",
+  "--before-context",
+  "--include",
+  "--exclude",
+  "--exclude-dir",
+  "--glob",
+  "--iglob",
+  "--type",
+  "--type-not",
+  "--binary-files",
+  "--devices",
+  "--directories",
+  "--color",
+  "--colour",
+  "--replace",
+  "--max-columns",
+  "--threads",
+  "--sort",
+  "--sortr",
+  "--pre",
+  "--engine"
+]);
+var _GREP_REGEX_META_RE = /[\\^$.|?*+()[\]{}]/;
+function grepLiteralPattern(argv) {
+  if (!argv.length) return null;
+  const stem = pathStem(argv[0] ?? "").toLowerCase();
+  let rest = argv.slice(1);
+  let isRg = stem === "rg";
+  if (stem === "git") {
+    const gi = rest.indexOf("grep");
+    if (gi < 0) return null;
+    rest = rest.slice(gi + 1);
+    isRg = false;
+  }
+  let fixed = false;
+  let endOfFlags = false;
+  let pattern = null;
+  for (let i = 0; i < rest.length; i++) {
+    const tok = rest[i];
+    if (!endOfFlags && tok === "--") {
+      endOfFlags = true;
+      continue;
+    }
+    if (!endOfFlags && tok.startsWith("--")) {
+      const eq = tok.indexOf("=");
+      const name = eq >= 0 ? tok.slice(0, eq) : tok;
+      if (_GREP_BAIL_LONG.has(name)) return null;
+      if (name === "--fixed-strings") fixed = true;
+      else if (eq < 0 && _GREP_VALUE_LONG.has(name)) i++;
+      continue;
+    }
+    if (!endOfFlags && tok.length > 1 && tok.startsWith("-")) {
+      const letters = tok.slice(1);
+      for (let k = 0; k < letters.length; k++) {
+        const ch = letters[k];
+        if (_GREP_BAIL_SHORT.has(ch)) return null;
+        if (ch === "F") fixed = true;
+        if (_GREP_VALUE_SHORT.has(ch) || isRg && _GREP_RG_VALUE_SHORT.has(ch)) {
+          if (k === letters.length - 1) i++;
+          break;
+        }
+      }
+      continue;
+    }
+    pattern = tok;
+    break;
+  }
+  if (pattern === null || pattern.length < 3 || pattern.includes("\n")) return null;
+  if (!fixed && _GREP_REGEX_META_RE.test(pattern)) return null;
+  return pattern;
+}
+function _safeCut(line, idx) {
+  if (idx <= 0 || idx >= line.length) return idx;
+  const high = line.charCodeAt(idx - 1);
+  const low = line.charCodeAt(idx);
+  return high >= 55296 && high <= 56319 && low >= 56320 && low <= 57343 ? idx - 1 : idx;
+}
+function clipLongMatchLine(line, pattern, maxChars = GREP_MAX_LINE_CHARS) {
+  if (line.length <= maxChars) return line;
+  const pm = _GREP_LINE_PREFIX_RE.exec(line);
+  const prefixEnd = pm && pm[0].length <= _GREP_PREFIX_BUDGET ? pm[0].length : 0;
+  let idx = line.indexOf(pattern, prefixEnd);
+  if (idx < 0) idx = line.indexOf(pattern);
+  if (idx < 0) return line;
+  const matchEnd = idx + pattern.length;
+  let clipped;
+  if (matchEnd <= maxChars) {
+    const cut = _safeCut(line, maxChars);
+    clipped = `${line.slice(0, cut)}  \u2026 [${line.length - cut} chars elided]`;
+  } else {
+    const budget = maxChars - prefixEnd;
+    if (budget < pattern.length + 40) return line;
+    let start = Math.max(prefixEnd, idx - Math.floor((budget - pattern.length) / 2));
+    let stop = start + budget;
+    if (stop > line.length) {
+      stop = line.length;
+      start = Math.max(prefixEnd, stop - budget);
+    }
+    start = _safeCut(line, start);
+    stop = _safeCut(line, stop);
+    if (start > idx || stop < matchEnd) return line;
+    const before = start - prefixEnd;
+    const after = line.length - stop;
+    clipped = line.slice(0, prefixEnd) + (before > 0 ? `\u2026 [${before} chars elided] \u2026` : "") + line.slice(start, stop) + (after > 0 ? `  \u2026 [${after} chars elided]` : "");
+  }
+  return clipped.length < line.length ? clipped : line;
+}
+function clipGrepLines(text, argv, maxChars = GREP_MAX_LINE_CHARS) {
+  if (text.length <= maxChars) return text;
+  const pattern = grepLiteralPattern(argv);
+  if (pattern === null) return text;
+  let changed = false;
+  const out = text.split("\n").map((line) => {
+    const clipped = clipLongMatchLine(line, pattern, maxChars);
+    if (clipped !== line) changed = true;
+    return clipped;
+  });
+  return changed ? out.join("\n") : text;
+}
+function fallbackTruncate(stdout, stderr, maxLines) {
+  const half = Math.floor(maxLines / 2);
+  const outLines = truncateMiddle(capLongLines(dedupeConsecutive(stdout.split("\n"))), half);
+  const errLines = truncateMiddle(capLongLines(dedupeConsecutive(stderr.split("\n"))), half);
+  if (stderr) return `${outLines.join("\n")}
+---
+${errLines.join("\n")}`;
+  return outLines.join("\n");
+}
+function compressBashOutput(stdout, stderr) {
+  let body = dedupeConsecutive(stdout.split("\n"), { entropyBypass: true }).join("\n");
+  if (stderr.trim()) {
+    const err = dedupeConsecutive(stderr.split("\n"), { entropyBypass: true }).join("\n");
+    body = `${body.replace(/\s+$/, "")}
+---
+${err.replace(/\s+$/, "")}`;
+  }
+  return body;
+}
+function dedupeCombinedOutput(text) {
+  return squeezeBlankLines(dedupeConsecutive(text.split("\n")).join("\n"));
+}
+function compressTestOutput(lines, maxLines = 300) {
+  const deduped = dedupeNumericRuns(lines, { minRun: 5 });
+  return truncateMiddle(deduped, maxLines).join("\n");
+}
+function byteLength(s) {
+  return utf8Len(s);
+}
+
+// src/bash_output_cache.ts
+init_define_import_meta_env();
+import { readdirSync, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
+import { resolve } from "path";
+
+// src/hints/lang_patterns.ts
+init_define_import_meta_env();
+var LOCK_FILE_NAMES = /* @__PURE__ */ new Set([
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "cargo.lock",
+  "poetry.lock",
+  "pipfile.lock",
+  "uv.lock",
+  "gemfile.lock",
+  "go.sum",
+  "composer.lock",
+  "mix.lock",
+  "pubspec.lock",
+  "package.resolved"
+]);
+var MANIFEST_FILE_NAMES = /* @__PURE__ */ new Set([
+  "package.json",
+  "pyproject.toml",
+  "cargo.toml",
+  "go.mod",
+  "go.work",
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  "settings.gradle",
+  "composer.json",
+  "gemfile",
+  "mix.exs",
+  "pubspec.yaml",
+  "cmakelists.txt",
+  "makefile",
+  "project.clj",
+  // TypeScript / JavaScript project configs
+  "tsconfig.json",
+  "jsconfig.json",
+  // Bundler / framework configs
+  "vite.config.ts",
+  "vite.config.js",
+  "webpack.config.js",
+  "webpack.config.ts",
+  "rollup.config.js",
+  "rollup.config.ts",
+  "esbuild.config.js",
+  "next.config.js",
+  "next.config.ts",
+  "nuxt.config.ts"
+]);
+var MANIFEST_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".cabal"
+]);
+var MANIFEST_BASENAME_PATTERNS = [
+  /^tsconfig(\..+)?\.json$/i
+];
+var BUILD_DIR_NAMES = /* @__PURE__ */ new Set([
+  "dist",
+  "target",
+  "build",
+  "out",
+  "__pycache__",
+  ".next",
+  ".nuxt",
+  ".output",
+  ".gradle",
+  "_build",
+  ".build",
+  "pkg",
+  "obj"
+]);
+var ALWAYS_GENERATED_EXTS = /* @__PURE__ */ new Set([
+  ".pyc",
+  ".pyo",
+  ".pyd",
+  ".class",
+  ".o",
+  ".a",
+  ".so",
+  ".dylib",
+  ".dll",
+  ".tsbuildinfo"
+]);
+var CONDITIONALLY_GENERATED_EXTS = /* @__PURE__ */ new Set([
+  ".map",
+  ".d.ts"
+]);
+var BUILD_COMMAND_PATTERNS = [
+  // Rust / Cargo
+  /^\s*cargo\s+(build|test|run|check|clippy)\b/i,
+  // Go
+  /^\s*go\s+(build|test|run|vet)\b/i,
+  // Maven
+  /^\s*mvn\b/i,
+  // Gradle (direct or wrapper)
+  /^\s*(?:gradle|\.\/gradlew|gradlew)\b/i,
+  // Python / pip
+  /^\s*pip\s+(install|freeze)\b/i,
+  // npm audit / npm outdated — read-only reporting commands with no side effects, safe to cache/recall. Each resolves a `lockfile`-scoped fingerprint via bash_output_cache.ts's isNpmAuditCommand/isNpmOutdatedCommand, but that fingerprinting never actually ran outside their own unit tests until this entry, since neither subcommand was recognized by isBuildCommand (the generic cache-reachability gate in hooks_bash.ts). `npm install`/`npm ci`/`npm list`/`npm ls` are deliberately left out — see the negative-case test in lang_patterns.test.ts.
+  /^\s*npm\s+(audit|outdated)\b/i,
+  // Poetry
+  /^\s*poetry\s+(install|update)\b/i,
+  // uv
+  /^\s*uv\s+(sync|pip\s+install)\b/i,
+  // Bundler (Ruby)
+  /^\s*bundle\s+(install|update)\b/i,
+  // Mix (Elixir)
+  /^\s*mix\s+(deps\.get|compile|test)\b/i,
+  // dotnet
+  /^\s*dotnet\s+(build|test|restore)\b/i,
+  // Make
+  /^\s*make\b/i,
+  // CMake build
+  /^\s*cmake\s+--build\b/i,
+  // Rake (Ruby)
+  /^\s*rake\b/i,
+  // TypeScript compiler (direct and via npx)
+  /^\s*tsc(?:\s|$)/i,
+  /^\s*npx\s+tsc(?:\s|$)/i,
+  // Vite
+  /^\s*vite\s+(build|dev|preview)\b/i,
+  // Next.js
+  /^\s*next\s+(build|dev|start)\b/i,
+  // Nuxt
+  /^\s*nuxt\s+(build|dev)\b/i,
+  // Webpack
+  /^\s*webpack\b/i,
+  // esbuild
+  /^\s*esbuild\b/i,
+  // Rollup
+  /^\s*rollup\b/i,
+  // Turbo
+  /^\s*turbo\s+(build|dev)\b/i
+];
+var LOCK_FILE_COUNT = LOCK_FILE_NAMES.size;
+var MANIFEST_FILE_COUNT = MANIFEST_FILE_NAMES.size + MANIFEST_EXTENSIONS.size + MANIFEST_BASENAME_PATTERNS.length;
+var BUILD_DIR_COUNT = BUILD_DIR_NAMES.size;
+var GENERATED_EXT_COUNT = ALWAYS_GENERATED_EXTS.size + CONDITIONALLY_GENERATED_EXTS.size;
+function isLockFile(basename) {
+  return LOCK_FILE_NAMES.has(basename.toLowerCase());
+}
+function isManifestFile(basename) {
+  const lower = basename.toLowerCase();
+  if (MANIFEST_FILE_NAMES.has(lower)) return true;
+  const dot = lower.lastIndexOf(".");
+  if (dot !== -1 && MANIFEST_EXTENSIONS.has(lower.slice(dot))) return true;
+  if (MANIFEST_BASENAME_PATTERNS.some((re) => re.test(basename))) return true;
+  return false;
+}
+function pathSegments(filePath) {
+  return filePath.split(/[/\\]/).filter((s) => s.length > 0);
+}
+function isInBuildDir(filePath) {
+  const segments = pathSegments(filePath);
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i];
+    if (seg !== void 0 && BUILD_DIR_NAMES.has(seg.toLowerCase())) return true;
+  }
+  return false;
+}
+function isGeneratedFile(filePath) {
+  const lower = filePath.toLowerCase();
+  for (const ext of ALWAYS_GENERATED_EXTS) {
+    if (lower.endsWith(ext)) return true;
+  }
+  for (const ext of CONDITIONALLY_GENERATED_EXTS) {
+    if (lower.endsWith(ext) && isInBuildDir(filePath)) return true;
+  }
+  return false;
+}
+function isBuildCommand(cmd) {
+  return BUILD_COMMAND_PATTERNS.some((re) => re.test(cmd));
+}
+var TEST_RUNNER_COMMAND_PATTERNS = [
+  // pytest (Python)
+  /^pytest(?:\s|$)/i,
+  // Jest / Vitest (direct or via npx)
+  /^(?:npx\s+)?jest(?:\s|$)/i,
+  /^(?:npx\s+)?vitest(?:\s+run|\s+watch)?(?:\s|$)/i,
+  // Go
+  /^go test(?:\s|$)/i,
+  // Rust / Cargo
+  /^cargo test(?:\s|$)/i,
+  // npm test / npm run test
+  /^npm (?:test|run test)(?:\s|$)/i,
+  // yarn test / yarn run test / pnpm test / pnpm run test
+  /^(?:yarn|pnpm)(?:\s+run)? test(?:\s|$)/i
+];
+function isTestRunnerCommand(cmd) {
+  return TEST_RUNNER_COMMAND_PATTERNS.some((re) => re.test(cmd));
+}
+var MONITORING_COMMAND_PATTERNS = [
+  // GitHub CI
+  { pattern: /^gh run (?:watch|view|list)/, recallHint: '--grep "fail|error|pass|\u2713|\u2717|conclusion"' },
+  { pattern: /^gh run view.*--log/, recallHint: '--tail 100 --grep "Error|FAIL|error"' },
+  { pattern: /^gh pr checks/, recallHint: '--grep "fail|error|pass|pending"' },
+  { pattern: /^gh pr view/, recallHint: '--grep "state|title|mergeable|review|OPEN|CLOSED|MERGED"' },
+  { pattern: /^gh pr list/, recallHint: '--grep "OPEN|DRAFT|MERGED|#"' },
+  { pattern: /^gh issue view/, recallHint: '--grep "state|title|label|OPEN|CLOSED"' },
+  { pattern: /^gh workflow (?:run|list|view)/, recallHint: '--grep "completed|failed|in_progress"' },
+  // Dev servers (Next, Vite, Nuxt, Remix, Astro)
+  { pattern: /^(?:npx\s+)?next dev/, recallHint: '--tail 30 --grep "error|warn|ready|compiled"' },
+  { pattern: /^(?:npx\s+)?next build/, recallHint: '--grep "error|warn|Failed|\u2713"' },
+  { pattern: /^(?:npx\s+)?vite\b(?:\s+dev|\s+build|\s+preview)?/, recallHint: '--tail 20 --grep "error|warn|ready"' },
+  { pattern: /^(?:npx\s+)?nuxt dev/, recallHint: '--tail 30 --grep "error|warn|ready"' },
+  { pattern: /^(?:npx\s+)?remix dev/, recallHint: '--tail 20 --grep "error|warn|ready"' },
+  { pattern: /^(?:npx\s+)?astro dev/, recallHint: '--tail 20 --grep "error|warn|ready"' },
+  // Test watchers
+  { pattern: /^(?:npx\s+)?vitest(?:\s+run|\s+watch)?/, recallHint: '--grep "FAIL|PASS|Error|\u2713|\u2717"' },
+  { pattern: /^(?:npx\s+)?jest(?:\s+--watch)?/, recallHint: '--grep "FAIL|PASS|Error|Tests:"' },
+  { pattern: /^pytest(?:\s|$)/, recallHint: '--grep "FAILED|PASSED|ERROR|passed|failed"' },
+  { pattern: /^(?:cargo\s+test|cargo\s+watch)/, recallHint: '--grep "FAILED|ok|error\\["' },
+  { pattern: /^go test/, recallHint: '--grep "FAIL|ok|---"' },
+  // Docker / compose
+  { pattern: /^docker(?:\s+compose)?\s+logs/, recallHint: '--tail 50 --grep "error|warn|Error|WARN"' },
+  { pattern: /^docker-compose\s+logs/, recallHint: '--tail 50 --grep "error|warn|Error|WARN"' },
+  // File watchers / hot-reload
+  { pattern: /^nodemon/, recallHint: '--tail 20 --grep "error|crash|restart"' },
+  { pattern: /^air(?:\s|$)/, recallHint: '--tail 20 --grep "error|build failed"' },
+  { pattern: /^cargo watch/, recallHint: '--tail 20 --grep "error\\[|warning\\["' },
+  { pattern: /^watchexec/, recallHint: '--tail 20 --grep "error|warn"' },
+  // Linters / formatters run repeatedly
+  { pattern: /^(?:npx\s+)?eslint(?:\s|$)/, recallHint: '--grep "error|warning|\u2716|problems"' },
+  { pattern: /^(?:npx\s+)?prettier(?:\s|$)/, recallHint: '--grep "unchanged|reformatted|error"' },
+  { pattern: /^npx\s+tsc(?:\s|$)/, recallHint: '--grep "error TS|Cannot find|Type "' },
+  { pattern: /^ruff(?:\s|$)/, recallHint: '--grep "error|warning|Found"' },
+  { pattern: /^(?:cargo\s+)?clippy/, recallHint: '--grep "error\\[|warning\\["' },
+  // git diff (full diff output — can be very large; excludes --stat which is small)
+  { pattern: /^git diff(?!\s+--stat)(?:\s+HEAD)?(?:\s|$)/, recallHint: '--grep "@@|\\+\\+\\+|---|diff --git"' },
+  { pattern: /^git diff\s+--cached(?!\s+--stat)/, recallHint: '--grep "@@|\\+\\+\\+|---|diff --git"' },
+  // git push — output is dominated by the pre-push hook (full test suite, often 10K+); cache it so failures/rejections are recallable without re-pushing
+  { pattern: /^git push(?:\s|$)/, recallHint: '--tail 100 --grep "error|fail|FAIL|rejected|To "' },
+  // npm run * wrappers (npm test is excluded — too generic; npm run test is explicit)
+  { pattern: /^npm run (?:test|spec)(?:\s|$)/, recallHint: '--grep "FAIL|PASS|Error|Tests:|\u2713|\u2717"' },
+  { pattern: /^npm run build(?:\s|$)/, recallHint: '--grep "error|Built|Failed|\u2713|\u2717"' },
+  { pattern: /^npm run (?:lint|typecheck|check|type-check)(?:\s|$)/, recallHint: '--grep "error|warning|\u2716|problems"' },
+  // node scripts (migration runners, seed generators, etc. run repeatedly)
+  { pattern: /^node\s+(?:scripts|src\/scripts)\/\S+\.m?js\b/, recallHint: '--tail 50 --grep "error|Error|done|complete|inserted|migrated"' },
+  // External AI peer-review CLI tools (produce large outputs, run repeatedly per session)
+  { pattern: /^codex(?:\s|$)/, recallHint: '--tail 100 --grep "error|suggestion|verdict|conclusion"' },
+  { pattern: /^(?:~\/\.claude\/bin\/|\.claude\/bin\/)?glm\.sh(?:\s|$)/, recallHint: '--tail 100 --grep "error|verdict|conclusion|suggestion"' },
+  // cat of a single source file — output is the full file; pre-bash emits a token-goat read suggestion
+  { pattern: /^cat\s+\S+\.(java|py|ts|tsx|js|jsx|go|rb|rs|cpp|cc|cxx|c|h|hpp|kt|swift|cs|php|scala|clj)\s*$/, recallHint: "--tail 50" },
+  // PowerShell read-only system-state queries (stable over 60-120s)
+  {
+    pattern: /^(?:powershell(?:\.exe)?|pwsh(?:\.exe)?)\s+(?:-\w+\s+)*-Command\s+["']?Get-(?:CimInstance|Process|Counter|Service|PSDrive|WmiObject)\b/i,
+    recallHint: "--tail 50"
+  },
+  // token-goat section/outline/symbol repeat calls — output is stable until the file changes
+  { pattern: /^(?:token-goat|tg)\s+section\s+["'][^"']+["']/, recallHint: "" },
+  { pattern: /^(?:token-goat|tg)\s+outline\s+\S+/, recallHint: "" },
+  { pattern: /^(?:token-goat|tg)\s+symbol\s+\S+/, recallHint: "" }
+];
+function isPsMultilineSystemQuery(cmd) {
+  if (!/^(?:powershell(?:\.exe)?|pwsh(?:\.exe)?)\s+/i.test(cmd)) return false;
+  const cmdIdx = cmd.search(/-Command\b/i);
+  if (cmdIdx === -1) return false;
+  const afterCmd = cmd.slice(cmdIdx + "-Command".length).trimStart();
+  if (!/^["']/.test(afterCmd)) return false;
+  const body = afterCmd.slice(1);
+  if (!body.includes("\n")) return false;
+  if (!/\bGet-(?:CimInstance|Process|Counter|Service|PSDrive|WmiObject)\b/i.test(body)) return false;
+  if (/\b(?:Remove|Set|New|Restart|Install|Uninstall|Enable|Disable|Grant|Revoke|Register|Unregister)-/i.test(body)) return false;
+  if (/\b(?:Stop-(?:Process|Service|Computer)|Invoke-(?:Expression|Command)|Clear-(?:Content|EventLog|Item))\b/i.test(body)) return false;
+  return true;
+}
+function getMonitoringRecallHint(cmd) {
+  const trimmed = cmd.trim();
+  if (hasUnquotedOperator(trimmed, ["&&", "||", ";"])) return null;
+  for (const { pattern, recallHint } of MONITORING_COMMAND_PATTERNS) {
+    if (pattern.test(trimmed)) return recallHint;
+  }
+  if (isPsMultilineSystemQuery(trimmed)) return "--tail 50";
+  return null;
+}
+
+// src/recall_index.ts
+init_define_import_meta_env();
+import * as fs2 from "node:fs";
+function subdirForCacheType(cacheType) {
+  return cacheType === "web" ? "web_outputs" : "bash_outputs";
+}
+function blobStillExists(cacheType, id) {
+  try {
+    const p = blobPath(subdirForCacheType(cacheType), id);
+    return p !== null && fs2.existsSync(p);
+  } catch {
+    return false;
+  }
+}
+var VALID_TYPES = ["bash", "web", "mcp"];
+var RECALL_DEFAULT_LIMIT = 10;
+function isRecallCacheType(value) {
+  return VALID_TYPES.includes(value);
+}
+function indexRecallEntry(cacheType, id, label, content, storedAt) {
+  try {
+    const db = getDb(globalDbPath());
+    db.prepare(
+      `INSERT INTO cache_recall (cache_type, entry_id, label, content, stored_at)
+       VALUES (@cacheType, @id, @label, @content, @storedAt)
+       ON CONFLICT(cache_type, entry_id) DO UPDATE SET
+         label = excluded.label,
+         content = excluded.content,
+         stored_at = excluded.stored_at`
+    ).run({ cacheType, id, label, content, storedAt });
+  } catch {
+  }
+  pruneCacheRecallRows();
+}
+function pruneCacheRecallRows(maxAgeMs = DEFAULT_MAX_AGE_MS) {
+  try {
+    const db = getDb(globalDbPath());
+    const cutoff = Date.now() - maxAgeMs;
+    db.prepare(`DELETE FROM cache_recall WHERE stored_at < ?`).run(cutoff);
+  } catch {
+  }
+}
+var _ftsAvailable = null;
+function hasFtsTable() {
+  if (_ftsAvailable !== null) return _ftsAvailable;
+  try {
+    const db = getDb(globalDbPath());
+    const row = db.prepare(`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'cache_recall_fts'`).get();
+    _ftsAvailable = row !== void 0;
+  } catch {
+    _ftsAvailable = false;
+  }
+  return _ftsAvailable;
+}
+function buildSnippet(content, query, maxLen = 160) {
+  const flat = content.replace(/\s+/g, " ").trim();
+  const tokens = query.split(/\s+/).filter(Boolean);
+  let idx = -1;
+  const lowerFlat = flat.toLowerCase();
+  for (const token of tokens) {
+    const at = lowerFlat.indexOf(token.toLowerCase());
+    if (at !== -1) {
+      idx = at;
+      break;
+    }
+  }
+  if (idx === -1) {
+    return flat.length > maxLen ? flat.slice(0, maxLen) + "..." : flat;
+  }
+  const start = Math.max(0, idx - Math.floor(maxLen / 3));
+  const end = Math.min(flat.length, start + maxLen);
+  const prefix = start > 0 ? "..." : "";
+  const suffix = end < flat.length ? "..." : "";
+  return prefix + flat.slice(start, end) + suffix;
+}
+function toFtsMatchExpr(query) {
+  if (query.trim().length === 0) return null;
+  return sanitizeFtsQuery(query);
+}
+function mapRowsToHits(rows, snippetQuery) {
+  return rows.filter((r) => isRecallCacheType(r.cacheType)).map((r) => ({
+    id: r.id,
+    cacheType: r.cacheType,
+    label: r.label ?? "",
+    snippet: buildSnippet(r.content ?? "", snippetQuery),
+    storedAt: r.storedAt ?? 0,
+    blobPresent: blobStillExists(r.cacheType, r.id)
+  }));
+}
+function ftsSearch(query, type, limit) {
+  const matchExpr = toFtsMatchExpr(query);
+  if (matchExpr === null) return [];
+  const db = getDb(globalDbPath());
+  const rows = type !== void 0 ? db.prepare(
+    `SELECT c.entry_id AS id, c.cache_type AS cacheType, c.label AS label, c.content AS content, c.stored_at AS storedAt
+             FROM cache_recall_fts
+             JOIN cache_recall c ON c.row_id = cache_recall_fts.rowid
+             WHERE cache_recall_fts MATCH ? AND c.cache_type = ?
+             ORDER BY bm25(cache_recall_fts)
+             LIMIT ?`
+  ).all(matchExpr, type, limit) : db.prepare(
+    `SELECT c.entry_id AS id, c.cache_type AS cacheType, c.label AS label, c.content AS content, c.stored_at AS storedAt
+             FROM cache_recall_fts
+             JOIN cache_recall c ON c.row_id = cache_recall_fts.rowid
+             WHERE cache_recall_fts MATCH ?
+             ORDER BY bm25(cache_recall_fts)
+             LIMIT ?`
+  ).all(matchExpr, limit);
+  return mapRowsToHits(rows, query);
+}
+function likeSearch(query, type, limit) {
+  const trimmed = query.trim();
+  if (!trimmed) return [];
+  const db = getDb(globalDbPath());
+  const needle = `%${trimmed.replace(/\\/g, "\\\\").replace(/[%_]/g, (c) => `\\${c}`)}%`;
+  const rows = type !== void 0 ? db.prepare(
+    `SELECT entry_id AS id, cache_type AS cacheType, label, content, stored_at AS storedAt
+             FROM cache_recall
+             WHERE cache_type = ? AND (label LIKE ? ESCAPE '\\' OR content LIKE ? ESCAPE '\\')
+             ORDER BY stored_at DESC
+             LIMIT ?`
+  ).all(type, needle, needle, limit) : db.prepare(
+    `SELECT entry_id AS id, cache_type AS cacheType, label, content, stored_at AS storedAt
+             FROM cache_recall
+             WHERE label LIKE ? ESCAPE '\\' OR content LIKE ? ESCAPE '\\'
+             ORDER BY stored_at DESC
+             LIMIT ?`
+  ).all(needle, needle, limit);
+  return mapRowsToHits(rows, trimmed);
+}
+function listRecentRecall(opts = {}) {
+  const limit = opts.limit ?? RECALL_DEFAULT_LIMIT;
+  const columns = `SELECT entry_id AS id, cache_type AS cacheType, label, content, stored_at AS storedAt FROM cache_recall`;
+  try {
+    const db = getDb(globalDbPath());
+    const rows = opts.type !== void 0 ? db.prepare(`${columns} WHERE cache_type = ? ORDER BY stored_at DESC LIMIT ?`).all(opts.type, limit) : db.prepare(`${columns} ORDER BY stored_at DESC LIMIT ?`).all(limit);
+    return mapRowsToHits(rows, "");
+  } catch {
+    return [];
+  }
+}
+function searchRecall(query, opts = {}) {
+  const limit = opts.limit ?? RECALL_DEFAULT_LIMIT;
+  if (query.trim() === "") return [];
+  try {
+    if (hasFtsTable()) {
+      return ftsSearch(query, opts.type, limit);
+    }
+    return likeSearch(query, opts.type, limit);
+  } catch {
+    try {
+      return likeSearch(query, opts.type, limit);
+    } catch {
+      return [];
+    }
+  }
+}
+
+// src/bash_output_cache.ts
+var BASH_OUTPUT_SUBDIR = "bash_outputs";
+var _byId = /* @__PURE__ */ new Map();
+var COMMAND_PATTERNS = {
+  gitMutable: /^\s*git\s+(diff|status)\b/i,
+  gitImmutable: /^\s*git\s+show\s+[0-9a-f]{40}\b/i,
+  gitDiffScoped: /\s--\s+\S/,
+  dirListing: /^\s*(?:ls|eza|exa|dir|Get-ChildItem|gci)\b/i,
+  depList: /^\s*(?:npm\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*(?:ls|list)\b|pip\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*(?:list|freeze)\b|uv\s+pip\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*(?:list|freeze)\b|pnpm\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*(?:list|ls)\b|yarn\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*(?:list)\b|cargo\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*tree\b|bundle\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*(?:list|show)\b|composer\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*show\b)/i,
+  npmInstall: /^\s*npm\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*(?:install|ci)\b/i,
+  npmAudit: /^\s*npm\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*audit\b(?!.*(?:--fix|fix)\b)/i,
+  npmOutdated: /^\s*npm\s+(?:--?[a-zA-Z0-9_-]+(?:\s+|=))*outdated\b/i,
+  envProbe: /^\s*(?:node\s+(?:-v|--version)|npm\s+(?:-v|--version)|python3?\s+(?:(?:-V)\b|--?version)|git\s+--version|uv\s+--version|go\s+version|rustc\s+--version|cargo\s+--version|java\s+--version|ruby\s+--version|gem\s+--version|php\s+--version|which\b|where\b)/i,
+  npx: /^(?!.*\b(?:install|add|remove|uninstall|i|rm|update|upgrade|set|get|publish|link|ci|audit|shrinkwrap|dedupe|prune|rebuild)\b)\s*npx\s+(?:--?yes\s+)?/i,
+  gitPush: /^\s*git\s+push\b/i,
+  testRunner: /^\s*(?:npx\s+)?(?:pytest|vitest|jest|go\s+test)\b/i,
+  lintCommand: /^\s*(?:(?:npx\s+)?eslint|(?:uv\s+run\s+)?ruff)\b/i,
+  npmRunScript: /^\s*npm\s+run(?:-script)?\b/i,
+  catCommand: /^\s*cat\b/i
+};
+var DEP_LOCKFILES = {
+  npm: ["package-lock.json", "yarn.lock"],
+  pip: ["requirements.txt"],
+  uv: ["uv.lock", "requirements.txt"],
+  pnpm: ["pnpm-lock.yaml"],
+  yarn: ["yarn.lock"],
+  cargo: ["Cargo.lock"],
+  bundle: ["Gemfile.lock"],
+  composer: ["composer.lock"]
+};
+function isCommandOfType(cmd, type) {
+  const pattern = COMMAND_PATTERNS[type];
+  return pattern?.test(cmd) ?? false;
+}
+var isGitMutableCommand = (cmd) => isCommandOfType(cmd, "gitMutable");
+var isDirListingCommand = (cmd) => isCommandOfType(cmd, "dirListing");
+var isDepListCommand = (cmd) => isCommandOfType(cmd, "depList");
+var isNpmInstallCommand = (cmd) => isCommandOfType(cmd, "npmInstall");
+var isNpmAuditCommand = (cmd) => isCommandOfType(cmd, "npmAudit");
+var isNpmOutdatedCommand = (cmd) => isCommandOfType(cmd, "npmOutdated");
+var isGitPushCommand = (cmd) => isCommandOfType(cmd, "gitPush");
+var isTestRunnerCommand2 = (cmd) => isCommandOfType(cmd, "testRunner");
+var isLintCommand = (cmd) => isCommandOfType(cmd, "lintCommand");
+var isNpmRunScriptCommand = (cmd) => isCommandOfType(cmd, "npmRunScript");
+var isCatCommand = (cmd) => isCommandOfType(cmd, "catCommand");
+function isScopedGitStatusOrDiffStatCommand(cmd) {
+  if (!isCommandOfType(cmd, "gitMutable")) return false;
+  if (!isCommandOfType(cmd, "gitDiffScoped")) return false;
+  if (/^\s*git\s+diff\b/i.test(cmd) && !/--stat\b/.test(cmd)) return false;
+  return true;
+}
+function gitStateFingerprintSync(cwd) {
+  try {
+    const headResult = runGit(["rev-parse", "HEAD"], { cwd });
+    if (headResult.exitCode !== 0) return null;
+    const headSha = headResult.stdout.trim();
+    let statusHash = "";
+    const statusResult = runGit(["status", "--porcelain"], { cwd });
+    if (statusResult.exitCode === 0) {
+      statusHash = shortFingerprint(statusResult.stdout);
+    }
+    const key = `${headSha}\0${statusHash}`;
+    return shortFingerprint(key);
+  } catch {
+    return null;
+  }
+}
+var DIR_FINGERPRINT_LISTING_CAP_ENTRIES = 1e4;
+function dirStateFingerprintSync(path2) {
+  try {
+    const stat = statSync2(path2);
+    if (!stat.isDirectory()) return null;
+    const entries = readdirSync(path2);
+    if (entries.length <= DIR_FINGERPRINT_LISTING_CAP_ENTRIES) {
+      return shortFingerprint(entries.slice().sort().join("\0"));
+    }
+    return shortFingerprint(stat.mtimeMs.toString());
+  } catch {
+    return null;
+  }
+}
+var FILE_FINGERPRINT_CONTENT_CAP_BYTES = 2 * 1024 * 1024;
+function fileStateFingerprintSync(path2) {
+  try {
+    const stat = statSync2(path2);
+    if (!stat.isFile()) return null;
+    if (stat.size <= FILE_FINGERPRINT_CONTENT_CAP_BYTES) {
+      return shortFingerprint(readFileSync2(path2));
+    }
+    return shortFingerprint(`${stat.mtimeMs}\0${stat.size}`);
+  } catch {
+    return null;
+  }
+}
+function depLockfileFingerprintSync(cmd, cwd) {
+  if (!cwd) return null;
+  const stripped = cmd.trim();
+  const firstToken = stripped.split(/\s+/)[0]?.toLowerCase() || "";
+  if (!firstToken) return null;
+  const candidates = firstToken === "uv" ? DEP_LOCKFILES["uv"] : DEP_LOCKFILES[firstToken];
+  if (!candidates) return null;
+  for (const lockfile of candidates) {
+    try {
+      const content = readFileSync2(resolve(cwd, lockfile));
+      return shortFingerprint(content);
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function normalizeCommandForCacheKey(cmd) {
+  const trimmed = cmd.trim();
+  const tokens = [];
+  let current = "";
+  let quoteChar = null;
+  const flush = () => {
+    if (current.length > 0) {
+      tokens.push(current);
+      current = "";
+    }
+  };
+  for (let i = 0; i < trimmed.length; i++) {
+    const ch = trimmed[i];
+    if (quoteChar !== null) {
+      current += ch;
+      if (ch === quoteChar) quoteChar = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quoteChar = ch;
+      current += ch;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      flush();
+      continue;
+    }
+    current += ch === "\\" ? "/" : ch;
+  }
+  flush();
+  const normalized_tokens = tokens.map((token) => {
+    if (token.startsWith("-") || ["&&", "||", "|", ">", ">>", ";", "&"].includes(token)) {
+      return token;
+    }
+    if (token.startsWith("./") && !token.startsWith("../")) {
+      token = token.slice(2);
+    }
+    if (token.endsWith("/") && token !== "/") {
+      token = token.slice(0, -1);
+    }
+    return token || ".";
+  });
+  return normalized_tokens.join(" ");
+}
+function commandHashSync(command, cwd = null) {
+  const normalized = normalizeCommandForCacheKey(command);
+  let key = cwd ? `${normalizePath(cwd)}\0${normalized}` : normalized;
+  if (cwd && isGitMutableCommand(command)) {
+    const fp = gitStateFingerprintSync(cwd);
+    if (fp) key = `${key}\0git:${fp}`;
+  }
+  if (cwd && isDirListingCommand(command)) {
+    const target = extractFirstPathArg(command, cwd, cwd);
+    if (target) {
+      const fp = dirStateFingerprintSync(target);
+      if (fp) key = `${key}\0dir:${fp}`;
+    }
+  }
+  if (isDepListCommand(command)) {
+    const fp = depLockfileFingerprintSync(command, cwd);
+    if (fp) key = `${key}\0lockfile:${fp}`;
+  }
+  if (cwd && (isNpmInstallCommand(command) || isNpmAuditCommand(command) || isNpmOutdatedCommand(command))) {
+    const fp = depLockfileFingerprintSync(command, cwd);
+    if (fp) key = `${key}\0npm-install:${fp}`;
+  }
+  return shortFingerprint(key);
+}
+function commandHash(command, cwd = null) {
+  return Promise.resolve(commandHashSync(command, cwd));
+}
+function bashOutputIdSync(command, output, cwd = null) {
+  return shortFingerprint(`${commandHashSync(command, cwd)}\0${output}`);
+}
+function computeBashFingerprints(command, cwd) {
+  const fingerprints = {};
+  if (cwd && (isGitMutableCommand(command) || isGitPushCommand(command) || isTestRunnerCommand2(command) || isLintCommand(command) || isBuildCommand(command) || isNpmRunScriptCommand(command))) {
+    const fp = gitStateFingerprintSync(cwd);
+    if (fp) fingerprints.git = fp;
+  }
+  if (cwd && isDirListingCommand(command)) {
+    const target = extractFirstPathArg(command, cwd, cwd);
+    if (target) {
+      const fp = dirStateFingerprintSync(target);
+      if (fp) fingerprints.dir = fp;
+    }
+  }
+  if (isDepListCommand(command) || cwd && (isNpmInstallCommand(command) || isNpmAuditCommand(command) || isNpmOutdatedCommand(command))) {
+    const fp = depLockfileFingerprintSync(command, cwd);
+    if (fp) fingerprints.lockfile = fp;
+  }
+  if (cwd && isCatCommand(command)) {
+    const target = extractFirstPathArg(command, cwd, null);
+    if (target) {
+      const fp = fileStateFingerprintSync(target);
+      if (fp) fingerprints.file = fp;
+    }
+  }
+  return Object.keys(fingerprints).length > 0 ? fingerprints : void 0;
+}
+function isBashEntryStale(entry, command, cwd) {
+  const stored = entry.fingerprints;
+  if (!stored) return false;
+  const current = computeBashFingerprints(command, cwd);
+  if (stored.git !== void 0 && stored.git !== current?.git) return true;
+  if (stored.dir !== void 0 && stored.dir !== current?.dir) return true;
+  if (stored.lockfile !== void 0 && stored.lockfile !== current?.lockfile) return true;
+  if (stored.file !== void 0 && stored.file !== current?.file) return true;
+  return false;
+}
+function tokenizeShellArgs(cmd) {
+  const trimmed = cmd.trim();
+  const tokens = [];
+  let current = "";
+  let quoteChar = null;
+  let hasToken = false;
+  for (let i = 0; i < trimmed.length; i++) {
+    const ch = trimmed[i];
+    if (quoteChar !== null) {
+      if (ch === quoteChar) {
+        quoteChar = null;
+      } else {
+        current += ch;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quoteChar = ch;
+      hasToken = true;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (hasToken) {
+        tokens.push(current);
+        current = "";
+        hasToken = false;
+      }
+      continue;
+    }
+    current += ch;
+    hasToken = true;
+  }
+  if (hasToken) tokens.push(current);
+  return tokens;
+}
+function extractFirstPathArg(cmd, cwd, fallback) {
+  const tokens = tokenizeShellArgs(cmd);
+  for (let i = 1; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (!token.startsWith("-")) {
+      if (!token.startsWith("/")) {
+        return resolve(cwd, token);
+      }
+      return token;
+    }
+  }
+  return fallback;
+}
+var ISSUE_LINE_PATTERN = /\b(?:error|fail(?:ed|ure)?|warning)\b/i;
+function summarizeOutputDelta(oldOutput, newOutput) {
+  if (oldOutput === newOutput) return null;
+  const oldLines = oldOutput.split("\n");
+  const newLines = newOutput.split("\n");
+  const oldIssueLines = oldLines.filter((l) => ISSUE_LINE_PATTERN.test(l));
+  if (oldIssueLines.length > 0) {
+    const newIssueLines = newLines.filter((l) => ISSUE_LINE_PATTERN.test(l));
+    const priorTotal = oldIssueLines.length;
+    const availableCounts = /* @__PURE__ */ new Map();
+    for (const l of newIssueLines) availableCounts.set(l, (availableCounts.get(l) ?? 0) + 1);
+    let resolved = 0;
+    for (const l of oldIssueLines) {
+      const avail = availableCounts.get(l) ?? 0;
+      if (avail > 0) {
+        availableCounts.set(l, avail - 1);
+      } else {
+        resolved++;
+      }
+    }
+    const remaining = newIssueLines.length;
+    return `[token-goat: delta] ${resolved} of ${priorTotal} prior issues resolved; remaining: ${remaining}`;
+  }
+  return `[token-goat: delta] output changed: ${oldLines.length} -> ${newLines.length} lines`;
+}
+function storeBashOutputSync(command, output, exitCode, cwd = null) {
+  const id = bashOutputIdSync(command, output, cwd);
+  const commandKey = commandHashSync(command, cwd);
+  const fingerprints = computeBashFingerprints(command, cwd);
+  const redactedOutput = redactSecrets(output).text;
+  const redactedCommand = redactSecrets(command).text;
+  const entry = {
+    id,
+    command: redactedCommand,
+    output: redactedOutput,
+    exitCode,
+    storedAt: Date.now(),
+    sizeBytes: Buffer.byteLength(redactedOutput, "utf-8"),
+    ...fingerprints ? { fingerprints } : {}
+  };
+  _byId.set(id, entry);
+  _byId.set(commandKey, entry);
+  storeBlob(BASH_OUTPUT_SUBDIR, id, entry);
+  if (commandKey !== id) storeBlob(BASH_OUTPUT_SUBDIR, commandKey, { latestId: id });
+  indexRecallEntry("bash", id, redactedCommand, `${redactedCommand}
+${redactedOutput}`, entry.storedAt);
+  return id;
+}
+function coerceBashRedirect(raw) {
+  if (raw === null || typeof raw !== "object") return null;
+  const latest = raw["latestId"];
+  return typeof latest === "string" && latest.length > 0 ? latest : null;
+}
+function storeBashOutput(command, output, exitCode, cwd = null) {
+  return Promise.resolve(storeBashOutputSync(command, output, exitCode, cwd));
+}
+function coerceBashEntry(raw) {
+  if (raw === null || typeof raw !== "object") return null;
+  const o = raw;
+  if (typeof o["id"] !== "string" || typeof o["command"] !== "string" || typeof o["output"] !== "string" || typeof o["exitCode"] !== "number" || typeof o["storedAt"] !== "number" || typeof o["sizeBytes"] !== "number") {
+    return null;
+  }
+  const entry = {
+    id: o["id"],
+    command: o["command"],
+    output: o["output"],
+    exitCode: o["exitCode"],
+    storedAt: o["storedAt"],
+    sizeBytes: o["sizeBytes"]
+  };
+  const rawFingerprints = o["fingerprints"];
+  if (rawFingerprints !== null && typeof rawFingerprints === "object") {
+    const f = rawFingerprints;
+    const fingerprints = {};
+    if (typeof f["git"] === "string") fingerprints.git = f["git"];
+    if (typeof f["dir"] === "string") fingerprints.dir = f["dir"];
+    if (typeof f["lockfile"] === "string") fingerprints.lockfile = f["lockfile"];
+    if (typeof f["file"] === "string") fingerprints.file = f["file"];
+    if (Object.keys(fingerprints).length > 0) return { ...entry, fingerprints };
+  }
+  return entry;
+}
+function getBashOutput(id) {
+  const hit = _byId.get(id);
+  if (hit !== void 0) return hit;
+  if (isBlobStale(BASH_OUTPUT_SUBDIR, id)) return null;
+  const raw = loadBlob(BASH_OUTPUT_SUBDIR, id);
+  const target = coerceBashRedirect(raw);
+  if (target !== null) {
+    if (isBlobStale(BASH_OUTPUT_SUBDIR, target)) return null;
+    const latest = coerceBashEntry(loadBlob(BASH_OUTPUT_SUBDIR, target));
+    if (latest === null) return null;
+    _byId.set(target, latest);
+    _byId.set(id, latest);
+    return latest;
+  }
+  const entry = coerceBashEntry(raw);
+  if (entry === null) return null;
+  _byId.set(id, entry);
+  return entry;
+}
+registerReset(() => {
+  _byId = /* @__PURE__ */ new Map();
+});
+
+export {
+  DEFAULT_MAX_LINES,
+  DEFAULT_MAX_BYTES,
+  MAX_INSPECT_BYTES,
+  LONG_LINE_MAX_CHARS,
+  getMaxInputBytes,
+  INPUT_MAX_LINE_CHARS,
+  clipWideLines,
+  clampKeepingEnds,
+  compressionMarker,
+  combineStreams,
+  ERROR_SIGNAL_RE,
+  TIMESTAMP_PREFIX_RE,
+  REDIRECT_TOKEN_RE,
+  hasBareBackgroundOrNewline,
+  isRedirectAmpersand,
+  hasUnquotedOperator,
+  splitOwnTrailingNotices,
+  safeDecode,
+  normalise,
+  hasHighEntropyToken,
+  dedupeConsecutive,
+  truncateMiddleSmart,
+  capBytes,
+  capTokens,
+  headTailCompress,
+  truncateTableRows,
+  trimRepeatedPrefix,
+  stripTimestamps,
+  splitBlocks,
+  maybeNote,
+  squeezeBlankLines,
+  preserveStderrOnError,
+  pathName,
+  pathStem,
+  positionalArgs,
+  stripPrefixes,
+  resolvePackageManagerScript,
+  shlexSplit,
+  capLongLines,
+  clipLongMatchLine,
+  clipGrepLines,
+  fallbackTruncate,
+  compressBashOutput,
+  dedupeCombinedOutput,
+  compressTestOutput,
+  byteLength,
+  isLockFile,
+  isManifestFile,
+  isInBuildDir,
+  isGeneratedFile,
+  isBuildCommand,
+  isTestRunnerCommand,
+  getMonitoringRecallHint,
+  RECALL_DEFAULT_LIMIT,
+  isRecallCacheType,
+  indexRecallEntry,
+  listRecentRecall,
+  searchRecall,
+  BASH_OUTPUT_SUBDIR,
+  isScopedGitStatusOrDiffStatCommand,
+  normalizeCommandForCacheKey,
+  commandHash,
+  bashOutputIdSync,
+  isBashEntryStale,
+  summarizeOutputDelta,
+  storeBashOutputSync,
+  storeBashOutput,
+  getBashOutput
+};