token-goat 2.9.13 → 2.9.14

package/dist/{token-goat-chunk-JOXLE672.mjs → token-goat-chunk-VZYD4OZB.mjs}

@@ -1,17 +1,26 @@
 import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
+  DEFAULT_MAX_AGE_MS,
+  blobPath,
   countRedactionPlaceholders,
-  detectHarness,
-  loadConfig,
-  parse,
+  getDb,
+  isBlobStale,
+  loadBlob,
   recordStat,
   recordUnmappedTool,
   redactSecrets,
   savedTokensFromBytes,
-  stringify,
+  storeBlob,
   stripAnsiEscapes
-} from "./token-goat-chunk-UMXJN7DI.mjs";
+} from "./token-goat-chunk-T2IWWTHB.mjs";
+import {
+  detectHarness,
+  loadConfig,
+  parse,
+  shortFingerprint,
+  stringify
+} from "./token-goat-chunk-SAQ5PG4L.mjs";
 import {
   registerReset
 } from "./token-goat-chunk-EEIDFMEM.mjs";
@@ -24,16 +33,21 @@ import {
   ensureDirSync,
   escapeRegExp,
   extractErrorMessage,
+  foldPath,
+  globalDbPath,
   hookCommandFor,
   hookPowershellCommand,
+  isCaseInsensitiveFs,
   neutralizeOutsideFences,
   normalizeDarwinSystemAlias,
+  normalizePath,
   projectPathIsConsultable,
   projectScopeRoot,
   recordCreatedConfig,
   removeCreatedBackups,
   removeFileInScope,
   resolveIndexPath,
+  runGit,
   safeSlice,
   stripDelimitedBlock,
   stripOwnHooksFromMap,
@@ -43,7 +57,7 @@ import {
   withInstallScope,
   writeIfDifferent,
   writeJsonSettings
-} from "./token-goat-chunk-QKXBGBQR.mjs";
+} from "./token-goat-chunk-AMYCQJX4.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -842,12 +856,12 @@ async function main() {
     return
   }
 
-  process.stdout.write(JSON.stringify(translate(copilotEvent, resp, toolName, originalToolArgs)))
+  process.stdout.write(JSON.stringify(translate(copilotEvent, resp, toolName, originalToolArgs, payload)))
 }
 
 ${MATERIALIZE_SHRUNK_IMAGE_JS}
 
-function translate(copilotEvent, resp, toolName, originalToolArgs) {
+function translate(copilotEvent, resp, toolName, originalToolArgs, payload) {
   if (copilotEvent === 'preToolUse') {
     const hso = resp && resp.hookSpecificOutput
     const denied = resp && (resp.decision === 'block' || (hso && hso.permissionDecision === 'deny'))
@@ -869,52 +883,20 @@ function translate(copilotEvent, resp, toolName, originalToolArgs) {
   }
 
   if (copilotEvent === 'postToolUse') {
-    // Verified against the shipping @github/copilot 1.0.80 bundle, not against the docs page.
-    // NativeHookPipelineProcessor.postToolExecution (app.js offset 2043150) gates on
-    // toolResult.resultType === "success", then does n.toolResultJson && CSr(e.toolResult,
-    // n.toolResultJson), where CSr (offset 2032350) is an in-place Object.assign; the mutated
-    // object is re-serialized back to native in the postTool callback at offset 1793926. So
-    // modifiedResult IS honored on this event, and token-goat's rewriteOutput producers
-    // (compression, injection fencing, image shrink) really do reach the model. resultType is
-    // hardcoded 'success' because success is the only branch this event ever runs on.
-    //
-    // additionalContext on THIS event is dropped on the JS path. grep -abo "onAdditionalContext:"
-    // app.js returns nothing, so the callback is never supplied, and the two "onAdditionalContext?"
-    // call sites (offsets 2041896 and 2043300) are both no-ops. preToolsExecution (offset 2041832)
-    // additionally pushes each context into an array that IS drained into the native return
-    // payload (additional_contexts, offset 1791950); postToolExecution has no such push and its
-    // native return payload (offset 1793926) has no additional_contexts key. Residual, stated
-    // honestly: the native hookProcessorPostToolUse might fold additionalContext into the
-    // toolResultJson it returns, and that was NOT verified. The evidence leans against it, since
-    // the failure sibling path appends its context explicitly in JS via
-    // hookAppendPostToolUseFailureContext and there is no success-path counterpart. The
-    // out.additionalContext below is kept as cheap best-effort, not as a channel anything should
-    // depend on -- see src/pending_context.ts, whose whole design depended on it.
-    //
-    // Failed tool calls never reach this event. postToolUse and postToolUseFailure are two
-    // distinct hook events (both listed in the runtime.node hook-event enum at offset 101618150),
-    // and the shipped copilot-sdk/types.d.ts says onPostToolUse "does not fire for non-success
-    // results". The failure event cannot carry a fence either: PostToolUseFailureHookInput carries
-    // only a stringified error message, not the tool result, and PostToolUseFailureHookOutput
-    // consumes only additionalContext -- "modifiedResult or suppressOutput are not honored for
-    // failure hooks". rejected/denied/timeout results trigger no post hook at all. So on Copilot,
-    // the output of a failed tool call reaches the model unfenced, uncompressed and unshrunk, and
-    // no response shape this shim could emit changes that. That gap is real and still open. What
-    // is now wired is the narrower thing that IS possible there: the postToolUseFailure branch
-    // below carries advisory text alongside the failure, and never rewrites it.
-    //
-    // Emitted camelCase-only. The inbound side around line 247 also tolerates a snake_case "VS
-    // Code compatible" shape, and this comment used to justify the camelCase choice by claiming
-    // PascalCase event registration selects the snake_case response format. That reasoning is
-    // UNVERIFIED in 1.0.80: every hook-response field in the native string tables is camelCase,
-    // and the snake_case hits in the bundle are unrelated internal Rust identifiers. camelCase
-    // stays because it is what the bundle reads; the old justification is no longer asserted.
+    // modifiedResult is honored on success: rewriteOutput (compression, fencing, image shrink) reaches LLM.
+    // additionalContext is dropped on Copilot CLI JS path; we fold context into modifiedResult.textResultForLlm.
     const hso = resp && resp.hookSpecificOutput
     const updatedToolOutput = hso && hso.updatedToolOutput
     const context = extractContext(resp)
     const out = {}
     if (typeof updatedToolOutput === 'string') {
       out.modifiedResult = { resultType: 'success', textResultForLlm: updatedToolOutput }
+    } else if (context) {
+      const rawResult = payload && payload.toolResult
+      const originalText = rawResult && (typeof rawResult.textResultForLlm === 'string' ? rawResult.textResultForLlm : typeof rawResult.text_result_for_llm === 'string' ? rawResult.text_result_for_llm : undefined)
+      if (typeof originalText === 'string') {
+        out.modifiedResult = { resultType: 'success', textResultForLlm: originalText + '\\n\\n[token-goat: ' + context + ']' }
+      }
     }
     if (context) out.additionalContext = context
     return out
@@ -1747,6 +1729,10 @@ function getCwd(event) {
   const value = event.raw && typeof event.raw === "object" ? event.raw["cwd"] : void 0;
   return typeof value === "string" && value !== "" ? value : void 0;
 }
+function getTranscriptPath(event) {
+  const value = event.raw && typeof event.raw === "object" ? event.raw["transcript_path"] : void 0;
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
 function extractToolResponseField(raw, keys) {
   const resp = raw["tool_response"];
   if (typeof resp === "string") return resp;
@@ -2954,9 +2940,1032 @@ function byteLength(s) {
   return utf8Len(s);
 }
 
-// src/install.ts
+// src/index_reader.ts
+init_define_import_meta_env();
+
+// src/sql_path.ts
+init_define_import_meta_env();
+function pathEqClause(column) {
+  return isCaseInsensitiveFs() ? `TG_LOWER(${column}) = ?` : `${column} = ?`;
+}
+function pathSuffixClause(column) {
+  const col = isCaseInsensitiveFs() ? `TG_LOWER(${column})` : column;
+  return {
+    // Both separators are accepted because not every writer into `symbols` stores a normalizePath'd (forward-slash) file_path, and the JS-side path-boundary test this narrowing feeds treats `/` and `\` alike.
+    clause: `(${col} = ? OR substr(${col}, -length(?)) = ? OR substr(${col}, -length(?)) = ?)`,
+    params: (baseName) => {
+      const folded = foldPath(baseName);
+      return [folded, `/${folded}`, `/${folded}`, `\\${folded}`, `\\${folded}`];
+    }
+  };
+}
+function projectScopeClause(column) {
+  const caseInsensitive = isCaseInsensitiveFs();
+  const col = caseInsensitive ? `TG_LOWER(${column})` : column;
+  return {
+    // Parenthesised so an OR anywhere in the surrounding WHERE cannot bind tighter than the pair.
+    clause: `(${col} >= ? AND ${col} < ?)`,
+    params: (root) => {
+      const folded = caseInsensitive ? foldPath(normalizePath(root)) : normalizePath(root);
+      const lower = folded.endsWith("/") ? folded : `${folded}/`;
+      const upper = `${lower.slice(0, -1)}0`;
+      return [lower, upper];
+    }
+  };
+}
+
+// src/index_reader.ts
+function toSymbolEntry(row) {
+  return {
+    filePath: row.file_path,
+    name: row.name,
+    kind: row.kind,
+    lineStart: row.line_start,
+    lineEnd: row.line_end,
+    body: row.body ?? "",
+    docstring: row.docstring ?? "",
+    parent: row.parent ?? ""
+  };
+}
+function toRefEntry(row) {
+  return {
+    filePath: row.file_path,
+    name: row.name,
+    line: row.line,
+    col: row.col,
+    context: row.context ?? ""
+  };
+}
+function applyRootDirScope(rootDir, column, where, params) {
+  if (rootDir === void 0) return;
+  const { clause, params: bounds } = projectScopeClause(column);
+  where.push(clause);
+  params.push(...bounds(rootDir));
+}
+function buildSymbolWhere(opts) {
+  const where = [];
+  const params = [];
+  if (opts.name !== void 0) {
+    where.push("name = ?");
+    params.push(opts.name);
+  }
+  if (opts.filePath !== void 0) {
+    where.push(pathEqClause("file_path"));
+    params.push(foldPath(opts.filePath));
+  }
+  if (opts.kind !== void 0) {
+    where.push("kind = ?");
+    params.push(opts.kind);
+  }
+  if (opts.fileBaseName !== void 0) {
+    const { clause: suffixClause, params: suffixParams } = pathSuffixClause("file_path");
+    where.push(suffixClause);
+    params.push(...suffixParams(opts.fileBaseName));
+  }
+  if (opts.enclosingLine !== void 0) {
+    where.push("line_start <= ? AND ? <= line_end");
+    params.push(opts.enclosingLine, opts.enclosingLine);
+  }
+  applyRootDirScope(opts.rootDir, "file_path", where, params);
+  return { clause: where.length > 0 ? `WHERE ${where.join(" AND ")}` : "", params };
+}
+var DEFAULT_QUERY_LIMIT = 100;
+function querySymbols(opts = {}, dbPath = globalDbPath()) {
+  const { clause, params } = buildSymbolWhere(opts);
+  const limit = opts.limit ?? DEFAULT_QUERY_LIMIT;
+  const offset = opts.offset ?? 0;
+  const sql = `SELECT file_path, name, kind, line_start, line_end, body, docstring, parent FROM symbols ${clause} ORDER BY file_path, line_start, rowid LIMIT ? OFFSET ?`;
+  const db = getDb(dbPath);
+  const rows = db.prepare(sql).all(...params, limit, offset);
+  return rows.map(toSymbolEntry);
+}
+function distinctSymbolKinds(rootDir, dbPath = globalDbPath()) {
+  const where = [];
+  const params = [];
+  applyRootDirScope(rootDir, "file_path", where, params);
+  const clause = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
+  const db = getDb(dbPath);
+  const rows = db.prepare(`SELECT DISTINCT kind FROM symbols ${clause} ORDER BY kind`).all(...params);
+  return rows.map((r) => r.kind);
+}
+function countSymbols(opts = {}, dbPath = globalDbPath()) {
+  const { clause, params } = buildSymbolWhere(opts);
+  const sql = `SELECT COUNT(*) as cnt FROM symbols ${clause}`;
+  const db = getDb(dbPath);
+  const row = db.prepare(sql).get(...params);
+  return row.cnt;
+}
+function buildRefsWhere(opts) {
+  const where = ["name = ?"];
+  const params = [opts.name];
+  if (opts.filePath !== void 0) {
+    where.push(pathEqClause("file_path"));
+    params.push(foldPath(opts.filePath));
+  }
+  applyRootDirScope(opts.rootDir, "file_path", where, params);
+  return { clause: `WHERE ${where.join(" AND ")}`, params };
+}
+function queryRefs(opts, dbPath = globalDbPath()) {
+  const { clause, params } = buildRefsWhere(opts);
+  const limit = opts.limit ?? DEFAULT_QUERY_LIMIT;
+  const sql = `SELECT file_path, name, line, col, context FROM refs ${clause} ORDER BY file_path, line LIMIT ?`;
+  const db = getDb(dbPath);
+  const rows = db.prepare(sql).all(...params, limit);
+  return rows.map(toRefEntry);
+}
+function countRefs(opts, dbPath = globalDbPath()) {
+  const { clause, params } = buildRefsWhere(opts);
+  const sql = `SELECT COUNT(*) as cnt FROM refs ${clause}`;
+  const db = getDb(dbPath);
+  const row = db.prepare(sql).get(...params);
+  return row.cnt;
+}
+function queryRefsByContext(context, filePath, dbPath = globalDbPath()) {
+  const sql = `SELECT file_path, name, line, col, context FROM refs WHERE context = ? AND ${pathEqClause("file_path")} ORDER BY line LIMIT 20`;
+  const db = getDb(dbPath);
+  const rows = db.prepare(sql).all(context, foldPath(filePath));
+  return rows.map(toRefEntry);
+}
+var REF_COUNT_BATCH = 900;
+function queryRefCounts(names, dbPath = globalDbPath(), rootDir) {
+  const counts = /* @__PURE__ */ new Map();
+  if (names.length === 0) return counts;
+  const db = getDb(dbPath);
+  const scopeWhere = [];
+  const scopeParams = [];
+  applyRootDirScope(rootDir, "file_path", scopeWhere, scopeParams);
+  const scopeSql = scopeWhere.length > 0 ? ` AND ${scopeWhere.join(" AND ")}` : "";
+  const sqlFor = (width) => `SELECT name, COUNT(*) as c FROM refs WHERE name IN (${Array.from({ length: width }, () => "?").join(", ")})${scopeSql} GROUP BY name`;
+  const full = names.length >= REF_COUNT_BATCH ? db.prepare(sqlFor(REF_COUNT_BATCH)) : void 0;
+  db.transaction(() => {
+    for (let start = 0; start < names.length; start += REF_COUNT_BATCH) {
+      const batch = names.slice(start, start + REF_COUNT_BATCH);
+      const stmt = batch.length === REF_COUNT_BATCH && full !== void 0 ? full : db.prepare(sqlFor(batch.length));
+      for (const row of stmt.all(...batch, ...scopeParams)) {
+        counts.set(row.name, row.c);
+      }
+    }
+  })();
+  return counts;
+}
+function getProjectFileEntries(rootDir, dbPath = globalDbPath()) {
+  const db = getDb(dbPath);
+  const { clause, params } = projectScopeClause("path");
+  const rows = db.prepare(`SELECT path, sha, mtime, language, indexed_at, embed_sha, parser_sha FROM files WHERE ${clause}`).all(...params(rootDir));
+  const out = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    out.set(foldPath(row.path), {
+      filePath: row.path,
+      sha: row.sha ?? "",
+      mtime: row.mtime ?? 0,
+      language: row.language ?? "unknown",
+      indexedAt: row.indexed_at ?? 0,
+      embedSha: row.embed_sha ?? "",
+      parserSha: row.parser_sha ?? ""
+    });
+  }
+  return out;
+}
+function getFileEntry(filePath, dbPath = globalDbPath()) {
+  const db = getDb(dbPath);
+  const row = db.prepare(
+    `SELECT path, sha, mtime, language, indexed_at, embed_sha, parser_sha FROM files WHERE ${pathEqClause("path")}`
+  ).get(foldPath(filePath));
+  if (row === void 0) return null;
+  return {
+    filePath: row.path,
+    sha: row.sha ?? "",
+    mtime: row.mtime ?? 0,
+    language: row.language ?? "unknown",
+    indexedAt: row.indexed_at ?? 0,
+    embedSha: row.embed_sha ?? "",
+    parserSha: row.parser_sha ?? ""
+  };
+}
+function sanitizeFtsQuery(query, join11 = "AND") {
+  const terms = query.split(/\s+/).filter((t) => t.length > 0).map((t) => '"' + t.replace(/"/g, '""') + '"');
+  return terms.join(join11 === "OR" ? " OR " : " ");
+}
+function runFtsQuery(db, match, limit, scope, rootDir) {
+  const sql = `SELECT s.file_path, s.name, s.kind, s.line_start, s.line_end, s.body, s.docstring, s.parent FROM symbols_fts JOIN symbols s ON s.id = symbols_fts.rowid WHERE symbols_fts MATCH ?${scope !== void 0 ? ` AND ${scope.clause}` : ""} ORDER BY bm25(symbols_fts) LIMIT ?`;
+  const params = [match];
+  if (scope !== void 0 && rootDir !== void 0) {
+    params.push(...scope.params(rootDir));
+  }
+  params.push(limit);
+  const rows = db.prepare(sql).all(...params);
+  return rows.map(toSymbolEntry);
+}
+function searchSymbolsFts(query, limit = 50, dbPath = globalDbPath(), rootDir) {
+  const andMatch = sanitizeFtsQuery(query, "AND");
+  if (andMatch === "") return [];
+  const db = getDb(dbPath);
+  const scope = rootDir !== void 0 ? projectScopeClause("s.file_path") : void 0;
+  try {
+    const andResults = runFtsQuery(db, andMatch, limit, scope, rootDir);
+    if (andResults.length > 0) return andResults;
+    const orMatch = sanitizeFtsQuery(query, "OR");
+    if (orMatch === andMatch) return andResults;
+    return runFtsQuery(db, orMatch, limit, scope, rootDir);
+  } catch {
+    return [];
+  }
+}
+
+// src/bash_output_cache.ts
+init_define_import_meta_env();
+import { readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
+import { resolve as resolve4 } 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(basename2) {
+  return LOCK_FILE_NAMES.has(basename2.toLowerCase());
+}
+function isManifestFile(basename2) {
+  const lower = basename2.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(basename2))) 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 fs7 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 && fs7.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(path12) {
+  try {
+    const stat = statSync3(path12);
+    if (!stat.isDirectory()) return null;
+    const entries = readdirSync2(path12);
+    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(path12) {
+  try {
+    const stat = statSync3(path12);
+    if (!stat.isFile()) return null;
+    if (stat.size <= FILE_FINGERPRINT_CONTENT_CAP_BYTES) {
+      return shortFingerprint(readFileSync5(path12));
+    }
+    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 = readFileSync5(resolve4(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 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 resolve4(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 = 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);
+  storeBlob(BASH_OUTPUT_SUBDIR, id, entry);
+  indexRecallEntry("bash", id, redactedCommand, `${redactedCommand}
+${redactedOutput}`, entry.storedAt);
+  return id;
+}
+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 entry = coerceBashEntry(loadBlob(BASH_OUTPUT_SUBDIR, id));
+  if (entry === null) return null;
+  _byId.set(id, entry);
+  return entry;
+}
+registerReset(() => {
+  _byId = /* @__PURE__ */ new Map();
+});
+
+// src/install.ts
+init_define_import_meta_env();
+import * as fs8 from "node:fs";
 import * as os4 from "node:os";
 import * as path7 from "node:path";
 
@@ -3140,7 +4149,7 @@ var SettingsParseError = class extends Error {
 function readSettings(p, opts = {}) {
   let raw;
   try {
-    raw = fs7.readFileSync(p, "utf8");
+    raw = fs8.readFileSync(p, "utf8");
   } catch {
     return {};
   }
@@ -3272,7 +4281,7 @@ function isInstalled(scope = "user") {
   const hooks = settings.hooks;
   if (hooks === void 0) return false;
   const scriptPath = claudeHookScriptPath();
-  if (!fs7.existsSync(scriptPath)) return false;
+  if (!fs8.existsSync(scriptPath)) return false;
   for (const [eventKey, eventArg] of HOOK_EVENT_MAP) {
     const expectedCommand = hookCommandFor(scriptPath, eventArg);
     if (!groupHasTokenGoat(hooks[eventKey], (c) => c === expectedCommand)) return false;
@@ -3310,7 +4319,7 @@ function findStrayClaudeMdBlocks(searchRoot) {
   const root = searchRoot ?? path7.join(os4.homedir(), ".claude");
   const canonical = path7.resolve(claudeMdPath());
   const found = [];
-  if (!fs7.existsSync(root)) return found;
+  if (!fs8.existsSync(root)) return found;
   const SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git"]);
   const MAX_DEPTH = 6;
   const hasRealBlock = (text) => {
@@ -3326,7 +4335,7 @@ function findStrayClaudeMdBlocks(searchRoot) {
     if (depth > MAX_DEPTH) return;
     let entries;
     try {
-      entries = fs7.readdirSync(dir, { withFileTypes: true });
+      entries = fs8.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -3340,7 +4349,7 @@ function findStrayClaudeMdBlocks(searchRoot) {
       if (path7.resolve(full) === canonical) continue;
       let text;
       try {
-        text = fs7.readFileSync(full, "utf8");
+        text = fs8.readFileSync(full, "utf8");
       } catch {
         continue;
       }
@@ -3378,7 +4387,7 @@ function installSkill() {
   const p = skillPath();
   let existing = null;
   try {
-    existing = fs7.readFileSync(p, "utf8");
+    existing = fs8.readFileSync(p, "utf8");
   } catch {
   }
   const skillContent = skillMdContent();
@@ -3390,17 +4399,17 @@ function installSkill() {
 }
 function uninstallSkill() {
   const dir = skillDir();
-  if (!fs7.existsSync(dir)) return false;
+  if (!fs8.existsSync(dir)) return false;
   removeCreatedBackups(skillPath());
   assertWriteInScope(dir);
-  fs7.rmSync(dir, { recursive: true, force: true });
+  fs8.rmSync(dir, { recursive: true, force: true });
   return true;
 }
 
 // src/bridges/codex_install.ts
 init_define_import_meta_env();
 import * as crypto2 from "node:crypto";
-import * as fs8 from "node:fs";
+import * as fs9 from "node:fs";
 import * as os5 from "node:os";
 import * as path8 from "node:path";
 
@@ -3567,7 +4576,7 @@ function codexHookScriptPath() {
 function readCodexConfig(p, opts = {}) {
   let raw;
   try {
-    raw = fs8.readFileSync(p, "utf8");
+    raw = fs9.readFileSync(p, "utf8");
   } catch {
     return {};
   }
@@ -3773,7 +4782,7 @@ function uninstallCodex() {
     removedAny = true;
   }
   try {
-    fs8.unlinkSync(scriptPath);
+    fs9.unlinkSync(scriptPath);
     removedAny = true;
   } catch {
   }
@@ -3809,10 +4818,10 @@ function isCodexInstalled() {
     const expectedHash = computeCodexHookHash(eventArg, expectedCommand);
     if (hooksState[stateKey]?.trusted_hash !== expectedHash) return false;
   }
-  if (!fs8.existsSync(scriptPath)) return false;
+  if (!fs9.existsSync(scriptPath)) return false;
   let agents;
   try {
-    agents = fs8.readFileSync(codexAgentsPath(), "utf8");
+    agents = fs9.readFileSync(codexAgentsPath(), "utf8");
   } catch {
     return false;
   }
@@ -3837,7 +4846,7 @@ function stripAgentsBlock(p) {
 
 // src/bridges/kimi_install.ts
 init_define_import_meta_env();
-import * as fs9 from "node:fs";
+import * as fs10 from "node:fs";
 import * as os6 from "node:os";
 import * as path9 from "node:path";
 
@@ -3967,7 +4976,7 @@ function kimiSkillPath() {
 function readKimiConfig(p, opts = {}) {
   let raw;
   try {
-    raw = fs9.readFileSync(p, "utf8");
+    raw = fs10.readFileSync(p, "utf8");
   } catch {
     return {};
   }
@@ -4070,16 +5079,16 @@ function uninstallKimi() {
   }
   if (stripKimiAgentsBlock(kimiAgentsPath())) removed = true;
   try {
-    if (fs9.existsSync(kimiSkillDir())) {
+    if (fs10.existsSync(kimiSkillDir())) {
       removeCreatedBackups(kimiSkillPath());
-      fs9.rmSync(kimiSkillDir(), { recursive: true, force: true });
+      fs10.rmSync(kimiSkillDir(), { recursive: true, force: true });
       removed = true;
     }
   } catch {
   }
   try {
-    if (fs9.existsSync(kimiHookScriptPath())) {
-      fs9.rmSync(kimiHookScriptPath(), { force: true });
+    if (fs10.existsSync(kimiHookScriptPath())) {
+      fs10.rmSync(kimiHookScriptPath(), { force: true });
       removed = true;
     }
   } catch {
@@ -4100,7 +5109,7 @@ function isKimiInstalled() {
 
 // src/bridges/grok_install.ts
 init_define_import_meta_env();
-import * as fs10 from "node:fs";
+import * as fs11 from "node:fs";
 import * as os7 from "node:os";
 import * as path10 from "node:path";
 
@@ -4244,12 +5253,12 @@ function uninstallGrok() {
   const scriptPath = grokHookScriptPath();
   let removedAny = false;
   try {
-    fs10.unlinkSync(configPath);
+    fs11.unlinkSync(configPath);
     removedAny = true;
   } catch {
   }
   try {
-    fs10.unlinkSync(scriptPath);
+    fs11.unlinkSync(scriptPath);
     removedAny = true;
   } catch {
   }
@@ -4257,12 +5266,12 @@ function uninstallGrok() {
   return removedAny;
 }
 function isGrokInstalled() {
-  return fs10.existsSync(grokConfigPath()) && fs10.existsSync(grokHookScriptPath());
+  return fs11.existsSync(grokConfigPath()) && fs11.existsSync(grokHookScriptPath());
 }
 
 // src/bridges/vscode_install.ts
 init_define_import_meta_env();
-import * as fs11 from "node:fs";
+import * as fs12 from "node:fs";
 import * as os8 from "node:os";
 import * as path11 from "node:path";
 var VSCODE_GUIDANCE_BEGIN = "<!-- token-goat-vscode-begin -->";
@@ -4311,7 +5320,7 @@ function vscodeUserSettingsPath() {
 function vscodeUsesClaudeHooks(settingsPath2 = vscodeUserSettingsPath()) {
   let text;
   try {
-    text = fs11.readFileSync(settingsPath2, "utf8");
+    text = fs12.readFileSync(settingsPath2, "utf8");
   } catch {
     return false;
   }
@@ -4326,7 +5335,7 @@ var updateConfig = setTokenGoatServer;
 function otherScopeHasManagedServer(opts) {
   const otherPath = otherScopeMcpPath2(opts);
   if (opts.project !== true && !projectPathIsConsultable(otherPath, path11.resolve(opts.projectRoot ?? process.cwd()))) return false;
-  if (!fs11.existsSync(otherPath)) return false;
+  if (!fs12.existsSync(otherPath)) return false;
   try {
     const config = readConfig(otherPath);
     const servers = config.value["servers"];
@@ -4343,7 +5352,7 @@ function vscodeDecoderConfigured(opts = {}) {
     if (projectPathIsConsultable(projectPath, path11.resolve(opts.projectRoot))) checkedPaths.push(projectPath);
   }
   for (const candidate of checkedPaths) {
-    if (!fs11.existsSync(candidate)) continue;
+    if (!fs12.existsSync(candidate)) continue;
     try {
       const config = readConfig(candidate);
       const servers = config.value["servers"];
@@ -4358,7 +5367,7 @@ function vscodeDecoderConfigured(opts = {}) {
 }
 function writeGuidance2(filePath, userScope) {
   let created = false;
-  if (userScope && !fs11.existsSync(filePath)) {
+  if (userScope && !fs12.existsSync(filePath)) {
     ensureDirSync(path11.dirname(filePath));
     atomicWriteText(filePath, USER_INSTRUCTIONS_FRONTMATTER);
     created = true;
@@ -4409,7 +5418,7 @@ function installVscodeScoped(opts) {
     throw new Error(`VS Code MCP JSON at ${mcpPath} already has a non-token-goat-managed server named "token-goat"`);
   }
   const next = updateConfig(config.text, managedServer());
-  const mcpExisted = fs11.existsSync(mcpPath);
+  const mcpExisted = fs12.existsSync(mcpPath);
   ensureDirSync(path11.dirname(mcpPath));
   if (config.text !== next) {
     backupFile(mcpPath);
@@ -4435,7 +5444,7 @@ function uninstallVscodeScoped(opts) {
   assertProjectTargetsAreInTheProject(opts);
   const mcpPath = vscodeMcpPath(opts);
   let removed = false;
-  if (fs11.existsSync(mcpPath)) {
+  if (fs12.existsSync(mcpPath)) {
     const config = readConfig(mcpPath);
     const servers = config.value["servers"];
     if (servers !== void 0 && (servers === null || typeof servers !== "object" || Array.isArray(servers))) {
@@ -4455,7 +5464,7 @@ function uninstallVscodeScoped(opts) {
   const instructionsPath = vscodeInstructionsPath(opts);
   if (stripDelimitedBlock(instructionsPath, BEGIN, END, opts.keepBackups === true)) {
     removed = true;
-    if (opts.project !== true && fs11.readFileSync(instructionsPath, "utf8").trim() === USER_INSTRUCTIONS_FRONTMATTER.trim()) removeFileInScope(instructionsPath);
+    if (opts.project !== true && fs12.readFileSync(instructionsPath, "utf8").trim() === USER_INSTRUCTIONS_FRONTMATTER.trim()) removeFileInScope(instructionsPath);
   }
   if (opts.project === true) syncVisualStudioProjectGuidance(instructionsPath);
   if (releaseCopilotHooksFile(vscodeHooksDir(opts), "vscode", opts.keepBackups === true)) removed = true;
@@ -5318,25 +6327,25 @@ function makeLanguageFilter(cfg) {
 // src/tool_filters/ai_clis.ts
 var _GH_COPILOT_SPINNER_RE = /^\s*(?:Asking GitHub Copilot|Generating|Thinking|Fetching)\s*(?:\.{1,3}\s*)?$/i;
 var _GH_COPILOT_BANNER_RE = /^\s*(?:Welcome to GitHub Copilot|Using GitHub Copilot|Authenticated as|GitHub Copilot\s+v\d+)/i;
-var _GH_COPILOT_DISCLAIMER_RE = /^\s*(?:Disclaimer:|This response was|GitHub Copilot|The commands?\s+(?:above|below)|Please review|Always review|Remember to|Note:|Tip:)/i;
+var _GH_COPILOT_DISCLAIMER_RE = /^\s*(?:Disclaimer:|This response was|GitHub Copilot|The commands?\s+(?:above|below)|Please review|Always review|Remember to)/i;
 var _AIDER_APPLYING_RE = /^\s*(?:Applying\s+edits?(?:\s+to\s+\S+)?|Applied\s+edit\s+to\s+\S+)\s*(?:\.{1,3}\s*)?$/i;
 var _AIDER_TOKENS_RE = /^\s*Tokens:\s+\d[\d,]*\s+sent,\s+\d[\d,]*\s+received/i;
 var _AIDER_COST_RE = /^\s*Cost:\s+\$[\d.]+\s+message,\s+\$[\d.]+\s+session/i;
 var _AIDER_REPOMAP_RE = /^\s*(?:Repo-map:|Added\s+\S+\s+to\s+the\s+chat|Removed\s+\S+\s+from\s+the\s+chat|Loading\s+repo\s+map|Updating\s+repo\s+map|Scanning\s+repo\s+contents|Using\s+\d+\s+tokens\s+of\s+repo\s+map)/i;
 var _AIDER_BANNER_RE = /^\s*aider\s+v\d+\.\d+/i;
-var _AIDER_FOOTER_NOISE_RE = /^\s*(?:Use\s+ctrl-c|Run\s+with\s+--help|You\s+can\s+skip\s+this|Tip:|Note:)/i;
+var _AIDER_FOOTER_NOISE_RE = /^\s*(?:Use\s+ctrl-c|Run\s+with\s+--help|You\s+can\s+skip\s+this)/i;
 var _COPILOT_WORKSPACE_NOISE_RE = /^\s*(?:Starting\s+Copilot\s+workspace|Loading\s+model:|Copilot\s+workspace\s+(?:starting|loaded|ready)|Streaming\.\.\.|▌\s*$|Turn\s+\d+\s*:)/i;
 var _COPILOT_COMPLETION_STATS_RE = /^\s*(?:Completion\s+tokens:|Prompt\s+tokens:|Total\s+tokens:|Input\s+tokens:|Output\s+tokens:)\s*\d/i;
 var _GEMINI_STARTUP_RE = /^\s*(?:[✓✗►]|>)\s*(?:Model:|Theme:|Tools:|Sandbox:|Checkpointing:|Context(?:\s+limit)?:|Version:|Authenticated(?:\s+as)?:|Connecting)/i;
 var _GEMINI_BANNER_RE = /^\s*Gemini\s+CLI\s+v\d+/i;
 var _GEMINI_TOKEN_METER_RE = /^\s*(?:Token\s+usage|Context|Tokens):\s+[\d,]+\s*\/\s*[\d,]+/i;
 var _GEMINI_TOOL_SPINNER_RE = /^\s*[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏✓✗►✦]\s+(?:Call(?:ing|ed)|Execut(?:ing|ed)|Running)\s+\S+/;
-var _GEMINI_FOOTER_RE = /^\s*(?:Type\s+\/help|Press\s+Ctrl|Use\s+Ctrl|Tip:|Note:)/i;
+var _GEMINI_FOOTER_RE = /^\s*(?:Type\s+\/help|Press\s+Ctrl|Use\s+Ctrl)/i;
 var _GEMINI_THINKING_RE = /^\s*(?:Thinking|Generating|Processing)\s*(?:\.{1,3}\s*)?$/i;
 var _CLAUDE_CLI_MODEL_HDR_RE = /^\s*[◆◇►✦]\s+claude-/i;
 var _CLAUDE_CLI_STATS_RE = /^\s*[↑↓⇑⇓]\s*\d[\d,]*(?:(?:\s*[↑↓⇑⇓]\s*|\s+)\d[\d,]*)?\s*tokens/i;
 var _CLAUDE_CLI_CONTEXT_RE = /^\s*(?:Context(?:\s+window)?|Token\s+limit):\s+[\d,]+\s*\/\s*[\d,]+/i;
-var _CLAUDE_CLI_FOOTER_RE = /^\s*(?:Press\s+Ctrl|Enter\s+\/|Type\s+\/|Use\s+Ctrl|Tip:|Note:)/i;
+var _CLAUDE_CLI_FOOTER_RE = /^\s*(?:Press\s+Ctrl|Enter\s+\/|Type\s+\/|Use\s+Ctrl)/i;
 var _CLAUDE_CLI_SPINNER_RE = /^\s*[◎⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]\s+(?:Thinking|Generating|Processing|Running)\s*(?:\.{1,3}\s*)?$/;
 var _CLAUDE_CLI_TOOL_LOG_RE = /^\s*(?:>\s+Using\s+tool:|✓\s+Tool\s+result:|◎\s+Tool:)/i;
 var _CLAUDE_CLI_SKIP_SUBCMDS = /* @__PURE__ */ new Set(["install", "update", "doctor", "config", "login", "logout"]);
@@ -8315,7 +9324,8 @@ ${stderr.replace(/\s+$/, "")}` : stderr;
 var awsFilter = new AwsFilter();
 var _AWS_UPLOAD_RE = /^upload:\s+\S+\s+to\s+s3:\/\//i;
 var _AWS_DOWNLOAD_RE = /^download:\s+s3:\/\//i;
-var _AWS_S3_PROGRESS_RE = /^(?:Completed\s+\d|\d+(?:\.\d+)?\s*(?:KiB|MiB|GiB|B)\/s|Calculating|upload\s+failed:|download\s+failed:)/i;
+var _AWS_S3_TRANSFER_FAILED_RE = /^(?:upload|download|copy|delete|move)\s+failed:/i;
+var _AWS_S3_PROGRESS_RE = /^(?:Completed\s+\d|\d+(?:\.\d+)?\s*(?:KiB|MiB|GiB|B)\/s|Calculating)/i;
 var AWS_GLOBAL_VALUE_FLAGS = /* @__PURE__ */ new Set([
   "--profile",
   "--region",
@@ -8337,7 +9347,8 @@ var AwsCliFilter = class extends ToolFilter {
   _JSON_ARRAY_KEEP = 3;
   compressBody(stdout, stderr, _exitCode, argv) {
     const positionals = positionalArgs(argv.slice(1), AWS_GLOBAL_VALUE_FLAGS);
-    const isS3Transfer = positionals.length >= 2 && positionals[0] === "s3" && (positionals[1] === "cp" || positionals[1] === "sync" || positionals[1] === "mv");
+    const isS3Transfer = positionals.length >= 2 && positionals[0] === "s3" && // `rm` belongs here for the failure path, not the volume one: `aws s3 rm --recursive` reports `delete failed:` per object, and routing it anywhere else meant those lines were never counted. Its `delete:` success lines are not folded into a count -- only `upload:`/`download:` are -- so adding it drops nothing that used to survive.
+    (positionals[1] === "cp" || positionals[1] === "sync" || positionals[1] === "mv" || positionals[1] === "rm");
     const isCfnEvents = positionals.length >= 2 && positionals[0] === "cloudformation" && positionals[1] === "describe-stack-events";
     let text = stdout;
     if (isS3Transfer) {
@@ -8369,6 +9380,7 @@ ${stderr.replace(/\s+$/, "")}` : stderr;
     const kept = [];
     let uploadCount = 0;
     let downloadCount = 0;
+    let failedCount = 0;
     let progressDropped = 0;
     for (const line of lines) {
       if (_AWS_UPLOAD_RE.test(line)) {
@@ -8379,6 +9391,11 @@ ${stderr.replace(/\s+$/, "")}` : stderr;
         downloadCount++;
         continue;
       }
+      if (_AWS_S3_TRANSFER_FAILED_RE.test(line)) {
+        failedCount++;
+        kept.push(line);
+        continue;
+      }
       if (_AWS_S3_PROGRESS_RE.test(line)) {
         progressDropped++;
         continue;
@@ -8388,6 +9405,7 @@ ${stderr.replace(/\s+$/, "")}` : stderr;
     const notes = [];
     maybeNote(notes, uploadCount, `uploaded ${uploadCount} file(s)`);
     maybeNote(notes, downloadCount, `downloaded ${downloadCount} file(s)`);
+    maybeNote(notes, failedCount, `${failedCount} transfer(s) failed`);
     maybeNote(notes, progressDropped, `dropped ${progressDropped} progress line(s)`);
     this.emitNotes(kept, notes);
     return this.finalize(kept);
@@ -9488,8 +10506,9 @@ var RgFilter = class _RgFilter extends ToolFilter {
   name = "rg";
   binaries = /* @__PURE__ */ new Set(["rg", "grep"]);
   static _SEP = "--";
-  static _CTX_LINE_RE = /^.+-\d+-/;
-  static _MATCH_LINE_RE = /^.+:\d+:/;
+  // The path prefix is optional because ripgrep only prints one when the search covers more than one file: `rg -n -C2 pat one.ts` emits `12-text` and `14:text`, not `one.ts-12-text` and `one.ts:14:text`. Requiring the prefix meant neither regex matched anything on a single-file search -- the ordinary shape of the command -- so no context line was ever suppressed there, and the only thing removed was the cosmetic `--` separator, under a note announcing a compression that had not happened.
+  static _CTX_LINE_RE = /^(?:.+-)?\d+-/;
+  static _MATCH_LINE_RE = /^(?:.+:)?\d+:/;
   static _parseContextDepth(argv) {
     let depth = 0;
     const longFlags = /* @__PURE__ */ new Set(["--after-context", "--before-context", "--context"]);
@@ -9529,8 +10548,14 @@ var RgFilter = class _RgFilter extends ToolFilter {
   // RgFilter only handles context-block output (-A/-B/-C/--context); a plain
   // grep/rg with no context flags falls through to GrepFilter's per-file
   // match-count summarizer, which produces dramatically smaller output.
+  // Both line regexes hard-code ripgrep's default field separators (`:` after a match's line number, `-` after a context line's). `--field-match-separator=-` makes a real match read `12-text`, which is exactly the shape this filter drops, so a search that overrides either separator is released to the generic path rather than compressed against an assumption it broke.
+  static _hasCustomFieldSeparator(argv) {
+    const flags = ["--field-match-separator", "--field-context-separator"];
+    return argv.some((a) => flags.some((f) => a === f || a.startsWith(f + "=")));
+  }
   matches(argv) {
     if (!super.matches(argv)) return false;
+    if (_RgFilter._hasCustomFieldSeparator(argv)) return false;
     return _RgFilter._hasContextFlags(argv);
   }
   _compressGroups(groups) {
@@ -9563,7 +10588,8 @@ var RgFilter = class _RgFilter extends ToolFilter {
     const kept = [];
     let suppressed = 0;
     for (const ln of lines) {
-      if (ln === _RgFilter._SEP || _RgFilter._CTX_LINE_RE.test(ln) && !_RgFilter._MATCH_LINE_RE.test(ln)) {
+      if (ln === _RgFilter._SEP) continue;
+      if (_RgFilter._CTX_LINE_RE.test(ln) && !_RgFilter._MATCH_LINE_RE.test(ln)) {
         suppressed++;
       } else {
         kept.push(ln);
@@ -13231,6 +14257,8 @@ var _DOCKER_OLD_STEP_ERROR_RE = /error|returned a non-zero code/i;
 var DockerFilter = class extends ToolFilter {
   name = "docker";
   binaries = /* @__PURE__ */ new Set(["docker", "buildah", "podman", "nerdctl"]);
+  // Every rule below is about image transfer and build noise -- layer digests, pull/push progress, cached step lines, step bodies -- so the filter is declared for exactly the subcommands that emit them, including buildah's `bud` spelling of build, `create` and `plugin install`/`plugin upgrade`, which pull layers and emit the same per-layer status lines as `pull`. The base matcher scans the first three positionals, so the management-command spellings (`docker image pull`, `docker container create`) are covered by the same entries. With no subcommand set it claimed every `docker …` invocation and removed a single blank line from the ones it has no rules for, which matters because dispatch stops at the first match: `docker logs` on a service repeating a heartbeat went 8702 bytes in, 8701 out, where the generic compressor it was displacing returns 6987. On output with nothing repeated (`docker images` here: 15912 bytes) neither saves anything, so the gain is confined to the repetitive case -- but a filter that claims a command it cannot compress blocks whatever could.
+  subcommands = /* @__PURE__ */ new Set(["build", "bud", "buildx", "pull", "push", "run", "load", "create", "install", "upgrade"]);
   // Docker writes progress/errors to stderr; only stdout carries build bodies. Merge with stderr first so errors appear before raw build output.
   compress(stdout, stderr, _exitCode, _argv) {
     const merged = this.combineOutput(stderr, stdout);
@@ -13457,6 +14485,7 @@ var _KEY_PREFIXES = [
   "Namespace:",
   "Status:",
   "State:",
+  "Last State:",
   "Node:",
   "IP:",
   "PodIP:",
@@ -13464,6 +14493,7 @@ var _KEY_PREFIXES = [
   "QoS Class:",
   "Priority:",
   "Image:",
+  "Container ID:",
   "Ready:",
   "Restart Count:",
   "Started:",
@@ -14401,12 +15431,18 @@ function _compressGitStatusVerbose(stdout, stderr, argv = null) {
   const kept = [];
   let section = null;
   let counts = {};
+  let fileLines = [];
   function flush() {
-    if (section !== null && section !== "unmerged" && Object.keys(counts).length) {
-      const parts = Object.entries(counts).map(([label, n]) => `${n} ${label}`);
-      kept.push("	" + parts.join(", "));
+    if (section !== null && section !== "unmerged" && fileLines.length) {
+      if (fileLines.length > _DIFF_STAT_DIR_ROLLUP_THRESHOLD) {
+        const parts = Object.entries(counts).map(([label, n]) => `${n} ${label}`);
+        kept.push("	" + parts.join(", "));
+      } else {
+        kept.push(...fileLines);
+      }
     }
     counts = {};
+    fileLines = [];
   }
   for (const line of lines) {
     const headerMatch = _GIT_STATUS_SECTION_RE.exec(line);
@@ -14423,6 +15459,7 @@ function _compressGitStatusVerbose(stdout, stderr, argv = null) {
       } else {
         const label = _gitStatusFileLabel(line, section);
         counts[label] = (counts[label] ?? 0) + 1;
+        fileLines.push(line);
       }
       continue;
     }
@@ -17726,10 +18763,13 @@ function filterByName(name) {
 init_define_import_meta_env();
 
 export {
+  pathEqClause,
+  projectScopeClause,
   getToolName,
   getToolInput,
   getFilePath,
   getCwd,
+  getTranscriptPath,
   extractToolResponseField,
   OUTPUT_FIRST_TOOL_RESPONSE_KEYS,
   BODY_FIRST_TOOL_RESPONSE_KEYS,
@@ -17793,6 +18833,38 @@ export {
   capTokens,
   shlexSplit,
   clipLongMatchLine,
+  isLockFile,
+  isManifestFile,
+  isInBuildDir,
+  isGeneratedFile,
+  isBuildCommand,
+  isTestRunnerCommand,
+  getMonitoringRecallHint,
+  DEFAULT_QUERY_LIMIT,
+  querySymbols,
+  distinctSymbolKinds,
+  countSymbols,
+  queryRefs,
+  countRefs,
+  queryRefsByContext,
+  queryRefCounts,
+  getProjectFileEntries,
+  getFileEntry,
+  searchSymbolsFts,
+  RECALL_DEFAULT_LIMIT,
+  isRecallCacheType,
+  indexRecallEntry,
+  listRecentRecall,
+  searchRecall,
+  BASH_OUTPUT_SUBDIR,
+  isScopedGitStatusOrDiffStatCommand,
+  normalizeCommandForCacheKey,
+  commandHash,
+  isBashEntryStale,
+  summarizeOutputDelta,
+  storeBashOutputSync,
+  storeBashOutput,
+  getBashOutput,
   anchoredMarkerPattern,
   settingsPath,
   installHooks,