token-goat 2.0.1 → 2.0.2

package/dist/token-goat.mjs

@@ -982,7 +982,7 @@ var require_command = __commonJS({
     var EventEmitter = __require("node:events").EventEmitter;
     var childProcess = __require("node:child_process");
     var path14 = __require("node:path");
-    var fs14 = __require("node:fs");
+    var fs15 = __require("node:fs");
     var process2 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1915,10 +1915,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
           const localBin = path14.resolve(baseDir, baseName);
-          if (fs14.existsSync(localBin)) return localBin;
+          if (fs15.existsSync(localBin)) return localBin;
           if (sourceExt.includes(path14.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs14.existsSync(`${localBin}${ext}`)
+            (ext) => fs15.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1930,7 +1930,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs14.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs15.realpathSync(this._scriptPath);
           } catch (err2) {
             resolvedScriptPath = this._scriptPath;
           }
@@ -3158,27 +3158,27 @@ var require_filesystem = __commonJS({
   "node_modules/detect-libc/lib/filesystem.js"(exports, module) {
     "use strict";
     init_define_import_meta_env();
-    var fs14 = __require("fs");
+    var fs15 = __require("fs");
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
     var readFileSync11 = (path14) => {
-      const fd = fs14.openSync(path14, "r");
+      const fd = fs15.openSync(path14, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
-      const bytesRead = fs14.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-      fs14.close(fd, () => {
+      const bytesRead = fs15.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs15.close(fd, () => {
       });
       return buffer.subarray(0, bytesRead);
     };
-    var readFile2 = (path14) => new Promise((resolve4, reject) => {
-      fs14.open(path14, "r", (err2, fd) => {
+    var readFile3 = (path14) => new Promise((resolve5, reject) => {
+      fs15.open(path14, "r", (err2, fd) => {
         if (err2) {
           reject(err2);
         } else {
           const buffer = Buffer.alloc(MAX_LENGTH);
-          fs14.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
-            resolve4(buffer.subarray(0, bytesRead));
-            fs14.close(fd, () => {
+          fs15.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+            resolve5(buffer.subarray(0, bytesRead));
+            fs15.close(fd, () => {
             });
           });
         }
@@ -3188,7 +3188,7 @@ var require_filesystem = __commonJS({
       LDD_PATH,
       SELF_PATH,
       readFileSync: readFileSync11,
-      readFile: readFile2
+      readFile: readFile3
     };
   }
 });
@@ -3238,7 +3238,7 @@ var require_detect_libc = __commonJS({
     init_define_import_meta_env();
     var childProcess = __require("child_process");
     var { isLinux, getReport } = require_process();
-    var { LDD_PATH, SELF_PATH, readFile: readFile2, readFileSync: readFileSync11 } = require_filesystem();
+    var { LDD_PATH, SELF_PATH, readFile: readFile3, readFileSync: readFileSync11 } = require_filesystem();
     var { interpreterPath } = require_elf();
     var cachedFamilyInterpreter;
     var cachedFamilyFilesystem;
@@ -3247,10 +3247,10 @@ var require_detect_libc = __commonJS({
     var commandOut = "";
     var safeCommand = () => {
       if (!commandOut) {
-        return new Promise((resolve4) => {
+        return new Promise((resolve5) => {
           childProcess.exec(command, (err2, out2) => {
             commandOut = err2 ? " " : out2;
-            resolve4(commandOut);
+            resolve5(commandOut);
           });
         });
       }
@@ -3318,7 +3318,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyFilesystem = null;
       try {
-        const lddContent = await readFile2(LDD_PATH);
+        const lddContent = await readFile3(LDD_PATH);
         cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
       } catch (e) {
       }
@@ -3342,7 +3342,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyInterpreter = null;
       try {
-        const selfContent = await readFile2(SELF_PATH);
+        const selfContent = await readFile3(SELF_PATH);
         const path14 = interpreterPath(selfContent);
         cachedFamilyInterpreter = familyFromInterpreterPath(path14);
       } catch (e) {
@@ -3404,7 +3404,7 @@ var require_detect_libc = __commonJS({
       }
       cachedVersionFilesystem = null;
       try {
-        const lddContent = await readFile2(LDD_PATH);
+        const lddContent = await readFile3(LDD_PATH);
         const versionMatch = lddContent.match(RE_GLIBC_VERSION);
         if (versionMatch) {
           cachedVersionFilesystem = versionMatch[1];
@@ -7392,14 +7392,14 @@ var require_input = __commonJS({
         return this;
       } else {
         if (this._isStreamInput()) {
-          return new Promise((resolve4, reject) => {
+          return new Promise((resolve5, reject) => {
             const finished = () => {
               this._flattenBufferIn();
               sharp.metadata(this.options, (err2, metadata2) => {
                 if (err2) {
                   reject(is.nativeError(err2, stack));
                 } else {
-                  resolve4(metadata2);
+                  resolve5(metadata2);
                 }
               });
             };
@@ -7410,12 +7410,12 @@ var require_input = __commonJS({
             }
           });
         } else {
-          return new Promise((resolve4, reject) => {
+          return new Promise((resolve5, reject) => {
             sharp.metadata(this.options, (err2, metadata2) => {
               if (err2) {
                 reject(is.nativeError(err2, stack));
               } else {
-                resolve4(metadata2);
+                resolve5(metadata2);
               }
             });
           });
@@ -7448,25 +7448,25 @@ var require_input = __commonJS({
         return this;
       } else {
         if (this._isStreamInput()) {
-          return new Promise((resolve4, reject) => {
+          return new Promise((resolve5, reject) => {
             this.on("finish", function() {
               this._flattenBufferIn();
               sharp.stats(this.options, (err2, stats2) => {
                 if (err2) {
                   reject(is.nativeError(err2, stack));
                 } else {
-                  resolve4(stats2);
+                  resolve5(stats2);
                 }
               });
             });
           });
         } else {
-          return new Promise((resolve4, reject) => {
+          return new Promise((resolve5, reject) => {
             sharp.stats(this.options, (err2, stats2) => {
               if (err2) {
                 reject(is.nativeError(err2, stack));
               } else {
-                resolve4(stats2);
+                resolve5(stats2);
               }
             });
           });
@@ -9242,7 +9242,7 @@ var require_output = __commonJS({
         return this;
       } else {
         if (this._isStreamInput()) {
-          return new Promise((resolve4, reject) => {
+          return new Promise((resolve5, reject) => {
             this.once("finish", () => {
               this._flattenBufferIn();
               sharp.pipeline(this.options, (err2, data, info) => {
@@ -9250,24 +9250,24 @@ var require_output = __commonJS({
                   reject(is.nativeError(err2, stack));
                 } else {
                   if (this.options.resolveWithObject) {
-                    resolve4({ data, info });
+                    resolve5({ data, info });
                   } else {
-                    resolve4(data);
+                    resolve5(data);
                   }
                 }
               });
             });
           });
         } else {
-          return new Promise((resolve4, reject) => {
+          return new Promise((resolve5, reject) => {
             sharp.pipeline(this.options, (err2, data, info) => {
               if (err2) {
                 reject(is.nativeError(err2, stack));
               } else {
                 if (this.options.resolveWithObject) {
-                  resolve4({ data, info });
+                  resolve5({ data, info });
                 } else {
-                  resolve4(data);
+                  resolve5(data);
                 }
               }
             });
@@ -9475,7 +9475,7 @@ var {
 } = import_index.default;
 
 // src/cli.ts
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 
 // src/baseline.ts
 init_define_import_meta_env();
@@ -9492,7 +9492,7 @@ init_define_import_meta_env();
 import { createRequire } from "node:module";
 function resolveVersion() {
   if (true) {
-    return "2.0.1";
+    return "2.0.2";
   }
   const require2 = createRequire(import.meta.url);
   const pkg = require2("../package.json");
@@ -10297,8 +10297,11 @@ function wasFileReadThisSession(filePath) {
 function getSessionWebFetches() {
   return _webFetches;
 }
-function getBashOutputId(commandHash) {
-  return _bashOutputs.get(commandHash) ?? null;
+function recordBashOutput(commandHash2, outputId, _sizeBytes) {
+  _bashOutputs.set(commandHash2, outputId);
+}
+function getBashOutputId(commandHash2) {
+  return _bashOutputs.get(commandHash2) ?? null;
 }
 registerReset(() => {
   _files = /* @__PURE__ */ new Map();
@@ -10624,7 +10627,19 @@ var MONITORING_COMMAND_PATTERNS = [
   { pattern: /^(?:npx\s+)?eslint(?:\s|$)/, recallHint: '--grep "error|warning|\u2716|problems"' },
   { pattern: /^(?:npx\s+)?prettier(?:\s|$)/, recallHint: '--grep "unchanged|reformatted|error"' },
   { pattern: /^ruff(?:\s|$)/, recallHint: '--grep "error|warning|Found"' },
-  { pattern: /^(?:cargo\s+)?clippy/, recallHint: '--grep "error\\[|warning\\["' }
+  { 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"' },
+  // 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"' },
+  // 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" }
 ];
 function getMonitoringRecallHint(cmd) {
   for (const { pattern, recallHint } of MONITORING_COMMAND_PATTERNS) {
@@ -11334,11 +11349,164 @@ function fingerprintFile(filePath) {
   return fingerprintContent(data);
 }
 
+// src/bash_output_cache.ts
+init_define_import_meta_env();
+import * as fs7 from "fs/promises";
+import { resolve as resolve3 } from "path";
+var _byId = /* @__PURE__ */ new Map();
+var _globsByKey = /* @__PURE__ */ new Map();
+var _grepsByKey = /* @__PURE__ */ new Map();
+var GIT_MUTABLE_RE = /^\s*git\s+(diff|status)\b/i;
+var LS_CMD_RE = /^\s*(?:ls|eza|exa|dir|Get-ChildItem|gci)\b/i;
+var DEP_LIST_RE = /^\s*(?:npm\s+(?:-\S+\s+)*(?:ls|list)\b|pip\s+(?:-\S+\s+)*(?:list|freeze)\b|uv\s+pip\s+(?:-\S+\s+)*(?:list|freeze)\b|pnpm\s+(?:-\S+\s+)*(?:list|ls)\b|yarn\s+(?:-\S+\s+)*(?:list)\b|cargo\s+(?:-\S+\s+)*tree\b|bundle\s+(?:-\S+\s+)*(?:list|show)\b|composer\s+(?:-\S+\s+)*show\b)/i;
+var NPM_INSTALL_RE = /^\s*npm\s+(?:-\S+\s+)*(?:install|ci)\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 isGitMutableCommand(cmd) {
+  return GIT_MUTABLE_RE.test(cmd);
+}
+function isDirListingCommand(cmd) {
+  return LS_CMD_RE.test(cmd);
+}
+function isDepListCommand(cmd) {
+  return DEP_LIST_RE.test(cmd);
+}
+function isNpmInstallCommand(cmd) {
+  return NPM_INSTALL_RE.test(cmd);
+}
+async function gitStateFingerprint(cwd) {
+  try {
+    const headResult = runGit(["rev-parse", "HEAD"], { cwd });
+    if (headResult.exitCode !== 0) return null;
+    const headSha = headResult.stdout.trim();
+    let indexMtime = "";
+    try {
+      const stat3 = await fs7.stat(resolve3(cwd, ".git", "index"));
+      indexMtime = stat3.mtimeMs.toString();
+    } catch {
+    }
+    const key = `${headSha}\0${indexMtime}`;
+    return fingerprintContent(key).slice(0, 16);
+  } catch {
+    return null;
+  }
+}
+async function dirStateFingerprint(path14) {
+  try {
+    const stat3 = await fs7.stat(path14);
+    if (!stat3.isDirectory()) return null;
+    return fingerprintContent(stat3.mtimeMs.toString()).slice(0, 16);
+  } catch {
+    return null;
+  }
+}
+async function depLockfileFingerprint(cmd, cwd) {
+  if (!cwd) return null;
+  const stripped = cmd.trim();
+  const firstToken = stripped.split(/\s+/)[0]?.toLowerCase() || "";
+  const candidates = firstToken === "uv" ? DEP_LOCKFILES["uv"] : DEP_LOCKFILES[firstToken];
+  if (!candidates) return null;
+  for (const lockfile of candidates) {
+    try {
+      const content = await fs7.readFile(resolve3(cwd, lockfile));
+      return fingerprintContent(content).slice(0, 16);
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function normalizeCommandForCacheKey(cmd) {
+  let normalized = cmd.trim();
+  normalized = normalized.replace(/\s+/g, " ");
+  normalized = normalized.replace(/\\/g, "/");
+  const tokens = normalized.split(" ");
+  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(" ");
+}
+async function commandHash(command, cwd = null) {
+  const normalized = normalizeCommandForCacheKey(command);
+  let key = cwd ? `${normalizePath(cwd)}\0${normalized}` : normalized;
+  if (cwd && isGitMutableCommand(command)) {
+    const fp = await gitStateFingerprint(cwd);
+    if (fp) key = `${key}\0git:${fp}`;
+  }
+  if (cwd && isDirListingCommand(command)) {
+    const target = extractLsTarget(command, cwd);
+    if (target) {
+      const fp = await dirStateFingerprint(target);
+      if (fp) key = `${key}\0dir:${fp}`;
+    }
+  }
+  if (isDepListCommand(command)) {
+    const fp = await depLockfileFingerprint(command, cwd);
+    if (fp) key = `${key}\0lockfile:${fp}`;
+  }
+  if (cwd && isNpmInstallCommand(command)) {
+    const fp = await depLockfileFingerprint(command, cwd);
+    if (fp) key = `${key}\0npm-install:${fp}`;
+  }
+  return fingerprintContent(key).slice(0, 16);
+}
+function extractLsTarget(cmd, cwd) {
+  const tokens = cmd.trim().split(/\s+/);
+  for (let i = 1; i < tokens.length; i++) {
+    if (!tokens[i].startsWith("-")) {
+      return tokens[i];
+    }
+  }
+  return cwd;
+}
+async function storeBashOutput(command, output, exitCode, cwd = null) {
+  const id = await commandHash(command, cwd);
+  const entry = {
+    id,
+    command,
+    output,
+    exitCode,
+    storedAt: Date.now(),
+    sizeBytes: Buffer.byteLength(output, "utf-8")
+  };
+  _byId.set(id, entry);
+  return id;
+}
+function getBashOutput(id) {
+  return _byId.get(id) ?? null;
+}
+registerReset(() => {
+  _byId = /* @__PURE__ */ new Map();
+  _globsByKey = /* @__PURE__ */ new Map();
+  _grepsByKey = /* @__PURE__ */ new Map();
+});
+
 // src/hooks_bash.ts
 function extractCommand(event) {
   const cmd = event.toolInput["command"];
   return typeof cmd === "string" && cmd.trim() !== "" ? cmd.trim() : void 0;
 }
+function extractCatSourceFile(cmd) {
+  const m = /^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*$/.exec(cmd);
+  return m?.[1] ?? null;
+}
 function isTscCommand(cmd) {
   return /^\s*tsc(\s|$)/i.test(cmd);
 }
@@ -11363,6 +11531,12 @@ function preBashHandler(event) {
     const monCmdHash = fingerprintContent(cmd).slice(0, 16);
     const monOutputId = getBashOutputId(monCmdHash);
     if (monOutputId !== null) {
+      const catFile = extractCatSourceFile(cmd);
+      if (catFile !== null) {
+        return contextOutput(
+          "Prior output from `" + cmd + "` is cached. Use `token-goat bash-output " + monOutputId + "` to recall the full file, or `token-goat read '" + catFile + "::SymbolName'` to extract only the symbol you need."
+        );
+      }
       const cmdSummary = cmd.length > 60 ? cmd.slice(0, 57) + "..." : cmd;
       return contextOutput(
         "Prior output from `" + cmdSummary + "` is cached.\nUse `token-goat bash-output " + monOutputId + " " + monitoringHint + "` to re-inspect without re-running."
@@ -11376,10 +11550,39 @@ function preBashHandler(event) {
   return contextOutput(buildRecallHint(cmd, outputId));
 }
 registerHook("pre_tool_use", preBashHandler, { toolName: "Bash" });
+var MIN_CACHE_BYTES = 512;
+function extractBashOutput(raw) {
+  const resp = raw["tool_response"];
+  if (typeof resp === "string") return resp;
+  if (resp !== null && typeof resp === "object") {
+    const r = resp;
+    for (const key of ["output", "content", "text", "body"]) {
+      if (typeof r[key] === "string") return r[key];
+    }
+  }
+  return "";
+}
+async function postBashHandler(event) {
+  try {
+    const cmd = extractCommand(event);
+    if (cmd === void 0) return passOutput();
+    const isMonitoring = getMonitoringRecallHint(cmd) !== null;
+    if (!isMonitoring && !isBuildCommand(cmd)) return passOutput();
+    const output = extractBashOutput(event.raw);
+    if (Buffer.byteLength(output, "utf-8") < MIN_CACHE_BYTES) return passOutput();
+    const cwd = typeof event.raw["cwd"] === "string" ? event.raw["cwd"] : null;
+    const simpleHash = fingerprintContent(cmd).slice(0, 16);
+    const id = await storeBashOutput(cmd, output, 0, cwd);
+    recordBashOutput(simpleHash, id, Buffer.byteLength(output, "utf-8"));
+  } catch {
+  }
+  return passOutput();
+}
+registerHook("post_tool_use", postBashHandler, { toolName: "Bash" });
 
 // src/image_shrink.ts
 init_define_import_meta_env();
-import * as fs7 from "node:fs";
+import * as fs8 from "node:fs";
 import * as path9 from "node:path";
 var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".png",
@@ -11445,7 +11648,7 @@ async function shrinkImage(input, opts) {
 }
 function statSize2(absPath) {
   try {
-    const st = fs7.statSync(absPath);
+    const st = fs8.statSync(absPath);
     return st.isFile() ? st.size : null;
   } catch {
     return null;
@@ -11459,7 +11662,7 @@ async function preReadImageHandler(event) {
   if (size === null || size < DEFAULT_SIZE_THRESHOLD_BYTES) return passOutput();
   let input;
   try {
-    input = fs7.readFileSync(filePath);
+    input = fs8.readFileSync(filePath);
   } catch {
     return passOutput();
   }
@@ -11477,7 +11680,7 @@ registerHook("pre_tool_use", preReadImageHandler, { toolName: "Read" });
 // src/relay.ts
 var DEFAULT_STDIN_TIMEOUT_MS = 5e3;
 function readStdinJson(timeoutMs = DEFAULT_STDIN_TIMEOUT_MS) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const chunks = [];
     let settled = false;
     const finish = (fn) => {
@@ -11503,7 +11706,7 @@ function readStdinJson(timeoutMs = DEFAULT_STDIN_TIMEOUT_MS) {
           return;
         }
         try {
-          resolve4(JSON.parse(text));
+          resolve5(JSON.parse(text));
         } catch (err2) {
           reject(err2 instanceof Error ? err2 : new Error(String(err2)));
         }
@@ -11666,7 +11869,7 @@ function readSection(filePath, headingSpec) {
 
 // src/install.ts
 init_define_import_meta_env();
-import * as fs8 from "node:fs";
+import * as fs9 from "node:fs";
 import * as os2 from "node:os";
 import * as path10 from "node:path";
 var HOOK_EVENT_MAP = [
@@ -11685,7 +11888,7 @@ function settingsPath(scope) {
 function readSettings(p) {
   let raw;
   try {
-    raw = fs8.readFileSync(p, "utf8");
+    raw = fs9.readFileSync(p, "utf8");
   } catch {
     return {};
   }
@@ -11725,7 +11928,7 @@ function installHooks(scope = "user") {
     return { scope, settingsPath: p, alreadyInstalled: true };
   }
   settings.hooks = hooks;
-  fs8.mkdirSync(path10.dirname(p), { recursive: true });
+  fs9.mkdirSync(path10.dirname(p), { recursive: true });
   atomicWriteText(p, `${JSON.stringify(settings, null, 2)}
 `);
   return { scope, settingsPath: p, alreadyInstalled: false };
@@ -11764,7 +11967,7 @@ function uninstallHooks(scope = "user") {
   } else {
     settings.hooks = hooks;
   }
-  fs8.mkdirSync(path10.dirname(p), { recursive: true });
+  fs9.mkdirSync(path10.dirname(p), { recursive: true });
   atomicWriteText(p, `${JSON.stringify(settings, null, 2)}
 `);
   return true;
@@ -11773,7 +11976,7 @@ function uninstallHooks(scope = "user") {
 // src/worker.ts
 init_define_import_meta_env();
 import { spawn } from "node:child_process";
-import * as fs9 from "node:fs";
+import * as fs10 from "node:fs";
 import * as path11 from "node:path";
 import { Worker, isMainThread, parentPort, workerData } from "node:worker_threads";
 import { fileURLToPath } from "node:url";
@@ -11787,7 +11990,7 @@ function workerPidPath(dir = dataDir()) {
 function getDirtyPathsFor(dir) {
   let raw;
   try {
-    raw = fs9.readFileSync(dirtyQueuePathFor(dir), "utf8");
+    raw = fs10.readFileSync(dirtyQueuePathFor(dir), "utf8");
   } catch {
     return [];
   }
@@ -11803,7 +12006,7 @@ function getDirtyPathsFor(dir) {
 }
 function clearDirtyQueueFor(dir) {
   try {
-    fs9.rmSync(dirtyQueuePathFor(dir), { force: true });
+    fs10.rmSync(dirtyQueuePathFor(dir), { force: true });
   } catch {
   }
 }
@@ -11813,7 +12016,7 @@ function processDirtyBatch(paths, index = (absPath) => {
 }) {
   let indexed = 0;
   for (const p of paths) {
-    if (!fs9.existsSync(p)) continue;
+    if (!fs10.existsSync(p)) continue;
     const sha = fingerprintFile(p);
     if (sha === null) continue;
     index(p, sha);
@@ -11838,7 +12041,7 @@ function pidAlive(pid) {
 }
 function readPidFile(dir) {
   try {
-    const raw = fs9.readFileSync(workerPidPath(dir), "utf8").trim();
+    const raw = fs10.readFileSync(workerPidPath(dir), "utf8").trim();
     if (!/^\d+$/.test(raw)) return null;
     return parseInt(raw, 10);
   } catch {
@@ -11861,7 +12064,7 @@ function stopWorker(dir = dataDir()) {
     }
   }
   try {
-    fs9.rmSync(workerPidPath(dir), { force: true });
+    fs10.rmSync(workerPidPath(dir), { force: true });
   } catch {
   }
   return alive;
@@ -11869,7 +12072,7 @@ function stopWorker(dir = dataDir()) {
 function startDetachedWorker(opts) {
   const pollIntervalMs = opts?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
   const dir = opts?.dataDir ?? dataDir();
-  fs9.mkdirSync(dir, { recursive: true });
+  fs10.mkdirSync(dir, { recursive: true });
   const child = spawn(
     process.execPath,
     [fileURLToPath(import.meta.url), "--worker-daemon"],
@@ -11888,7 +12091,7 @@ function startDetachedWorker(opts) {
   if (pid === void 0) {
     throw new Error("startDetachedWorker: spawn produced no pid");
   }
-  fs9.writeFileSync(workerPidPath(dir), `${pid}
+  fs10.writeFileSync(workerPidPath(dir), `${pid}
 `);
   child.unref();
   return pid;
@@ -11900,7 +12103,7 @@ async function runWorkerLoop(dir, pollIntervalMs, shouldStop = () => false) {
     } catch {
     }
     if (shouldStop()) break;
-    await new Promise((resolve4) => setTimeout(resolve4, pollIntervalMs));
+    await new Promise((resolve5) => setTimeout(resolve5, pollIntervalMs));
   }
 }
 function workerEntry() {
@@ -11925,24 +12128,10 @@ function workerEntry() {
 }
 workerEntry();
 
-// src/bash_output_cache.ts
-init_define_import_meta_env();
-var _byId = /* @__PURE__ */ new Map();
-var _globsByKey = /* @__PURE__ */ new Map();
-var _grepsByKey = /* @__PURE__ */ new Map();
-function getBashOutput(id) {
-  return _byId.get(id) ?? null;
-}
-registerReset(() => {
-  _byId = /* @__PURE__ */ new Map();
-  _globsByKey = /* @__PURE__ */ new Map();
-  _grepsByKey = /* @__PURE__ */ new Map();
-});
-
 // src/skill_cache.ts
 init_define_import_meta_env();
-import * as fs10 from "fs/promises";
-import { resolve as resolve3 } from "path";
+import * as fs11 from "fs/promises";
+import { resolve as resolve4 } from "path";
 var COMPACT_END_MARKER = "<!-- COMPACT_END -->";
 var _skillOutputsDirOverride = null;
 registerReset(() => {
@@ -11950,11 +12139,11 @@ registerReset(() => {
 });
 function skillOutputsDir() {
   if (_skillOutputsDirOverride) return _skillOutputsDirOverride;
-  return resolve3(dataDir(), "skills");
+  return resolve4(dataDir(), "skills");
 }
 async function ensureSkillsDir() {
   try {
-    await fs10.mkdir(skillOutputsDir(), { recursive: true });
+    await fs11.mkdir(skillOutputsDir(), { recursive: true });
   } catch {
   }
 }
@@ -11996,14 +12185,14 @@ function extractCompactFromMarker(body) {
 async function listOutputs() {
   try {
     const dir = skillOutputsDir();
-    const entries = await fs10.readdir(dir, { withFileTypes: true });
+    const entries = await fs11.readdir(dir, { withFileTypes: true });
     const metas = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".meta")) {
         continue;
       }
       try {
-        const content = await fs10.readFile(resolve3(dir, entry.name), "utf-8");
+        const content = await fs11.readFile(resolve4(dir, entry.name), "utf-8");
         const meta = JSON.parse(content);
         metas.push(meta);
       } catch {
@@ -12028,7 +12217,7 @@ async function storeCompact(sessionId, skillName, compactText, sourceSha) {
       text = `<!-- source_sha: ${sourceSha.slice(0, 12)} -->
 ${text}`;
     }
-    await atomicWriteText(resolve3(dir, fileId), text);
+    await atomicWriteText(resolve4(dir, fileId), text);
   } catch {
   }
 }
@@ -12048,13 +12237,13 @@ async function listSkills(sessionId) {
       const compactFileId = `${safeSession}-${meta.skillName.replace(":", "_")}-compact`;
       let compactLen = 0;
       try {
-        const stat2 = await fs10.stat(resolve3(dir, compactFileId));
-        compactLen = stat2.size;
+        const stat3 = await fs11.stat(resolve4(dir, compactFileId));
+        compactLen = stat3.size;
       } catch {
         compactLen = 0;
       }
       const hasMarker = extractCompactFromMarker(
-        await fs10.readFile(resolve3(dir, `${meta.outputId}.txt`), "utf-8").catch(() => "")
+        await fs11.readFile(resolve4(dir, `${meta.outputId}.txt`), "utf-8").catch(() => "")
       ) !== null;
       results.push({
         name: meta.skillName,
@@ -12086,7 +12275,7 @@ async function getSkillFilePath(skillName) {
 
 // src/config.ts
 init_define_import_meta_env();
-import * as fs11 from "node:fs";
+import * as fs12 from "node:fs";
 
 // node_modules/smol-toml/dist/index.js
 init_define_import_meta_env();
@@ -13071,7 +13260,7 @@ function loadConfig() {
   const p = configPath();
   let currentMtime = 0;
   try {
-    currentMtime = fs11.statSync(p).mtimeMs;
+    currentMtime = fs12.statSync(p).mtimeMs;
   } catch {
   }
   const envFp = configEnvFingerprint();
@@ -13081,7 +13270,7 @@ function loadConfig() {
   let raw = {};
   if (currentMtime !== 0) {
     try {
-      const text = fs11.readFileSync(p, "utf8");
+      const text = fs12.readFileSync(p, "utf8");
       raw = parse(text);
     } catch {
     }
@@ -14232,7 +14421,7 @@ function renderStats2(opts) {
 
 // src/cli_doctor.ts
 init_define_import_meta_env();
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 import * as path13 from "path";
 import { execSync } from "child_process";
 function checkWorkerRunning() {
@@ -14245,7 +14434,7 @@ function checkWorkerRunning() {
 }
 function checkDbExists(dataDir2) {
   const dbPath = path13.join(dataDir2, "index.db");
-  if (!fs12.existsSync(dbPath)) {
+  if (!fs13.existsSync(dbPath)) {
     return {
       name: "Database",
       status: "warn",
@@ -14255,7 +14444,7 @@ function checkDbExists(dataDir2) {
   return {
     name: "Database",
     status: "ok",
-    message: `index.db exists (${Math.round(fs12.statSync(dbPath).size / 1024)} KB)`
+    message: `index.db exists (${Math.round(fs13.statSync(dbPath).size / 1024)} KB)`
   };
 }
 function checkInstall() {
@@ -14275,7 +14464,7 @@ function checkInstall() {
   }
 }
 function checkConfigValid(configPath2) {
-  if (!fs12.existsSync(configPath2)) {
+  if (!fs13.existsSync(configPath2)) {
     return {
       name: "Config",
       status: "warn",
@@ -14283,7 +14472,7 @@ function checkConfigValid(configPath2) {
     };
   }
   try {
-    const content = fs12.readFileSync(configPath2, "utf-8");
+    const content = fs13.readFileSync(configPath2, "utf-8");
     JSON.parse(content);
     return {
       name: "Config",
@@ -14647,7 +14836,7 @@ function cmdBashOutput(id, opts) {
   if (opts.file !== void 0) {
     let content;
     try {
-      content = fs13.readFileSync(opts.file, "utf-8");
+      content = fs14.readFileSync(opts.file, "utf-8");
     } catch {
       throw new CliError(`cannot read file: ${opts.file}`);
     }
@@ -14668,7 +14857,7 @@ async function cmdSkillBody(name, opts) {
   if (filePath === null) {
     throw new CliError(`skill '${name}' not found`);
   }
-  const body = fs13.readFileSync(filePath, "utf-8");
+  const body = fs14.readFileSync(filePath, "utf-8");
   if (opts.compact === true) {
     const lines = body.split("\n");
     const end = lines.findIndex((l) => l.includes("COMPACT_END"));
@@ -14686,7 +14875,7 @@ async function cmdSkillCompact(name) {
   if (filePath === null) {
     throw new CliError(`skill '${name}' not found`);
   }
-  const body = fs13.readFileSync(filePath, "utf-8");
+  const body = fs14.readFileSync(filePath, "utf-8");
   const sessionFiles = getSessionFiles();
   const sessionId = Array.from(sessionFiles.keys())[0] ?? "default";
   await storeCompact(sessionId, name, body);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "token-goat",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "Surgical token-reduction companion for Claude Code and other AI coding agents",
   "type": "module",
   "main": "./dist/token-goat.mjs",