token-goat 2.9.13 → 2.9.15

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

@@ -1,17 +1,31 @@
 import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
+  sanitizeFtsQuery
+} from "./token-goat-chunk-2X2EBBC6.mjs";
+import {
+  DEFAULT_MAX_AGE_MS,
+  blobPath,
   countRedactionPlaceholders,
-  detectHarness,
-  loadConfig,
-  parse,
+  isBlobStale,
+  loadBlob,
   recordStat,
   recordUnmappedTool,
   redactSecrets,
   savedTokensFromBytes,
-  stringify,
+  storeBlob,
   stripAnsiEscapes
-} from "./token-goat-chunk-UMXJN7DI.mjs";
+} from "./token-goat-chunk-IVUQLQWN.mjs";
+import {
+  getDb
+} from "./token-goat-chunk-K7F2BFIK.mjs";
+import {
+  detectHarness,
+  loadConfig,
+  parse,
+  shortFingerprint,
+  stringify
+} from "./token-goat-chunk-S4XRY446.mjs";
 import {
   registerReset
 } from "./token-goat-chunk-EEIDFMEM.mjs";
@@ -20,20 +34,18 @@ import {
   assertWriteInScope,
   atomicWriteText,
   backupFile,
-  displaySafeText,
   ensureDirSync,
   escapeRegExp,
   extractErrorMessage,
+  globalDbPath,
   hookCommandFor,
   hookPowershellCommand,
-  neutralizeOutsideFences,
-  normalizeDarwinSystemAlias,
   projectPathIsConsultable,
   projectScopeRoot,
   recordCreatedConfig,
   removeCreatedBackups,
   removeFileInScope,
-  resolveIndexPath,
+  runGit,
   safeSlice,
   stripDelimitedBlock,
   stripOwnHooksFromMap,
@@ -43,7 +55,14 @@ import {
   withInstallScope,
   writeIfDifferent,
   writeJsonSettings
-} from "./token-goat-chunk-QKXBGBQR.mjs";
+} from "./token-goat-chunk-PM76YS22.mjs";
+import {
+  displaySafeText,
+  neutralizeOutsideFences,
+  normalizeDarwinSystemAlias,
+  normalizePath,
+  resolveIndexPath
+} from "./token-goat-chunk-ERTXEKB6.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -513,6 +532,27 @@ const TOOL_TO_TG = {
   exit_plan_mode: 'ExitPlanMode',
 }
 
+function foldToolName(name) {
+  return typeof name === 'string' ? name.toLowerCase().replace(/[_-]/g, '') : ''
+}
+
+const FOLDED_TOOL_TO_TG = {}
+for (const [k, v] of Object.entries(TOOL_TO_TG)) {
+  FOLDED_TOOL_TO_TG[foldToolName(k)] = v
+}
+// Also register folded entries for canonical TG tool names directly (e.g. WebSearch -> websearch)
+for (const v of Object.values(TOOL_TO_TG)) {
+  FOLDED_TOOL_TO_TG[foldToolName(v)] = v
+}
+
+function resolveCanonicalToolName(name) {
+  if (!name || typeof name !== 'string') return name
+  const direct = TOOL_TO_TG[name]
+  if (direct !== undefined) return direct
+  const folded = foldToolName(name)
+  return FOLDED_TOOL_TO_TG[folded] || name
+}
+
 // Confirmed via github/copilot-cli#3349 (open, unresolved as of writing): some
 // real Copilot CLI invocations send toolArgs as a JSON-*encoded string*
 // rather than a parsed object, contradicting the documented schema. Left
@@ -583,11 +623,12 @@ function remapToolInput(copilotToolName, input) {
   let out = input
   // Add the canonical key alongside the original rather than renaming it, so nothing that
   // might read the original 'path'/'shellId' key elsewhere (e.g. a future handler) loses it.
-  const pathKey = FILE_PATH_ARG_KEY[copilotToolName]
+  const folded = foldToolName(copilotToolName)
+  const pathKey = FILE_PATH_ARG_KEY[copilotToolName] || (folded === 'view' || folded === 'edit' || folded === 'create' ? 'path' : undefined)
   if (pathKey !== undefined && pathKey in out) {
     out = Object.assign({}, out, { file_path: out[pathKey] })
   }
-  const idKey = POLL_ID_ARG_KEY[copilotToolName]
+  const idKey = POLL_ID_ARG_KEY[copilotToolName] || (folded === 'readbash' || folded === 'readpowershell' ? 'shellId' : undefined)
   if (idKey !== undefined && idKey in out) {
     out = Object.assign({}, out, { bash_id: out[idKey] })
   }
@@ -752,7 +793,7 @@ async function main() {
   let originalToolArgs = {}
   if (toolName) {
     originalToolArgs = parseMaybeJsonObject(payload && payload.toolArgs)
-    canonical.tool_name = TOOL_TO_TG[toolName] || toolName
+    canonical.tool_name = resolveCanonicalToolName(toolName)
     canonical.tool_input = remapToolInput(toolName, originalToolArgs)
   }
 
@@ -842,12 +883,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'))
@@ -861,7 +902,7 @@ function translate(copilotEvent, resp, toolName, originalToolArgs) {
       return { modifiedArgs: updated }
     }
     // Image shrink has no context channel on this event (Copilot's preToolUse output schema carries no additionalContext; docs/hook-channel-matrix.md footnote 7) -- translate it into a rewritten view path pointing at a materialized shrunk copy instead, via the same modifiedArgs channel the updatedInput branch above already uses. modifiedArgs REPLACES the tool call's args wholesale (ESr in the 1.0.80 bundle, see this module's header docblock), so the full original toolArgs are spread and only Copilot's own path key is swapped.
-    if (toolName === 'view') {
+    if (toolName === 'view' || foldToolName(toolName) === 'view') {
       const shrunkPath = materializeShrunkImage(extractContext(resp))
       if (shrunkPath) return { modifiedArgs: Object.assign({}, originalToolArgs, { path: shrunkPath }) }
     }
@@ -869,52 +910,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
@@ -1035,6 +1044,29 @@ main()
     process.exitCode = 0
   })
 `;
+function foldToolName(name) {
+  return typeof name === "string" ? name.toLowerCase().replace(/[_-]/g, "") : "";
+}
+var TOOL_TO_TG_MAPPING = {
+  bash: "Bash",
+  powershell: "Bash",
+  read_bash: "BashOutput",
+  read_powershell: "BashOutput",
+  view: "Read",
+  create: "Write",
+  edit: "Edit",
+  web_fetch: "WebFetch",
+  web_search: "WebSearch",
+  grep: "Grep",
+  glob: "Glob",
+  skill: "Skill",
+  exit_plan_mode: "ExitPlanMode"
+};
+var FOLDED_MAPPING = {};
+for (const [k, v] of Object.entries(TOOL_TO_TG_MAPPING)) {
+  FOLDED_MAPPING[foldToolName(k)] = v;
+  FOLDED_MAPPING[foldToolName(v)] = v;
+}
 
 // src/bridges/copilot_cli_install.ts
 var COPILOT_CLI_HOOK_EVENTS = [
@@ -1747,6 +1779,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;
@@ -2047,7 +2083,7 @@ function toolMatcherFor(eventName) {
   if (parts.length === 0) return null;
   return parts.join("|");
 }
-function foldToolName(name) {
+function foldToolName2(name) {
   return name.toLowerCase().replace(/[_-]/g, "");
 }
 function noteUnrecognizedTool(event, list) {
@@ -2060,8 +2096,8 @@ function noteUnrecognizedTool(event, list) {
     named.push(want);
   }
   if (named.length === 0) return;
-  const folded = foldToolName(toolName);
-  const nearMiss = named.find((n) => foldToolName(n) === folded) ?? null;
+  const folded = foldToolName2(toolName);
+  const nearMiss = named.find((n) => foldToolName2(n) === folded) ?? null;
   recordUnmappedTool(toolName, event.eventName, nearMiss);
 }
 async function runHook(event) {
@@ -2954,9 +2990,800 @@ function byteLength(s) {
   return utf8Len(s);
 }
 
-// src/install.ts
+// 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 +3967,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 +4099,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 +4137,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 +4153,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 +4167,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 +4205,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 +4217,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 +4394,7 @@ function codexHookScriptPath() {
 function readCodexConfig(p, opts = {}) {
   let raw;
   try {
-    raw = fs8.readFileSync(p, "utf8");
+    raw = fs9.readFileSync(p, "utf8");
   } catch {
     return {};
   }
@@ -3773,7 +4600,7 @@ function uninstallCodex() {
     removedAny = true;
   }
   try {
-    fs8.unlinkSync(scriptPath);
+    fs9.unlinkSync(scriptPath);
     removedAny = true;
   } catch {
   }
@@ -3809,10 +4636,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 +4664,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 +4794,7 @@ function kimiSkillPath() {
 function readKimiConfig(p, opts = {}) {
   let raw;
   try {
-    raw = fs9.readFileSync(p, "utf8");
+    raw = fs10.readFileSync(p, "utf8");
   } catch {
     return {};
   }
@@ -4070,16 +4897,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 +4927,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 +5071,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 +5084,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 +5138,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 +5153,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 +5170,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 +5185,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 +5236,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 +5262,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 +5282,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 +6145,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 +9142,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 +9165,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 +9198,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 +9209,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 +9223,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 +10324,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 +10366,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 +10406,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 +14075,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 +14303,7 @@ var _KEY_PREFIXES = [
   "Namespace:",
   "Status:",
   "State:",
+  "Last State:",
   "Node:",
   "IP:",
   "PodIP:",
@@ -13464,6 +14311,7 @@ var _KEY_PREFIXES = [
   "QoS Class:",
   "Priority:",
   "Image:",
+  "Container ID:",
   "Ready:",
   "Restart Count:",
   "Started:",
@@ -14269,8 +15117,8 @@ function _capHunksByDensity(hunks, maxHunksPerFile) {
   };
 }
 function _compressGitDiffBody(stdout, stderr, maxHunksPerFile = 10) {
-  const MAX_HUNK_CHANGED = 50;
-  const HUNK_HEAD_KEEP = 20;
+  const MAX_HUNK_CHANGED = 25;
+  const HUNK_HEAD_KEEP = 15;
   const HUNK_TAIL_KEEP = 5;
   const fileBlocks = splitBlocks(stdout, _GIT_DIFF_FILE_RE);
   if (!fileBlocks.length) return stdout;
@@ -14401,12 +15249,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 +15277,7 @@ function _compressGitStatusVerbose(stdout, stderr, argv = null) {
       } else {
         const label = _gitStatusFileLabel(line, section);
         counts[label] = (counts[label] ?? 0) + 1;
+        fileLines.push(line);
       }
       continue;
     }
@@ -15909,6 +16764,7 @@ var _PHPSTAN_SEP_RE = /^\s*-{3,}/;
 var _PHPSTAN_FILE_HEADER_RE = /^\s+Line\s+(\S.*\.php)\s*$/;
 var _PHPSTAN_ROW_RE = /^\s+(\d+)\s+(.+)$/;
 var _PHPSTAN_SUMMARY_RE = /^\s*\[(ERROR|OK|WARNING|NOTE)\]/i;
+var _PHPSTAN_ROW_CONTINUATION_RE = /^\s{2,}\S/;
 var _PSALM_ERROR_RE = /^(ERROR|INFO|FATAL): \w+ - .+\.php:\d+/i;
 var _PSALM_PROGRESS_RE = /^(Scanning|Analyzing|Checking|Parsing|Caching|Target PHP|Psalm|PHP version|Running Psalm|Checked \d)/i;
 var _PHPSTAN_INFO_RE = /^(Note: |Loading config|Found cached|Autoload|Bootstrapping|PHPStan - PHP Static|Psalm is running)/i;
@@ -15928,6 +16784,7 @@ var PhpStanFilter = class extends ToolFilter {
     let droppedSep = 0;
     let droppedInfo = 0;
     let currentFile = "";
+    let lastRowKept = true;
     const fileMsgs = /* @__PURE__ */ new Map();
     const flushFileDedup = (file) => {
       const msgs = fileMsgs.get(file);
@@ -15945,11 +16802,13 @@ var PhpStanFilter = class extends ToolFilter {
           flushFileDedup(currentFile);
           currentFile = "";
         }
+        lastRowKept = true;
         kept.push(line);
         continue;
       }
       if (_PHPSTAN_SEP_RE.test(line) && !_PHPSTAN_ROW_RE.test(line)) {
         droppedSep++;
+        lastRowKept = true;
         continue;
       }
       if (_PHPSTAN_FILE_HEADER_RE.test(line)) {
@@ -15957,6 +16816,7 @@ var PhpStanFilter = class extends ToolFilter {
         const headerMatch = _PHPSTAN_FILE_HEADER_RE.exec(line);
         currentFile = headerMatch?.[1] ? headerMatch[1].trim() : line.trim();
         if (!fileMsgs.has(currentFile)) fileMsgs.set(currentFile, /* @__PURE__ */ new Map());
+        lastRowKept = true;
         kept.push(line);
         continue;
       }
@@ -15966,9 +16826,11 @@ var PhpStanFilter = class extends ToolFilter {
         const counts = fileMsgs.get(currentFile);
         const count = (counts.get(msg) ?? 0) + 1;
         counts.set(msg, count);
-        if (count <= 3) kept.push(line);
+        lastRowKept = count <= 3;
+        if (lastRowKept) kept.push(line);
         continue;
       }
+      if (currentFile && !lastRowKept && _PHPSTAN_ROW_CONTINUATION_RE.test(line)) continue;
       kept.push(line);
     }
     if (currentFile) flushFileDedup(currentFile);
@@ -17730,6 +18592,7 @@ export {
   getToolInput,
   getFilePath,
   getCwd,
+  getTranscriptPath,
   extractToolResponseField,
   OUTPUT_FIRST_TOOL_RESPONSE_KEYS,
   BODY_FIRST_TOOL_RESPONSE_KEYS,
@@ -17793,6 +18656,27 @@ export {
   capTokens,
   shlexSplit,
   clipLongMatchLine,
+  isLockFile,
+  isManifestFile,
+  isInBuildDir,
+  isGeneratedFile,
+  isBuildCommand,
+  isTestRunnerCommand,
+  getMonitoringRecallHint,
+  RECALL_DEFAULT_LIMIT,
+  isRecallCacheType,
+  indexRecallEntry,
+  listRecentRecall,
+  searchRecall,
+  BASH_OUTPUT_SUBDIR,
+  isScopedGitStatusOrDiffStatCommand,
+  normalizeCommandForCacheKey,
+  commandHash,
+  isBashEntryStale,
+  summarizeOutputDelta,
+  storeBashOutputSync,
+  storeBashOutput,
+  getBashOutput,
   anchoredMarkerPattern,
   settingsPath,
   installHooks,