token-goat 2.9.29 → 2.9.31

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

@@ -0,0 +1,800 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  CHANGES_WHAT_RUNS_NAMES,
+  extractCatFile,
+  extractHeadFile,
+  extractLineRangeRead,
+  extractLineRangeReadsCompound,
+  extractTailFile,
+  isTscCommand,
+  splitShellSegments,
+  stripLeadingAssignments
+} from "./token-goat-chunk-DGS2LVNA.mjs";
+import {
+  detectFromCommand,
+  filterByName
+} from "./token-goat-chunk-INNPTRUX.mjs";
+import {
+  enqueueDirtyPathSafe,
+  requestReconcileSafe
+} from "./token-goat-chunk-CIMQ2BB3.mjs";
+import {
+  RECALL_DEFAULT_LIMIT,
+  isBuildCommand,
+  isTestRunnerCommand,
+  listRecentRecall,
+  parsePorcelainZ,
+  searchRecall
+} from "./token-goat-chunk-4ZBFWLXF.mjs";
+import {
+  fenceIfScanMatched,
+  fenceUntrusted
+} from "./token-goat-chunk-4NAPX7BA.mjs";
+import {
+  hasBareBackgroundOrNewline,
+  hasUnquotedOperator,
+  maskQuotedSpans,
+  shlexSplit
+} from "./token-goat-chunk-4GILLLWY.mjs";
+import {
+  appendWorkerErrorLog
+} from "./token-goat-chunk-F6PAUIEK.mjs";
+import {
+  shortFingerprint
+} from "./token-goat-chunk-4GBVPH3D.mjs";
+import {
+  pad,
+  runGit
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  UNTRUSTED_TOOL_TAG,
+  UNTRUSTED_WEB_TAG,
+  displaySafeJson,
+  displaySafeText,
+  normalizePath,
+  resolveIndexPath
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  dataDir
+} from "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/hooks_bash_commands.ts
+init_define_import_meta_env();
+import { statSync } from "node:fs";
+import { homedir } from "node:os";
+import * as path from "node:path";
+
+// src/cli_recall.ts
+init_define_import_meta_env();
+var RECALL_COMMAND = {
+  bash: "bash-output",
+  web: "web-output",
+  mcp: "mcp-output"
+};
+function fenceTagForCacheType(cacheType) {
+  return cacheType === "web" ? UNTRUSTED_WEB_TAG : UNTRUSTED_TOOL_TAG;
+}
+function fenceRecallListing(text, hits) {
+  const tags = new Set(hits.map((hit) => fenceTagForCacheType(hit.cacheType)));
+  const tag = tags.size === 1 ? [...tags][0] ?? UNTRUSTED_TOOL_TAG : UNTRUSTED_TOOL_TAG;
+  return fenceUntrusted(text, tag);
+}
+function fenceSnippetIfMatched(hit) {
+  return fenceIfScanMatched(hit.snippet, fenceTagForCacheType(hit.cacheType));
+}
+function printHits(query, hits) {
+  const w = (text) => {
+    process.stdout.write(text);
+  };
+  if (hits.length === 0) {
+    w(query === void 0 ? "No cache entries yet.\n" : `No cache entries match: ${query}
+`);
+    return;
+  }
+  const body = hits.map((hit) => {
+    const label = hit.label.length > 80 ? hit.label.slice(0, 77) + "..." : hit.label;
+    const pointer = hit.blobPresent ? `  (token-goat ${RECALL_COMMAND[hit.cacheType]} ${hit.id})` : "  (blob expired -- content below is all that remains)";
+    return `[${pad(hit.cacheType, 4)}] ${hit.id}
+${pointer}
+  ${label}
+  ${hit.snippet}
+`;
+  }).join("\n");
+  w(`${fenceRecallListing(body, hits)}
+`);
+}
+function runRecallCommand(query, opts = {}) {
+  const browse = query === void 0 || query.trim() === "";
+  const scope = {
+    ...opts.type !== void 0 ? { type: opts.type } : {},
+    ...opts.limit !== void 0 ? { limit: opts.limit } : {}
+  };
+  const effectiveLimit = opts.limit ?? RECALL_DEFAULT_LIMIT;
+  const fetched = browse ? listRecentRecall({ ...scope, limit: effectiveLimit + 1 }) : searchRecall(query, { ...scope, limit: effectiveLimit + 1 });
+  const hits = fetched.slice(0, effectiveLimit);
+  if (fetched.length > hits.length) {
+    process.stderr.write(`Showing ${hits.length} entries; more are available (raise --limit to see them).
+`);
+  }
+  if (opts.json === true) {
+    const fenced = hits.map((hit) => ({ ...hit, snippet: fenceSnippetIfMatched(hit) }));
+    process.stdout.write(`${displaySafeJson(fenced, 0)}
+`);
+    return;
+  }
+  printHits(browse ? void 0 : query, hits);
+}
+
+// src/hooks_bash_commands.ts
+var CD_PREFIX_RE = /^(?:cd\s+(?:"[^"]*"|'[^']*'|\S+)[ \t]*(?:&&|;|\r?\n)\s*)+/;
+var EXPORT_VALUE = String.raw`(?:[\w./:@%+,=-]*|"[^"$\`\\\r\n]*"|'[^'\r\n]*')`;
+var EXPORT_NAME = String.raw`(?!(?:${CHANGES_WHAT_RUNS_NAMES})=)[A-Za-z_]\w*`;
+var EXPORT_PREFIX_RE = new RegExp(String.raw`^(?:export[ \t]+${EXPORT_NAME}=${EXPORT_VALUE}(?:[ \t]+${EXPORT_NAME}=${EXPORT_VALUE})*[ \t]*(?:&&|;|\r?\n)\s*)+`);
+function stripExportPrefix(cmd) {
+  const stripped = cmd.replace(EXPORT_PREFIX_RE, "");
+  return stripped.trim() || cmd;
+}
+function stripCdPrefix(cmd) {
+  const stripped = cmd.replace(CD_PREFIX_RE, "");
+  return stripped.trim() || cmd;
+}
+function stripSubshellGroup(cmd) {
+  const t = cmd.trim();
+  if (!t.startsWith("(") || t.startsWith("((") || !t.endsWith(")")) return cmd;
+  const masked = maskQuotedSpans(t);
+  let depth = 0;
+  for (let i = 0; i < masked.length; i++) {
+    if (masked[i] === "(") depth++;
+    else if (masked[i] === ")" && --depth === 0) return i === masked.length - 1 ? t.slice(1, -1).trim() || cmd : cmd;
+  }
+  return cmd;
+}
+function stripGroupAndExports(rawCmd) {
+  return stripExportPrefix(stripSubshellGroup(rawCmd));
+}
+function stripCommandPrefix(rawCmd) {
+  return stripLeadingAssignments(stripExportPrefix(stripCdPrefix(stripGroupAndExports(rawCmd))));
+}
+function stripTrailingStderrRedirect(cmd) {
+  const stripped = cmd.replace(/\s*2>&1\s*$/, "");
+  return stripped.trim() || cmd;
+}
+function hasTestRunScopeOrBudget(cmd) {
+  const hasTimeout = /(?:^|\s)(?:timeout(?:\.exe)?\s+\S+|--(?:test)?timeout(?:=|\s)\S+)/i.test(cmd);
+  const hasSelector = /(?:\s::\S+|\s(?:-k|-t|-run|--(?:testNamePattern|last-failed|test|project))(?:=|\s)|\b(?:tests?|spec)\S*\.(?:[cm]?[jt]sx?|py|go|rs)\b|(?:^|\s)\.\/\S+)/i.test(cmd);
+  return hasTimeout || hasSelector;
+}
+function isDirectTestRunnerCommand(cmd) {
+  return /^(?:pytest|(?:npx\s+)?(?:jest|vitest)|go\s+test|cargo\s+test)\b/i.test(cmd);
+}
+function extractCdPrefixDirs(rawCmd) {
+  const prefixMatch = stripGroupAndExports(rawCmd).match(CD_PREFIX_RE);
+  if (prefixMatch === null) return [];
+  const dirs = [];
+  const segmentPattern = /cd\s+(?:"([^"]*)"|'([^']*)'|(\S+))[ \t]*(?:&&|;|\r?\n)/g;
+  let match;
+  while ((match = segmentPattern.exec(prefixMatch[0])) !== null) {
+    const dir = match[1] ?? match[2] ?? (match[3] === void 0 ? void 0 : expandHomePrefix(match[3]));
+    if (dir !== void 0) dirs.push(dir);
+  }
+  return dirs;
+}
+function expandHomePrefix(word) {
+  return word === "~" || word.startsWith("~/") ? path.join(homedir(), word.slice(1)) : word;
+}
+function resolveCdHintPath(rawCmd, filePath, cwd) {
+  if (extractCdPrefixDirs(rawCmd).length === 0) return filePath;
+  return resolveIndexPath(filePath, cdPrefixCwd(rawCmd, cwd));
+}
+function cdPrefixCwd(rawCmd, cwd) {
+  let dir = cwd;
+  for (const target of extractCdPrefixDirs(rawCmd)) dir = resolveIndexPath(target, dir);
+  return dir;
+}
+function commandRunDir(rawCmd, cwd) {
+  return cwd === null && extractCdPrefixDirs(rawCmd).length === 0 ? null : cdPrefixCwd(rawCmd, cwd ?? process.cwd());
+}
+function bashRecallKey(cmd, runDir) {
+  const base = stripOutputPipeline(cmd);
+  return shortFingerprint(runDir === null ? base : `${normalizePath(runDir)}\0${base}`);
+}
+function resolveBashCall(reported, startCwd) {
+  const rawCmd = unwrapCompressCommand(reported) ?? reported;
+  return { rawCmd, cmd: stripCommandPrefix(rawCmd), runDir: commandRunDir(rawCmd, startCwd) };
+}
+function stripOutputPipeline(cmd) {
+  let base = cmd.slice(0, firstTopLevelPipe(cmd));
+  let prev;
+  do {
+    prev = base;
+    const masked = base.replace(/"((?:[^"\\]|\\.)*)"/g, (_m, inner) => '"' + " ".repeat(inner.length) + '"').replace(/'([^']*)'/g, (_m, inner) => "'" + " ".repeat(inner.length) + "'");
+    const newMasked = masked.replace(/\s*(?:[0-9]*>&[0-9]+|[0-9&]*>>?\s*(?:"[^"]*"|'[^']*'|[^\s|]+))\s*$/, "");
+    if (newMasked.length < masked.length) {
+      base = base.slice(0, newMasked.length);
+    }
+  } while (base !== prev);
+  return base.trim();
+}
+function firstTopLevelPipe(cmd) {
+  let inSingle = false;
+  let inDouble = false;
+  let cut = cmd.length;
+  let backslashes = 0;
+  for (let i = 0; i < cmd.length; i++) {
+    const ch = cmd[i];
+    if (ch === "\\") {
+      backslashes++;
+      continue;
+    }
+    const escaped = backslashes % 2 === 1;
+    backslashes = 0;
+    if (ch === "'" && !inDouble) {
+      if (!escaped) inSingle = !inSingle;
+    } else if (ch === '"' && !inSingle) {
+      if (!escaped) inDouble = !inDouble;
+    } else if (ch === "|" && !inSingle && !inDouble) {
+      if (cmd[i + 1] === "|") {
+        i++;
+        continue;
+      }
+      cut = i;
+      break;
+    }
+  }
+  return cut;
+}
+function pipelineDivergenceNote(cmd, entryCommand) {
+  if (entryCommand === cmd) return "";
+  const preview = entryCommand.length > 60 ? entryCommand.slice(0, 57).trimEnd() + "..." : entryCommand;
+  return " (cached from a differently-piped run, `" + displaySafeText(preview) + "` \u2014 verify it covers what you need before trusting it)";
+}
+function outputSlice(cmd) {
+  const pipe = firstTopLevelPipe(cmd);
+  if (pipe >= cmd.length) return { kind: "none" };
+  const tail = cmd.slice(pipe + 1).replace(/\s*[0-9]*>&[0-9]+\s*$/, "").trim();
+  const head = /^head\s+(?:-n\s*|-)(\d+)$/.exec(tail);
+  if (head?.[1] !== void 0) return { kind: "head", n: Number(head[1]) };
+  const last = /^tail\s+(?:-n\s*|-)(\d+)$/.exec(tail);
+  if (last?.[1] !== void 0) return { kind: "tail", n: Number(last[1]) };
+  const sed = /^sed\s+-n\s+'?(\d+),(\d+)p'?$/.exec(tail);
+  if (sed?.[1] !== void 0 && sed[2] !== void 0) return { kind: "sed", from: Number(sed[1]), to: Number(sed[2]) };
+  return { kind: "unknown" };
+}
+function cachedRunCoversCommand(cachedCommand, cmd) {
+  const cached = outputSlice(cachedCommand);
+  const wanted = outputSlice(cmd);
+  if (cached.kind === "unknown" || wanted.kind === "unknown") return false;
+  if (cached.kind === "none") return true;
+  if (wanted.kind === "none") return false;
+  if (cached.kind === "tail") return wanted.kind === "tail" && wanted.n === cached.n;
+  const cachedFrom = cached.kind === "head" ? 1 : cached.from;
+  const cachedTo = cached.kind === "head" ? cached.n : cached.to;
+  if (wanted.kind === "tail") return false;
+  const wantedFrom = wanted.kind === "head" ? 1 : wanted.from;
+  const wantedTo = wanted.kind === "head" ? wanted.n : wanted.to;
+  return cachedFrom <= wantedFrom && wantedTo <= cachedTo;
+}
+function extractCommand(event) {
+  const cmd = event.toolInput["command"];
+  return typeof cmd === "string" && cmd.trim() !== "" ? cmd.trim() : void 0;
+}
+var HEAD_MOVING_GIT_RE = /^\s*git\s+(?:checkout|switch|pull|merge|rebase|reset|cherry-pick|stash\s+branch)\b/i;
+var PATH_SCOPED_CHECKOUT_RE = /^\s*git\s+checkout\s+(?:\S.*?\s)?--(?:\s|$)/i;
+function isHeadMovingGitCommand(cmd) {
+  if (!HEAD_MOVING_GIT_RE.test(cmd)) return false;
+  if (PATH_SCOPED_CHECKOUT_RE.test(cmd)) return false;
+  return true;
+}
+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_REWRITE_SUBCOMMANDS = /* @__PURE__ */ new Set(["pop", "apply", "branch", "push", "save"]);
+var GIT_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set(["-C", "-c", "--git-dir", "--work-tree", "--namespace", "--super-prefix", "--config-env"]);
+function gitStashRewriteDir(segment, runDir) {
+  const tokens = safeShlexSplit(segment);
+  if (tokens === null) return null;
+  let i = 0;
+  while (i < tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[i])) i++;
+  const head = tokens[i];
+  if (head === void 0 || path.basename(head.replace(/\\/g, "/")).replace(/\.exe$/i, "").toLowerCase() !== "git") return null;
+  let dir = runDir;
+  for (i++; i < tokens.length && tokens[i].startsWith("-"); i++) {
+    const t = tokens[i];
+    if (!GIT_OPTIONS_WITH_VALUE.has(t)) continue;
+    const value = tokens[++i];
+    if (t === "-C" && value !== void 0 && value !== "") dir = path.resolve(dir, value);
+  }
+  if (tokens[i] !== "stash") return null;
+  const rest = tokens.slice(i + 1);
+  if (rest.some((t) => t === "-h" || t === "--help")) return null;
+  const sub = rest[0];
+  return sub === void 0 || sub.startsWith("-") || GIT_STASH_REWRITE_SUBCOMMANDS.has(sub) ? dir : null;
+}
+var PATCH_APPLY_SEGMENT_RE = /^\s*(?:\S*[/\\])?(?:git\s+apply|patch)\b/i;
+var PATCH_APPLY_INSPECT_ONLY_RE = /(?:^|\s)--(?:check|stat|numstat|summary|dry-run)(?:\s|=|$)/i;
+function isFormatterWriteSegment(segment) {
+  return /(?:^|\s|[/\\])(?:prettier|eslint)\b/i.test(segment) && /(?:^|\s)--(?:write|fix)(?:\s|$)/i.test(segment);
+}
+function safeShlexSplit(segment) {
+  try {
+    return shlexSplit(segment);
+  } catch {
+    return null;
+  }
+}
+function segmentCommandIs(segment, name) {
+  return new RegExp("^\\s*(?:\\S*[/\\\\])?" + name + "(?:\\.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 gitRepoRootOrNull(gitDir) {
+  const toplevel = runGit(["rev-parse", "--show-toplevel"], { cwd: gitDir, timeoutMs: 5e3 });
+  return toplevel.exitCode === 0 && toplevel.stdout.trim() !== "" ? toplevel.stdout.trim() : null;
+}
+function reconcileIfGitTimedOut(result, gitDir, what, gitCommand) {
+  if (result.timedOut !== true) return;
+  const recorded = requestReconcileSafe(gitDir);
+  appendWorkerErrorLog(dataDir(), `${(/* @__PURE__ */ new Date()).toISOString()} post-bash ${what} in ${gitDir}: ${gitCommand} did not answer in time (${result.stderr.trim().slice(0, 200)}); ${recorded ? "asked the worker to reconcile the project" : "could not record a reconcile request, so the index may stay stale until the next index run"}
+`);
+}
+function expandGitPathspecs(specs, gitDir) {
+  if (specs.length === 0) return [];
+  const listed = runGit(["ls-files", "-z", "--full-name", "--", ...specs], { cwd: gitDir, timeoutMs: 5e3 });
+  reconcileIfGitTimedOut(listed, gitDir, "git restore", "git ls-files");
+  if (listed.exitCode !== 0) return [];
+  const repoRoot = gitRepoRootOrNull(gitDir);
+  if (repoRoot === null) {
+    requestReconcileSafe(gitDir);
+    return [];
+  }
+  return listed.stdout.split("\0").filter((rel) => rel.length > 0).map((rel) => resolveIndexPath(rel, repoRoot));
+}
+var STATUS_SWEEP_CAP = 2e3;
+function workingTreeStatusPaths(gitDir) {
+  const status = runGit(["status", "--porcelain", "-z", "--untracked-files=all"], { cwd: gitDir, timeoutMs: 5e3 });
+  reconcileIfGitTimedOut(status, gitDir, "status sweep", "git status");
+  const stamp = `${(/* @__PURE__ */ new Date()).toISOString()} post-bash status sweep in ${gitDir}`;
+  if (status.exitCode === -1 && status.timedOut !== true && /ENOBUFS/.test(status.stderr)) {
+    const recorded2 = requestReconcileSafe(gitDir);
+    appendWorkerErrorLog(dataDir(), `${stamp}: git status listed more than the output buffer holds; ${recorded2 ? "asked the worker to reconcile the project" : "could not record a reconcile request, so the index may stay stale until the next index run"}
+`);
+  }
+  if (status.exitCode !== 0) return [];
+  const recorded = requestReconcileSafe(gitDir);
+  const repoRoot = gitRepoRootOrNull(gitDir);
+  if (repoRoot === null) return [];
+  const entries = parsePorcelainZ(status.stdout);
+  const rels = [...entries.filter((e) => e.untracked === true), ...entries.filter((e) => e.untracked !== true)].flatMap((e) => e.origPath === void 0 ? [e.path] : [e.path, e.origPath]);
+  if (!recorded && rels.length <= STATUS_SWEEP_CAP) {
+    appendWorkerErrorLog(dataDir(), `${stamp}: could not record a reconcile request, so a file this sweep could not see may stay stale until the next index run
+`);
+  }
+  if (rels.length > STATUS_SWEEP_CAP) {
+    const untrackedDropped = Math.max(0, entries.filter((e) => e.untracked === true).length - STATUS_SWEEP_CAP);
+    appendWorkerErrorLog(dataDir(), `${stamp}: git listed ${rels.length} paths, so only the first ${STATUS_SWEEP_CAP} were queued, untracked ones first; ${untrackedDropped > 0 ? `${untrackedDropped} untracked ${untrackedDropped === 1 ? "file was" : "files were"} left out, which no reconcile finds, and ` : ""}${recorded ? "asked the worker to reconcile the project for the rest of the tracked files" : "could not record a reconcile request, so the index may stay stale until the next index run"}
+`);
+  }
+  return rels.slice(0, STATUS_SWEEP_CAP).map((rel) => resolveIndexPath(rel, repoRoot));
+}
+function enqueueRewrittenPath(absPath) {
+  if (/(?:^|[/\\])(?:NUL|nul)$/.test(absPath) || absPath.replace(/\\/g, "/").endsWith("/dev/null")) return;
+  try {
+    if (!statSync(absPath).isFile()) return;
+  } catch {
+    return;
+  }
+  enqueueDirtyPathSafe(absPath, { alreadyResolved: true });
+}
+function enqueueNonHeadMovingRewrites(cmd, runDir) {
+  const atRunDir = (f) => resolveIndexPath(f, runDir);
+  const paths = [];
+  const sweepDirs = /* @__PURE__ */ new Set();
+  if (GIT_RESTORE_RE.test(cmd) && !GIT_RESTORE_STAGED_ONLY_RE.test(cmd)) {
+    const specs = extractGitRestorePathspecs(cmd);
+    paths.push(...expandGitPathspecs(specs, runDir));
+    for (const spec of specs) if (spec !== "." && !spec.startsWith(":") && !/[*?[]/.test(spec)) paths.push(atRunDir(spec));
+  }
+  for (const segment of splitShellSegments(cmd)) {
+    if (PATCH_APPLY_SEGMENT_RE.test(segment) && !PATCH_APPLY_INSPECT_ONLY_RE.test(segment)) sweepDirs.add(runDir);
+    if (isFormatterWriteSegment(segment)) sweepDirs.add(runDir);
+    const stashDir = gitStashRewriteDir(segment, runDir);
+    if (stashDir !== null) sweepDirs.add(stashDir);
+    for (const f of extractSedInPlaceFiles(segment)) paths.push(atRunDir(f));
+    for (const f of extractTeeFiles(segment)) paths.push(atRunDir(f));
+    for (const f of extractRedirectTargets(segment)) paths.push(atRunDir(f));
+  }
+  for (const p of new Set(paths)) enqueueRewrittenPath(p);
+  for (const dir of sweepDirs) for (const p of workingTreeStatusPaths(dir)) enqueueSweptPath(p);
+}
+function enqueueSweptPath(absPath) {
+  try {
+    if (!statSync(absPath).isFile()) return;
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT" && code !== "ENOTDIR") return;
+  }
+  enqueueDirtyPathSafe(absPath, { alreadyResolved: true });
+}
+var PIPELINE_PASSTHROUGH_HEADS = /* @__PURE__ */ new Set(["head", "tail", "cat", "tee", "less", "more"]);
+var CI_FILTER_NAMES = /^(?:generic-ci|jest|vitest|pytest|go_test|cargo_test|cargo|go|make|cmake|gradle|maven|dotnet|turbo|nx|lerna|webpack|eslint|ruff|clippy|flake8|mypy|prettier|tsc)$/;
+function isCiBuildTestSegment(cleaned, cwd) {
+  if (isTestRunnerCommand(cleaned) || isBuildCommand(cleaned) || isTscCommand(cleaned)) return true;
+  if (/^\s*(npm|pnpm|yarn|bun)\s+(run\s+)?(test|build|lint|typecheck|check|ci|guards)\b/i.test(cleaned)) return true;
+  if (/^\s*(cargo|go|dotnet|make|gradle|mvn|pytest|vitest|jest|eslint|ruff)\b/i.test(cleaned)) return true;
+  const detected = detectFromCommand(cleaned, cwd ?? void 0);
+  if (detected !== null && CI_FILTER_NAMES.test(detected.filter.name)) return true;
+  return false;
+}
+function pipelineShapeFilter(cmd, cwd) {
+  if (hasUnquotedOperator(cmd, ["&&", "||", ";"])) {
+    const forSplit2 = cmd.replace(/\s2>(?:&1|\/dev\/null)/g, "");
+    if (hasBareBackgroundOrNewline(forSplit2)) return null;
+    const segments2 = splitShellSegments(forSplit2);
+    if (segments2.length >= 2) {
+      let recognizedCiCount = 0;
+      for (const segment of segments2) {
+        const cleaned = stripOutputPipeline(segment.trim());
+        if (cleaned.length === 0) continue;
+        if (isCiBuildTestSegment(cleaned, cwd)) {
+          recognizedCiCount++;
+        }
+      }
+      if (recognizedCiCount > 0) {
+        const ci = filterByName("generic-ci");
+        return ci === null ? null : { filter: ci, argv: [] };
+      }
+    }
+    return null;
+  }
+  const forSplit = cmd.replace(/\s2>(?:&1|\/dev\/null)/g, "");
+  if (hasBareBackgroundOrNewline(forSplit)) return null;
+  const segments = splitShellSegments(forSplit);
+  if (segments.length < 2) return null;
+  for (const segment of segments.slice(1)) {
+    const head = safeShlexSplit(segment)?.[0];
+    if (head === void 0) return null;
+    if (!PIPELINE_PASSTHROUGH_HEADS.has(head.replace(/^.*[/\\]/, ""))) return null;
+  }
+  const detected = detectFromCommand(stripOutputPipeline(cmd), cwd ?? void 0);
+  return detected === null ? null : { filter: detected.filter, argv: detected.argv };
+}
+function recallStageTokens(cmd) {
+  const forSplit = cmd.replace(/\s2>(?:&1|\/dev\/null)/g, "");
+  if (hasBareBackgroundOrNewline(forSplit)) return null;
+  const first = splitShellSegments(forSplit)[0];
+  if (first === void 0) return null;
+  const args = tokenGoatInvocation(stripOutputPipeline(first));
+  if (args === null) return null;
+  return Object.values(RECALL_COMMAND).includes(args[0] ?? "") ? ["token-goat", ...args] : null;
+}
+function tokenGoatInvocation(segment) {
+  const tokens = safeShlexSplit(segment);
+  if (tokens === null || tokens.length === 0) return null;
+  const base = (t) => t.replace(/^.*[/\\]/, "").replace(/\.exe$/i, "").toLowerCase();
+  const head = base(tokens[0] ?? "");
+  if (head === "token-goat" || head === "tg") return tokens.slice(1);
+  if (head === "node") {
+    const script = tokens[1];
+    return script !== void 0 && /(?:^|[/\\:])token-goat(?:\.core)?\.mjs$/i.test(script) ? tokens.slice(2) : null;
+  }
+  if (head === "npx") {
+    let i = 1;
+    while (tokens[i] === "-y" || tokens[i] === "--yes") i++;
+    return /^token-goat(?:@\S+)?$/.test(tokens[i] ?? "") ? tokens.slice(i + 1) : null;
+  }
+  return null;
+}
+function isTokenGoatOwnCommand(cmd) {
+  const forSplit = cmd.replace(/\s2>(?:&1|\/dev\/null)/g, "");
+  if (hasBareBackgroundOrNewline(forSplit)) return false;
+  const first = splitShellSegments(forSplit)[0];
+  return first !== void 0 && tokenGoatInvocation(stripOutputPipeline(first)) !== null;
+}
+function isRecallCommand(cmd) {
+  return recallStageTokens(cmd) !== null;
+}
+function isFullRecallCommand(cmd) {
+  return recallStageTokens(cmd)?.includes("--full") === true;
+}
+function pureFileReadPath(cmd) {
+  const single = extractCatFile(cmd)?.filePath ?? extractHeadFile(cmd)?.filePath ?? extractTailFile(cmd)?.filePath ?? extractLineRangeRead(cmd)?.filePath;
+  if (single !== void 0) return single;
+  return singleFileCompoundReadPath(cmd);
+}
+function singleFileCompoundReadPath(cmd) {
+  const reads = extractLineRangeReadsCompound(cmd);
+  if (reads === null || reads.length !== 1) return null;
+  return reads[0]?.filePath ?? null;
+}
+function deliveredLineNumbers(cmd, lineCount) {
+  const ranged = extractLineRangeRead(cmd);
+  if (ranged !== null) {
+    const nums = [];
+    for (const [lo, hi] of ranged.ranges) for (let n = lo; n <= hi; n++) nums.push(n);
+    if (nums.length === 0) return null;
+    while (nums.length < lineCount) nums.push((nums[nums.length - 1] ?? 0) + 1);
+    return nums;
+  }
+  if (extractCatFile(cmd) !== null || extractHeadFile(cmd) !== null) return Array.from({ length: lineCount }, (_, i) => i + 1);
+  if (singleFileCompoundReadPath(cmd) !== null) return Array.from({ length: lineCount }, () => null);
+  return null;
+}
+var WHOLE_FILE_DUMP_RE = /^(?:(?:cat|type|Get-Content|gc)|(?:head|tail)[ \t]+-n[ \t]+\d+)[ \t]+(?:"([A-Za-z0-9._\-/\\:+@ ]+)"|'([A-Za-z0-9._\-/\\:+@ ]+)'|([A-Za-z0-9._\-/\\:+@]+))(?:[ \t]+2>(?:&1|\/dev\/null))?[ \t]*$/i;
+function isWholeFileDump(cmd, extractedPath) {
+  const m = WHOLE_FILE_DUMP_RE.exec(cmd);
+  if (m === null) return false;
+  const shaped = m[1] ?? m[2] ?? m[3];
+  return shaped !== void 0 && shaped === extractedPath;
+}
+function unwrapCompressCommand(executed) {
+  const t = executed.trim();
+  if (!/^(?:token-goat|tg)\s+compress\b/.test(t)) return null;
+  let argv;
+  try {
+    argv = shlexSplit(t);
+  } catch {
+    return null;
+  }
+  for (let i = 0; i + 1 < argv.length; i++) {
+    const tok = argv[i];
+    if (tok === "-c" || tok === "--cmd") return argv[i + 1] ?? null;
+    if (tok === "--cmd-b64") {
+      try {
+        return Buffer.from(argv[i + 1] ?? "", "base64").toString("utf8");
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+function detectUnbalancedShellSyntax(cmd) {
+  let inSingle = false;
+  let inDouble = false;
+  let i = 0;
+  while (i < cmd.length) {
+    const ch = cmd[i];
+    if (inSingle) {
+      if (ch === "'") {
+        inSingle = false;
+      }
+      i++;
+      continue;
+    }
+    if (inDouble) {
+      if (ch === "\\" && i + 1 < cmd.length) {
+        i += 2;
+        continue;
+      }
+      if (ch === '"') {
+        inDouble = false;
+      }
+      i++;
+      continue;
+    }
+    if (ch === "\\" && i + 1 < cmd.length) {
+      i += 2;
+      continue;
+    }
+    if (ch === "$" && cmd[i + 1] === "(" && cmd[i + 2] === "(") {
+      let depth = 2;
+      let j = i + 3;
+      while (j < cmd.length && depth > 0) {
+        if (cmd[j] === "(") depth++;
+        else if (cmd[j] === ")") depth--;
+        j++;
+      }
+      i = j;
+      continue;
+    }
+    if (ch === "$" && cmd[i + 1] === "'") {
+      let j = i + 2;
+      let closed = false;
+      while (j < cmd.length) {
+        if (cmd[j] === "\\") {
+          j += 2;
+          continue;
+        }
+        if (cmd[j] === "'") {
+          j++;
+          closed = true;
+          break;
+        }
+        j++;
+      }
+      if (!closed) {
+        inSingle = true;
+        break;
+      }
+      i = j;
+      continue;
+    }
+    if (ch === "#" && (i === 0 || /\s/.test(cmd[i - 1] ?? ""))) {
+      const nl = cmd.indexOf("\n", i);
+      i = nl === -1 ? cmd.length : nl + 1;
+      continue;
+    }
+    if (ch === "'") {
+      inSingle = true;
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      inDouble = true;
+      i++;
+      continue;
+    }
+    if (ch === "<" && i + 1 < cmd.length && cmd[i + 1] === "<") {
+      if (i + 2 < cmd.length && cmd[i + 2] === "<") {
+        i += 3;
+        continue;
+      }
+      let j = i + 2;
+      let hasIndentModifier = false;
+      if (j < cmd.length && (cmd[j] === "-" || cmd[j] === "~")) {
+        hasIndentModifier = true;
+        j++;
+      }
+      while (j < cmd.length && cmd[j] === " ") {
+        j++;
+      }
+      if (j < cmd.length) {
+        let delimStart = j;
+        if (cmd[j] === '"' || cmd[j] === "'") {
+          delimStart = j + 1;
+          const quoteChar = cmd[j];
+          let delimEnd = delimStart;
+          while (delimEnd < cmd.length && cmd[delimEnd] !== quoteChar) {
+            delimEnd++;
+          }
+          if (delimEnd >= cmd.length) {
+            return "an unclosed quote in a heredoc opener";
+          }
+          j = delimEnd + 1;
+        } else {
+          let delimEnd = delimStart;
+          while (delimEnd < cmd.length && /\w/.test(cmd.charAt(delimEnd))) {
+            delimEnd++;
+          }
+          j = delimEnd;
+        }
+        const delimiter = cmd.slice(delimStart, j).replace(/["']/g, "");
+        if (delimiter) {
+          let scanPos = j;
+          let terminatorEnd = -1;
+          while (scanPos <= cmd.length) {
+            const nl = cmd.indexOf("\n", scanPos);
+            const lineEnd = nl === -1 ? cmd.length : nl;
+            let line = cmd.slice(scanPos, lineEnd);
+            if (line.endsWith("\r")) {
+              line = line.slice(0, -1);
+            }
+            const isMatch = hasIndentModifier ? line.trim() === delimiter : line === delimiter;
+            if (isMatch) {
+              terminatorEnd = nl === -1 ? cmd.length : nl + 1;
+              break;
+            }
+            if (nl === -1) break;
+            scanPos = nl + 1;
+          }
+          if (terminatorEnd === -1) {
+            return `an unterminated heredoc (${delimiter} never appears on its own line)`;
+          }
+          i = terminatorEnd;
+          continue;
+        }
+      }
+    }
+    i++;
+  }
+  if (inSingle) {
+    return "an unclosed single quote";
+  }
+  if (inDouble) {
+    return "an unclosed double quote";
+  }
+  return null;
+}
+
+export {
+  runRecallCommand,
+  stripCdPrefix,
+  stripGroupAndExports,
+  stripCommandPrefix,
+  stripTrailingStderrRedirect,
+  hasTestRunScopeOrBudget,
+  isDirectTestRunnerCommand,
+  resolveCdHintPath,
+  cdPrefixCwd,
+  commandRunDir,
+  bashRecallKey,
+  resolveBashCall,
+  pipelineDivergenceNote,
+  cachedRunCoversCommand,
+  extractCommand,
+  isHeadMovingGitCommand,
+  ORIG_HEAD_ELIGIBLE_GIT_RE,
+  ORIG_HEAD_REFLOG_MSG_RE,
+  gitRepoRootOrNull,
+  enqueueNonHeadMovingRewrites,
+  PIPELINE_PASSTHROUGH_HEADS,
+  pipelineShapeFilter,
+  isTokenGoatOwnCommand,
+  isRecallCommand,
+  isFullRecallCommand,
+  pureFileReadPath,
+  deliveredLineNumbers,
+  isWholeFileDump,
+  unwrapCompressCommand,
+  detectUnbalancedShellSyntax
+};