token-goat 2.2.3 → 2.2.4

package/dist/token-goat.mjs

@@ -981,8 +981,8 @@ var require_command = __commonJS({
     init_define_import_meta_env();
     var EventEmitter = __require("node:events").EventEmitter;
     var childProcess = __require("node:child_process");
-    var path19 = __require("node:path");
-    var fs18 = __require("node:fs");
+    var path22 = __require("node:path");
+    var fs20 = __require("node:fs");
     var process2 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1914,11 +1914,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path19.resolve(baseDir, baseName);
-          if (fs18.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path19.extname(baseName))) return void 0;
+          const localBin = path22.resolve(baseDir, baseName);
+          if (fs20.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path22.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs18.existsSync(`${localBin}${ext}`)
+            (ext) => fs20.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1930,21 +1930,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs18.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs20.realpathSync(this._scriptPath);
           } catch (err2) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path19.resolve(
-            path19.dirname(resolvedScriptPath),
+          executableDir = path22.resolve(
+            path22.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path19.basename(
+            const legacyName = path22.basename(
               this._scriptPath,
-              path19.extname(this._scriptPath)
+              path22.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1955,7 +1955,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path19.extname(executableFile));
+        launchWithNode = sourceExt.includes(path22.extname(executableFile));
         let proc;
         if (process2.platform !== "win32") {
           if (launchWithNode) {
@@ -2795,7 +2795,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path19.basename(filename, path19.extname(filename));
+        this._name = path22.basename(filename, path22.extname(filename));
         return this;
       }
       /**
@@ -2809,9 +2809,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path20) {
-        if (path20 === void 0) return this._executableDir;
-        this._executableDir = path20;
+      executableDir(path23) {
+        if (path23 === void 0) return this._executableDir;
+        this._executableDir = path23;
         return this;
       }
       /**
@@ -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 fs18 = __require("fs");
+    var fs20 = __require("fs");
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
-    var readFileSync14 = (path19) => {
-      const fd = fs18.openSync(path19, "r");
+    var readFileSync16 = (path22) => {
+      const fd = fs20.openSync(path22, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
-      const bytesRead = fs18.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-      fs18.close(fd, () => {
+      const bytesRead = fs20.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs20.close(fd, () => {
       });
       return buffer.subarray(0, bytesRead);
     };
-    var readFile3 = (path19) => new Promise((resolve7, reject) => {
-      fs18.open(path19, "r", (err2, fd) => {
+    var readFile3 = (path22) => new Promise((resolve8, reject) => {
+      fs20.open(path22, "r", (err2, fd) => {
         if (err2) {
           reject(err2);
         } else {
           const buffer = Buffer.alloc(MAX_LENGTH);
-          fs18.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
-            resolve7(buffer.subarray(0, bytesRead));
-            fs18.close(fd, () => {
+          fs20.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+            resolve8(buffer.subarray(0, bytesRead));
+            fs20.close(fd, () => {
             });
           });
         }
@@ -3187,7 +3187,7 @@ var require_filesystem = __commonJS({
     module.exports = {
       LDD_PATH,
       SELF_PATH,
-      readFileSync: readFileSync14,
+      readFileSync: readFileSync16,
       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: readFile3, readFileSync: readFileSync14 } = require_filesystem();
+    var { LDD_PATH, SELF_PATH, readFile: readFile3, readFileSync: readFileSync16 } = 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((resolve7) => {
+        return new Promise((resolve8) => {
           childProcess.exec(command, (err2, out2) => {
             commandOut = err2 ? " " : out2;
-            resolve7(commandOut);
+            resolve8(commandOut);
           });
         });
       }
@@ -3292,11 +3292,11 @@ var require_detect_libc = __commonJS({
       }
       return null;
     };
-    var familyFromInterpreterPath = (path19) => {
-      if (path19) {
-        if (path19.includes("/ld-musl-")) {
+    var familyFromInterpreterPath = (path22) => {
+      if (path22) {
+        if (path22.includes("/ld-musl-")) {
           return MUSL;
-        } else if (path19.includes("/ld-linux-")) {
+        } else if (path22.includes("/ld-linux-")) {
           return GLIBC;
         }
       }
@@ -3330,7 +3330,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyFilesystem = null;
       try {
-        const lddContent = readFileSync14(LDD_PATH);
+        const lddContent = readFileSync16(LDD_PATH);
         cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
       } catch (e) {
       }
@@ -3343,8 +3343,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = await readFile3(SELF_PATH);
-        const path19 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path19);
+        const path22 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path22);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -3355,9 +3355,9 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyInterpreter = null;
       try {
-        const selfContent = readFileSync14(SELF_PATH);
-        const path19 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path19);
+        const selfContent = readFileSync16(SELF_PATH);
+        const path22 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path22);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -3419,7 +3419,7 @@ var require_detect_libc = __commonJS({
       }
       cachedVersionFilesystem = null;
       try {
-        const lddContent = readFileSync14(LDD_PATH);
+        const lddContent = readFileSync16(LDD_PATH);
         const versionMatch = lddContent.match(RE_GLIBC_VERSION);
         if (versionMatch) {
           cachedVersionFilesystem = versionMatch[1];
@@ -3965,7 +3965,7 @@ var require_parse = __commonJS({
     "use strict";
     init_define_import_meta_env();
     var SemVer = require_semver();
-    var parse2 = (version, options, throwErrors = false) => {
+    var parse3 = (version, options, throwErrors = false) => {
       if (version instanceof SemVer) {
         return version;
       }
@@ -3978,7 +3978,7 @@ var require_parse = __commonJS({
         throw er;
       }
     };
-    module.exports = parse2;
+    module.exports = parse3;
   }
 });
 
@@ -3988,9 +3988,9 @@ var require_coerce = __commonJS({
     "use strict";
     init_define_import_meta_env();
     var SemVer = require_semver();
-    var parse2 = require_parse();
+    var parse3 = require_parse();
     var { safeRe: re, t } = require_re();
-    var coerce = (version, options) => {
+    var coerce2 = (version, options) => {
       if (version instanceof SemVer) {
         return version;
       }
@@ -4023,9 +4023,9 @@ var require_coerce = __commonJS({
       const patch = match[4] || "0";
       const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
       const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
-      return parse2(`${major}.${minor}.${patch}${prerelease}${build}`, options);
+      return parse3(`${major}.${minor}.${patch}${prerelease}${build}`, options);
     };
-    module.exports = coerce;
+    module.exports = coerce2;
   }
 });
 
@@ -4947,7 +4947,7 @@ var require_libvips = __commonJS({
   "node_modules/sharp/lib/libvips.js"(exports, module) {
     "use strict";
     init_define_import_meta_env();
-    var { spawnSync: spawnSync3 } = __require("node:child_process");
+    var { spawnSync: spawnSync4 } = __require("node:child_process");
     var { createHash: createHash3 } = __require("node:crypto");
     var semverCoerce = require_coerce();
     var semverGreaterThanOrEqualTo = require_gte();
@@ -5032,7 +5032,7 @@ var require_libvips = __commonJS({
     };
     var isRosetta = () => {
       if (process.platform === "darwin" && process.arch === "x64") {
-        const translated = spawnSync3("sysctl sysctl.proc_translated", spawnSyncOptions).stdout;
+        const translated = spawnSync4("sysctl sysctl.proc_translated", spawnSyncOptions).stdout;
         return (translated || "").trim() === "sysctl.proc_translated: 1";
       }
       return false;
@@ -5047,13 +5047,13 @@ var require_libvips = __commonJS({
       }
       return "";
     };
-    var spawnRebuild = () => spawnSync3(`node-gyp rebuild --directory=src ${isEmscripten() ? "--nodedir=emscripten" : ""}`, {
+    var spawnRebuild = () => spawnSync4(`node-gyp rebuild --directory=src ${isEmscripten() ? "--nodedir=emscripten" : ""}`, {
       ...spawnSyncOptions,
       stdio: "inherit"
     }).status;
     var globalLibvipsVersion = () => {
       if (process.platform !== "win32") {
-        const globalLibvipsVersion2 = spawnSync3("pkg-config --modversion vips-cpp", {
+        const globalLibvipsVersion2 = spawnSync4("pkg-config --modversion vips-cpp", {
           ...spawnSyncOptions,
           env: {
             ...process.env,
@@ -5067,7 +5067,7 @@ var require_libvips = __commonJS({
     };
     var pkgConfigPath = () => {
       if (process.platform !== "win32") {
-        const brewPkgConfigPath = spawnSync3(
+        const brewPkgConfigPath = spawnSync4(
           'which brew >/dev/null 2>&1 && brew environment --plain | grep PKG_CONFIG_LIBDIR | cut -d" " -f2',
           spawnSyncOptions
         ).stdout || "";
@@ -5138,9 +5138,9 @@ var require_sharp = __commonJS({
     ];
     var sharp;
     var errors = [];
-    for (const path19 of paths) {
+    for (const path22 of paths) {
       try {
-        sharp = __require(path19);
+        sharp = __require(path22);
         break;
       } catch (err2) {
         errors.push(err2);
@@ -5149,7 +5149,7 @@ var require_sharp = __commonJS({
     if (sharp) {
       module.exports = sharp;
     } else {
-      const [isLinux, isMacOs, isWindows2] = ["linux", "darwin", "win32"].map((os4) => runtimePlatform.startsWith(os4));
+      const [isLinux, isMacOs, isWindows2] = ["linux", "darwin", "win32"].map((os7) => runtimePlatform.startsWith(os7));
       const help = [`Could not load the "sharp" module using the ${runtimePlatform} runtime`];
       errors.forEach((err2) => {
         if (err2.code !== "MODULE_NOT_FOUND") {
@@ -5166,15 +5166,15 @@ var require_sharp = __commonJS({
           `    Requires ${expected}`
         );
       } else if (prebuiltPlatforms.includes(runtimePlatform)) {
-        const [os4, cpu] = runtimePlatform.split("-");
-        const libc = os4.endsWith("musl") ? " --libc=musl" : "";
+        const [os7, cpu] = runtimePlatform.split("-");
+        const libc = os7.endsWith("musl") ? " --libc=musl" : "";
         help.push(
           "- Ensure optional dependencies can be installed:",
           "    npm install --include=optional sharp",
           "- Ensure your package manager supports multi-platform installation:",
           "    See https://sharp.pixelplumbing.com/install#cross-platform",
           "- Add platform-specific dependencies:",
-          `    npm install --os=${os4.replace("musl", "")}${libc} --cpu=${cpu} sharp`
+          `    npm install --os=${os7.replace("musl", "")}${libc} --cpu=${cpu} sharp`
         );
       } else {
         help.push(
@@ -6552,15 +6552,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path19 = [graph[toModel].parent, toModel];
+      const path22 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path19.unshift(graph[cur].parent);
+        path22.unshift(graph[cur].parent);
         fn = link(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path19;
+      fn.conversion = path22;
       return fn;
     }
     module.exports = function(fromModel) {
@@ -7392,14 +7392,14 @@ var require_input = __commonJS({
         return this;
       } else {
         if (this._isStreamInput()) {
-          return new Promise((resolve7, reject) => {
+          return new Promise((resolve8, reject) => {
             const finished = () => {
               this._flattenBufferIn();
               sharp.metadata(this.options, (err2, metadata2) => {
                 if (err2) {
                   reject(is.nativeError(err2, stack));
                 } else {
-                  resolve7(metadata2);
+                  resolve8(metadata2);
                 }
               });
             };
@@ -7410,12 +7410,12 @@ var require_input = __commonJS({
             }
           });
         } else {
-          return new Promise((resolve7, reject) => {
+          return new Promise((resolve8, reject) => {
             sharp.metadata(this.options, (err2, metadata2) => {
               if (err2) {
                 reject(is.nativeError(err2, stack));
               } else {
-                resolve7(metadata2);
+                resolve8(metadata2);
               }
             });
           });
@@ -7448,25 +7448,25 @@ var require_input = __commonJS({
         return this;
       } else {
         if (this._isStreamInput()) {
-          return new Promise((resolve7, reject) => {
+          return new Promise((resolve8, reject) => {
             this.on("finish", function() {
               this._flattenBufferIn();
               sharp.stats(this.options, (err2, stats2) => {
                 if (err2) {
                   reject(is.nativeError(err2, stack));
                 } else {
-                  resolve7(stats2);
+                  resolve8(stats2);
                 }
               });
             });
           });
         } else {
-          return new Promise((resolve7, reject) => {
+          return new Promise((resolve8, reject) => {
             sharp.stats(this.options, (err2, stats2) => {
               if (err2) {
                 reject(is.nativeError(err2, stack));
               } else {
-                resolve7(stats2);
+                resolve8(stats2);
               }
             });
           });
@@ -8107,7 +8107,7 @@ var require_operation = __commonJS({
       }
       return this;
     }
-    function normalise(options) {
+    function normalise2(options) {
       if (is.plainObject(options)) {
         if (is.defined(options.lower)) {
           if (is.number(options.lower) && is.inRange(options.lower, 0, 99)) {
@@ -8295,7 +8295,7 @@ var require_operation = __commonJS({
         unflatten,
         gamma,
         negate,
-        normalise,
+        normalise: normalise2,
         normalize,
         clahe,
         convolve,
@@ -8464,7 +8464,7 @@ var require_output = __commonJS({
   "node_modules/sharp/lib/output.js"(exports, module) {
     "use strict";
     init_define_import_meta_env();
-    var path19 = __require("node:path");
+    var path22 = __require("node:path");
     var is = require_is();
     var sharp = require_sharp();
     var formats = /* @__PURE__ */ new Map([
@@ -8495,9 +8495,9 @@ var require_output = __commonJS({
       let err2;
       if (!is.string(fileOut)) {
         err2 = new Error("Missing output file path");
-      } else if (is.string(this.options.input.file) && path19.resolve(this.options.input.file) === path19.resolve(fileOut)) {
+      } else if (is.string(this.options.input.file) && path22.resolve(this.options.input.file) === path22.resolve(fileOut)) {
         err2 = new Error("Cannot use same file for input and output");
-      } else if (jp2Regex.test(path19.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
+      } else if (jp2Regex.test(path22.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
         err2 = errJp2Save();
       }
       if (err2) {
@@ -9242,7 +9242,7 @@ var require_output = __commonJS({
         return this;
       } else {
         if (this._isStreamInput()) {
-          return new Promise((resolve7, reject) => {
+          return new Promise((resolve8, 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) {
-                    resolve7({ data, info });
+                    resolve8({ data, info });
                   } else {
-                    resolve7(data);
+                    resolve8(data);
                   }
                 }
               });
             });
           });
         } else {
-          return new Promise((resolve7, reject) => {
+          return new Promise((resolve8, reject) => {
             sharp.pipeline(this.options, (err2, data, info) => {
               if (err2) {
                 reject(is.nativeError(err2, stack));
               } else {
                 if (this.options.resolveWithObject) {
-                  resolve7({ data, info });
+                  resolve8({ data, info });
                 } else {
-                  resolve7(data);
+                  resolve8(data);
                 }
               }
             });
@@ -9475,8 +9475,8 @@ var {
 } = import_index.default;
 
 // src/cli.ts
-import * as fs17 from "fs";
-import * as path18 from "path";
+import * as fs19 from "fs";
+import * as path21 from "path";
 
 // src/baseline.ts
 init_define_import_meta_env();
@@ -9493,7 +9493,7 @@ init_define_import_meta_env();
 import { createRequire } from "node:module";
 function resolveVersion() {
   if (true) {
-    return "2.2.3";
+    return "2.2.4";
   }
   const require2 = createRequire(import.meta.url);
   const pkg = require2("../package.json");
@@ -10191,23 +10191,23 @@ function isNoisePath(inputPath) {
     }
   }
   const slashIdx = p.lastIndexOf("/");
-  const basename8 = slashIdx >= 0 ? p.slice(slashIdx + 1) : p;
-  if (NOISE_BASENAMES.has(basename8)) {
+  const basename9 = slashIdx >= 0 ? p.slice(slashIdx + 1) : p;
+  if (NOISE_BASENAMES.has(basename9)) {
     return true;
   }
-  if (basename8.startsWith(".improve-state-") || basename8.startsWith("improve_commit_msg_")) {
+  if (basename9.startsWith(".improve-state-") || basename9.startsWith("improve_commit_msg_")) {
     return true;
   }
-  const dotIdx = basename8.lastIndexOf(".");
+  const dotIdx = basename9.lastIndexOf(".");
   if (dotIdx >= 0) {
-    const ext = basename8.slice(dotIdx);
+    const ext = basename9.slice(dotIdx);
     if (NOISE_EXTS.has(ext)) {
       return true;
     }
   }
   for (const ext of NOISE_EXTS) {
     if (ext.includes(".") && ext.split(".").length > 2) {
-      if (basename8.endsWith(ext)) {
+      if (basename9.endsWith(ext)) {
         return true;
       }
     }
@@ -10294,6 +10294,48 @@ function formatMap(entries, opts = {}) {
   return lines.join("\n");
 }
 
+// src/walk_index.ts
+init_define_import_meta_env();
+import * as os2 from "node:os";
+import * as path7 from "node:path";
+function isWalkExcluded(file) {
+  const base = path7.basename(file).toLowerCase();
+  if (base === ".env" || base.startsWith(".env.")) return true;
+  if (base.endsWith(".d.ts")) return true;
+  return false;
+}
+function assertWalkableRoot(root) {
+  const resolved = path7.resolve(root);
+  const fold = (p) => process.platform === "win32" || process.platform === "darwin" ? p.toLowerCase() : p;
+  const norm = fold(normalizePath(resolved));
+  const fsRoot = fold(normalizePath(path7.parse(resolved).root));
+  if (norm === fsRoot) {
+    throw new Error(`refusing to walk-index a filesystem root: ${resolved}`);
+  }
+  const home = os2.homedir();
+  if (home) {
+    const normHome = fold(normalizePath(path7.resolve(home)));
+    if (norm === normHome) {
+      throw new Error(`refusing to walk-index the home directory: ${resolved}`);
+    }
+    const boundary = norm.endsWith("/") ? norm : `${norm}/`;
+    if (normHome.startsWith(boundary)) {
+      throw new Error(`refusing to walk-index '${resolved}' \u2014 it contains the home directory`);
+    }
+  }
+}
+function collectWalkIndexFiles(root) {
+  const resolved = path7.resolve(root);
+  assertWalkableRoot(resolved);
+  const { files } = walkProject(resolved);
+  if (files.length >= MAX_FILES_SCANNED) {
+    throw new Error(
+      `'${resolved}' has too many source files (>= ${MAX_FILES_SCANNED}); refusing to walk-index \u2014 index a git repo or point at a narrower path`
+    );
+  }
+  return files.filter((f) => !isWalkExcluded(f));
+}
+
 // src/session.ts
 init_define_import_meta_env();
 import { randomBytes, randomUUID } from "node:crypto";
@@ -10361,6 +10403,9 @@ function wasFileReadThisSession(filePath) {
   const entry = _files.get(normalizePath(filePath));
   return entry !== void 0 && entry.readCount > 0;
 }
+function recordWebFetch(url, cacheId) {
+  _webFetches.set(url, cacheId);
+}
 function getSessionWebFetches() {
   return _webFetches;
 }
@@ -10409,6 +10454,25 @@ function getSessionId() {
   _sessionId = fromEnv !== void 0 && fromEnv !== "" ? fromEnv : generateSessionId();
   return _sessionId;
 }
+function exportSessionState() {
+  return {
+    files: Array.from(_files.values()),
+    hintsShown: Array.from(_hintsShown),
+    webFetches: Array.from(_webFetches.entries()),
+    bashOutputs: Array.from(_bashOutputs.entries()),
+    curlDownloads: Array.from(_curlDownloads.entries())
+  };
+}
+function importSessionState(s) {
+  _files = /* @__PURE__ */ new Map();
+  for (const e of s.files) {
+    if (e && typeof e.path === "string") _files.set(e.path, e);
+  }
+  _hintsShown = new Set(s.hintsShown);
+  _webFetches = new Map(s.webFetches);
+  _bashOutputs = new Map(s.bashOutputs);
+  _curlDownloads = new Map(s.curlDownloads);
+}
 registerReset(() => {
   _files = /* @__PURE__ */ new Map();
   _hintsShown = /* @__PURE__ */ new Set();
@@ -10728,7 +10792,8 @@ function assignFlatEndLines(sections, totalLines) {
     const next = sections[i + 1];
     const s = sections[i];
     if (s === void 0) continue;
-    s.endLine = next !== void 0 ? next.line - 1 : totalLines;
+    const end = next !== void 0 ? next.line - 1 : totalLines;
+    s.endLine = end < s.line ? s.line : end;
   }
 }
 function propagateEndLinesToSymbols(symbols, sections) {
@@ -10860,7 +10925,7 @@ function extractHtml(content, filePath) {
 
 // src/languages/liquid.ts
 init_define_import_meta_env();
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 var INCLUDE_RE = /{%\s*include\s+['"]([^'"]+)['"]/gi;
 var SECTION_RE = /{%\s*section\s+['"]([^'"]+)['"]/gi;
 var RENDER_RE = /{%\s*render\s+['"]([^'"]+)['"]/gi;
@@ -10904,7 +10969,7 @@ function extractLiquid(content, filePath, relPath) {
   const resolvedRel = relPath ?? filePath;
   const relPosix = resolvedRel.replace(/\\/g, "/");
   if (relPosix.startsWith("sections/") || relPosix.includes("/sections/")) {
-    const stem = path7.basename(resolvedRel, path7.extname(resolvedRel));
+    const stem = path8.basename(resolvedRel, path8.extname(resolvedRel));
     symbols.push({ filePath, name: stem, kind: "liquid_section_file", lineStart: 1, lineEnd: 1, body: "", docstring: "" });
   }
   const totalLines = content.split("\n").length;
@@ -12204,6 +12269,14 @@ function serializeOutput(output) {
       return JSON.stringify({ context: output.context });
     case "update":
       return JSON.stringify({ updatedInput: { content: output.content } });
+    case "rewriteInput":
+      return JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "allow",
+          updatedInput: output.updatedInput
+        }
+      });
     case "pass":
       return JSON.stringify({});
   }
@@ -12222,11 +12295,239 @@ var HOOK_EVENTS = [
   "subagent_stop"
 ];
 
-// src/hooks_read.ts
+// src/session_store.ts
 init_define_import_meta_env();
-import * as fs8 from "node:fs";
+import * as fs7 from "node:fs";
 import * as path10 from "node:path";
 
+// src/disk_cache.ts
+init_define_import_meta_env();
+import * as fs6 from "node:fs";
+import * as path9 from "node:path";
+import * as os3 from "node:os";
+var DEFAULT_MAX_COUNT = 200;
+var DEFAULT_MAX_AGE_MS = 24 * 3600 * 1e3;
+var ID_SANITIZE_RE = /[^a-zA-Z0-9_-]/g;
+function tokenGoatHome() {
+  const override = process.env["TOKEN_GOAT_HOME"];
+  if (override !== void 0 && override !== "") return override;
+  return path9.join(os3.homedir(), ".token-goat");
+}
+function sanitizeId(id) {
+  return id.replace(ID_SANITIZE_RE, "_").slice(0, 64);
+}
+function blobDir(subdir) {
+  return path9.join(tokenGoatHome(), subdir);
+}
+function blobPath(subdir, id) {
+  const safe = sanitizeId(id);
+  if (!safe) return null;
+  const dir = blobDir(subdir);
+  const candidate = path9.join(dir, `${safe}.json`);
+  try {
+    const rel = path9.relative(dir, candidate);
+    if (rel.startsWith("..")) return null;
+  } catch {
+    return null;
+  }
+  return candidate;
+}
+function storeBlob(subdir, id, value, opts = {}) {
+  const p = blobPath(subdir, id);
+  if (!p) return false;
+  try {
+    const dir = path9.dirname(p);
+    if (!fs6.existsSync(dir)) fs6.mkdirSync(dir, { recursive: true });
+    atomicWriteText(p, JSON.stringify(value));
+  } catch {
+    return false;
+  }
+  pruneBlobs(subdir, opts.maxCount ?? DEFAULT_MAX_COUNT, opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS);
+  return true;
+}
+function loadBlob(subdir, id) {
+  const p = blobPath(subdir, id);
+  if (!p) return null;
+  try {
+    if (!fs6.existsSync(p)) return null;
+    return JSON.parse(fs6.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function pruneBlobs(subdir, maxCount = DEFAULT_MAX_COUNT, maxAgeMs = DEFAULT_MAX_AGE_MS) {
+  const dir = blobDir(subdir);
+  let removed = 0;
+  try {
+    if (!fs6.existsSync(dir)) return 0;
+    const cutoff = Date.now() - maxAgeMs;
+    const kept = [];
+    for (const file of fs6.readdirSync(dir)) {
+      if (!file.endsWith(".json")) continue;
+      const full = path9.join(dir, file);
+      let mtime;
+      try {
+        mtime = fs6.statSync(full).mtimeMs;
+      } catch {
+        continue;
+      }
+      if (mtime < cutoff) {
+        try {
+          fs6.unlinkSync(full);
+          removed++;
+        } catch {
+          continue;
+        }
+      } else {
+        kept.push([full, mtime]);
+      }
+    }
+    if (kept.length > maxCount) {
+      kept.sort((a, b) => a[1] - b[1]);
+      for (const [full] of kept.slice(0, kept.length - maxCount)) {
+        try {
+          fs6.unlinkSync(full);
+          removed++;
+        } catch {
+          continue;
+        }
+      }
+    }
+  } catch {
+    return removed;
+  }
+  return removed;
+}
+
+// src/session_store.ts
+var SAFE_RE = /[^a-zA-Z0-9_-]/g;
+var MAX_FILES = 500;
+var SESSIONS_SUBDIR = "sessions";
+function sessionPath(sessionId) {
+  if (!sessionId) return null;
+  const safe = sessionId.replace(SAFE_RE, "_").slice(0, 64);
+  if (!safe) return null;
+  const dir = path10.join(tokenGoatHome(), SESSIONS_SUBDIR);
+  const candidate = path10.join(dir, `${safe}.json`);
+  try {
+    const rel = path10.relative(dir, candidate);
+    if (rel.startsWith("..")) return null;
+  } catch {
+    return null;
+  }
+  return candidate;
+}
+function asStringPairs(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out2 = [];
+  for (const item of raw) {
+    if (Array.isArray(item) && typeof item[0] === "string" && typeof item[1] === "string") {
+      out2.push([item[0], item[1]]);
+    }
+  }
+  return out2;
+}
+function asFileEntry(raw) {
+  if (raw === null || typeof raw !== "object") return null;
+  const o = raw;
+  if (typeof o["path"] !== "string" || typeof o["readCount"] !== "number" || typeof o["lastReadAt"] !== "number" || typeof o["wasEdited"] !== "boolean" || typeof o["sizeBytes"] !== "number") {
+    return null;
+  }
+  const entry = {
+    path: o["path"],
+    readCount: o["readCount"],
+    lastReadAt: o["lastReadAt"],
+    wasEdited: o["wasEdited"],
+    sizeBytes: o["sizeBytes"]
+  };
+  return o["wasTruncated"] === true ? { ...entry, wasTruncated: true } : entry;
+}
+function coerce(raw) {
+  const o = raw !== null && typeof raw === "object" ? raw : {};
+  const files = [];
+  if (Array.isArray(o["files"])) {
+    for (const f of o["files"]) {
+      const e = asFileEntry(f);
+      if (e !== null) files.push(e);
+    }
+  }
+  const hintsShown = Array.isArray(o["hintsShown"]) ? o["hintsShown"].filter((h) => typeof h === "string") : [];
+  return {
+    files,
+    hintsShown,
+    webFetches: asStringPairs(o["webFetches"]),
+    bashOutputs: asStringPairs(o["bashOutputs"]),
+    curlDownloads: asStringPairs(o["curlDownloads"])
+  };
+}
+function mergeFileEntry(a, b) {
+  const newest = a.lastReadAt >= b.lastReadAt ? a : b;
+  const merged = {
+    path: a.path,
+    readCount: Math.max(a.readCount, b.readCount),
+    lastReadAt: Math.max(a.lastReadAt, b.lastReadAt),
+    wasEdited: a.wasEdited || b.wasEdited,
+    sizeBytes: newest.sizeBytes
+  };
+  return a.wasTruncated || b.wasTruncated ? { ...merged, wasTruncated: true } : merged;
+}
+function mergePairs(disk, mem) {
+  return Array.from(new Map([...disk, ...mem]).entries());
+}
+function mergeSessionState(disk, mem) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const e of disk.files) byPath.set(e.path, e);
+  for (const e of mem.files) {
+    const prev = byPath.get(e.path);
+    byPath.set(e.path, prev ? mergeFileEntry(prev, e) : e);
+  }
+  return {
+    files: Array.from(byPath.values()),
+    hintsShown: Array.from(/* @__PURE__ */ new Set([...disk.hintsShown, ...mem.hintsShown])),
+    webFetches: mergePairs(disk.webFetches, mem.webFetches),
+    bashOutputs: mergePairs(disk.bashOutputs, mem.bashOutputs),
+    curlDownloads: mergePairs(disk.curlDownloads, mem.curlDownloads)
+  };
+}
+function capFiles(s, max) {
+  if (s.files.length <= max) return s;
+  const kept = [...s.files].sort((a, b) => b.lastReadAt - a.lastReadAt).slice(0, max);
+  return { ...s, files: kept };
+}
+function readDiskState(p) {
+  try {
+    if (!fs7.existsSync(p)) return null;
+    return coerce(JSON.parse(fs7.readFileSync(p, "utf8")));
+  } catch {
+    return null;
+  }
+}
+function loadSessionState(sessionId) {
+  const p = sessionPath(sessionId);
+  if (!p) return;
+  const disk = readDiskState(p);
+  if (disk === null) return;
+  importSessionState(disk);
+}
+function saveSessionState(sessionId) {
+  const p = sessionPath(sessionId);
+  if (!p) return;
+  try {
+    const mem = exportSessionState();
+    const disk = readDiskState(p);
+    const merged = capFiles(disk ? mergeSessionState(disk, mem) : mem, MAX_FILES);
+    const dir = path10.dirname(p);
+    if (!fs7.existsSync(dir)) fs7.mkdirSync(dir, { recursive: true });
+    atomicWriteText(p, JSON.stringify(merged));
+  } catch {
+  }
+}
+
+// src/hooks_read.ts
+init_define_import_meta_env();
+import * as fs10 from "node:fs";
+import * as path13 from "node:path";
+
 // src/hooks_common.ts
 init_define_import_meta_env();
 function getToolName(event) {
@@ -12251,7 +12552,7 @@ function contextOutput(context) {
 
 // src/config.ts
 init_define_import_meta_env();
-import * as fs6 from "node:fs";
+import * as fs8 from "node:fs";
 
 // node_modules/smol-toml/dist/index.js
 init_define_import_meta_env();
@@ -12886,7 +13187,7 @@ function peekTable(key, table, meta, type) {
   }
   return [k, t, state.c];
 }
-function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
+function parse2(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
   let res = {};
   let meta = {};
   let tbl = res;
@@ -13199,7 +13500,7 @@ function loadConfig() {
   const p = configPath();
   let currentMtime = 0;
   try {
-    currentMtime = fs6.statSync(p).mtimeMs;
+    currentMtime = fs8.statSync(p).mtimeMs;
   } catch {
   }
   const envFp = configEnvFingerprint();
@@ -13209,8 +13510,8 @@ function loadConfig() {
   let raw = {};
   if (currentMtime !== 0) {
     try {
-      const text = fs6.readFileSync(p, "utf8");
-      raw = parse(text);
+      const text = fs8.readFileSync(p, "utf8");
+      raw = parse2(text);
     } catch {
     }
   }
@@ -13419,10 +13720,10 @@ function _buildConfig(raw) {
 
 // src/snapshots.ts
 init_define_import_meta_env();
-import * as fs7 from "node:fs";
-import * as path8 from "node:path";
+import * as fs9 from "node:fs";
+import * as path11 from "node:path";
 import * as crypto from "node:crypto";
-import * as os2 from "node:os";
+import * as os4 from "node:os";
 var MAX_SNAPSHOTS_PER_SESSION = 150;
 var MAX_SNAPSHOT_BYTES = 256 * 1024;
 var SNAPSHOT_TRUNCATE_BYTES = 50 * 1024;
@@ -13434,10 +13735,10 @@ var SESSION_DIR_RE = /[^a-zA-Z0-9_-]/g;
 function sessionDir(sessionId) {
   if (!sessionId) return null;
   const safe = sessionId.replace(SESSION_DIR_RE, "_").slice(0, 64) || "anon";
-  const base = path8.join(os2.homedir(), ".token-goat", "session_snapshots");
-  const candidate = path8.join(base, safe);
+  const base = path11.join(os4.homedir(), ".token-goat", "session_snapshots");
+  const candidate = path11.join(base, safe);
   try {
-    const rel = path8.relative(base, candidate);
+    const rel = path11.relative(base, candidate);
     if (rel.startsWith("..")) return null;
   } catch {
     return null;
@@ -13450,7 +13751,7 @@ function pathKey(filePath) {
 function snapshot_path(sessionId, filePath) {
   const d = sessionDir(sessionId);
   if (!d) return null;
-  return path8.join(d, `${pathKey(filePath)}.bin`);
+  return path11.join(d, `${pathKey(filePath)}.bin`);
 }
 function kindSidecarPath(snapshotPath) {
   return snapshotPath + ".kind";
@@ -13458,11 +13759,11 @@ function kindSidecarPath(snapshotPath) {
 function writeSnapshotKind(sidecarPath, kind) {
   try {
     const safeKind = VALID_KINDS.has(kind) ? kind : KIND_READ;
-    const dir = path8.dirname(sidecarPath);
-    if (!fs7.existsSync(dir)) {
-      fs7.mkdirSync(dir, { recursive: true });
+    const dir = path11.dirname(sidecarPath);
+    if (!fs9.existsSync(dir)) {
+      fs9.mkdirSync(dir, { recursive: true });
     }
-    fs7.writeFileSync(sidecarPath, safeKind, "utf8");
+    fs9.writeFileSync(sidecarPath, safeKind, "utf8");
     return true;
   } catch {
     return false;
@@ -13471,12 +13772,12 @@ function writeSnapshotKind(sidecarPath, kind) {
 function evictOldest(d, maxCount) {
   try {
     const entries = [];
-    const files = fs7.readdirSync(d);
+    const files = fs9.readdirSync(d);
     for (const file of files) {
-      const fullPath = path8.join(d, file);
+      const fullPath = path11.join(d, file);
       if (!file.endsWith(".bin")) continue;
       try {
-        const stat3 = fs7.statSync(fullPath);
+        const stat3 = fs9.statSync(fullPath);
         entries.push([fullPath, stat3.mtimeMs]);
       } catch {
         continue;
@@ -13488,10 +13789,10 @@ function evictOldest(d, maxCount) {
     const over = entries.length - maxCount;
     for (const [p] of entries.slice(0, over)) {
       try {
-        fs7.unlinkSync(p);
+        fs9.unlinkSync(p);
         removed++;
         try {
-          fs7.unlinkSync(kindSidecarPath(p));
+          fs9.unlinkSync(kindSidecarPath(p));
         } catch {
         }
       } catch {
@@ -13520,9 +13821,9 @@ function store(sessionId, filePath, content, opts = {}) {
   if (!p) return null;
   const sha = crypto.createHash("sha256").update(stored).digest("hex");
   try {
-    if (fs7.existsSync(p)) {
+    if (fs9.existsSync(p)) {
       try {
-        const existing = fs7.readFileSync(p);
+        const existing = fs9.readFileSync(p);
         if (Buffer.from(existing).equals(stored)) {
           return {
             path: p,
@@ -13533,14 +13834,14 @@ function store(sessionId, filePath, content, opts = {}) {
       } catch {
       }
     }
-    const dir = path8.dirname(p);
-    if (!fs7.existsSync(dir)) {
-      fs7.mkdirSync(dir, { recursive: true });
+    const dir = path11.dirname(p);
+    if (!fs9.existsSync(dir)) {
+      fs9.mkdirSync(dir, { recursive: true });
     }
     evictOldest(dir, MAX_SNAPSHOTS_PER_SESSION - 1);
     const tempPath = p + ".tmp";
-    fs7.writeFileSync(tempPath, stored);
-    fs7.renameSync(tempPath, p);
+    fs9.writeFileSync(tempPath, stored);
+    fs9.renameSync(tempPath, p);
     const sidecar = kindSidecarPath(p);
     writeSnapshotKind(sidecar, kind);
     return {
@@ -13554,9 +13855,9 @@ function store(sessionId, filePath, content, opts = {}) {
 }
 function load(sessionId, filePath, opts = {}) {
   const p = snapshot_path(sessionId, filePath);
-  if (!p || !fs7.existsSync(p)) return null;
+  if (!p || !fs9.existsSync(p)) return null;
   try {
-    const stat3 = fs7.statSync(p);
+    const stat3 = fs9.statSync(p);
     if (stat3.size > MAX_SNAPSHOT_BYTES) {
       return null;
     }
@@ -13564,7 +13865,7 @@ function load(sessionId, filePath, opts = {}) {
     return null;
   }
   try {
-    const data = fs7.readFileSync(p);
+    const data = fs9.readFileSync(p);
     if (opts.expected_sha) {
       const actualSha = crypto.createHash("sha256").update(data).digest("hex");
       if (actualSha.toLowerCase() !== opts.expected_sha.toLowerCase()) {
@@ -13609,11 +13910,11 @@ function buildPackageManifestHint(options) {
     return null;
   }
 }
-function _sanitizeHintPath(path19) {
-  if (typeof path19 !== "string") {
+function _sanitizeHintPath(path22) {
+  if (typeof path22 !== "string") {
     return "???";
   }
-  return path19.replace(/[\x00]/g, "").slice(0, 200);
+  return path22.replace(/[\x00]/g, "").slice(0, 200);
 }
 
 // src/hints/lang_patterns.ts
@@ -13751,15 +14052,15 @@ 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(basename8) {
-  return LOCK_FILE_NAMES.has(basename8.toLowerCase());
+function isLockFile(basename9) {
+  return LOCK_FILE_NAMES.has(basename9.toLowerCase());
 }
-function isManifestFile(basename8) {
-  const lower = basename8.toLowerCase();
+function isManifestFile(basename9) {
+  const lower = basename9.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(basename8))) return true;
+  if (MANIFEST_BASENAME_PATTERNS.some((re) => re.test(basename9))) return true;
   return false;
 }
 function pathSegments(filePath) {
@@ -13917,8 +14218,8 @@ var WELL_KNOWN_SECTIONS = {
   "CLAUDE.md": ["Commands", "Architecture"],
   "CLAUDE.arch.md": ["Component Map", "Architecture"]
 };
-function getWellKnownSections(basename8) {
-  return WELL_KNOWN_SECTIONS[basename8] ?? [];
+function getWellKnownSections(basename9) {
+  return WELL_KNOWN_SECTIONS[basename9] ?? [];
 }
 function extractChangelogVersionHint(content, filePath) {
   const lines = content.split("\n");
@@ -14066,7 +14367,7 @@ function dispatchFileTypeHandler(filePath, content, contentLengthHint) {
 
 // src/stats.ts
 init_define_import_meta_env();
-import * as path9 from "node:path";
+import * as path12 from "node:path";
 
 // src/render/stats_renderer.ts
 init_define_import_meta_env();
@@ -14846,7 +15147,7 @@ CREATE INDEX IF NOT EXISTS idx_stats_kind ON stats(kind);
 var _globalSchemaApplied = /* @__PURE__ */ new Set();
 registerReset(() => _globalSchemaApplied.clear());
 function getGlobalDb() {
-  const dbPath = path9.join(dataDir(), "global.db");
+  const dbPath = path12.join(dataDir(), "global.db");
   const db = getDb(dbPath);
   if (!_globalSchemaApplied.has(dbPath)) {
     db.exec(GLOBAL_SCHEMA_SQL);
@@ -15038,8 +15339,8 @@ function renderStats2(opts) {
 }
 
 // src/hooks_read.ts
-function isTsConfigFile(basename8) {
-  const lower = basename8.toLowerCase();
+function isTsConfigFile(basename9) {
+  const lower = basename9.toLowerCase();
   return /^tsconfig(\..+)?\.json$/i.test(lower) || lower === "jsconfig.json";
 }
 var LARGE_FILE_BYTES = 100 * 1024;
@@ -15058,17 +15359,20 @@ function isSessionArtifactFile(filePath) {
   if (/[/\\]tool-results[/\\][a-z0-9]+\.txt$/i.test(filePath)) return true;
   return false;
 }
+function sessionArtifactRecall(filePath) {
+  return 'Use `token-goat bash-output --file "' + filePath + '" --tail 50` (or `--grep PATTERN`) to read a slice instead of the full file.';
+}
 function statSize(absPath) {
   try {
-    return fs8.statSync(absPath).size;
+    return fs10.statSync(absPath).size;
   } catch {
     return null;
   }
 }
 var DIFFABLE_SOURCE_RE = /\.(ts|tsx|js|jsx|mjs|cjs|css|scss|sass|less|json|jsonc|py|go|rs|java|rb|php|swift|kt|c|h|cpp|cc|cxx|hpp|cs|sql|yaml|yml|toml)$/i;
-function surgicalHint(filePath, basename8) {
-  const isDocFile = /\.(md|mdx|rst|txt)$/i.test(basename8);
-  const isSectionFile = /\.(json|jsonc|css|scss|sass|less|yaml|yml|toml)$/i.test(basename8);
+function surgicalHint(filePath, basename9) {
+  const isDocFile = /\.(md|mdx|rst|txt)$/i.test(basename9);
+  const isSectionFile = /\.(json|jsonc|css|scss|sass|less|yaml|yml|toml)$/i.test(basename9);
   if (isDocFile) {
     return 'Use `token-goat section "' + filePath + '::HeadingName"` to extract a part.';
   } else if (isSectionFile) {
@@ -15119,8 +15423,8 @@ function preReadHandler(event) {
       "node_modules is typically noise; use npm ls, npm outdated, or npm audit instead for dependency info. To force access, use: token-goat read node_modules/package/file.js::symbol-name or token-goat section node_modules/package/file.js::heading"
     );
   }
-  const basename8 = path10.basename(normalized);
-  if (isLockFile(basename8)) {
+  const basename9 = path13.basename(normalized);
+  if (isLockFile(basename9)) {
     return denyOutput(
       'Lock files are rarely useful to read in full. Use `token-goat section "' + normalized + '::<section>"` to extract a specific dependency, or read the relevant manifest instead.'
     );
@@ -15140,25 +15444,25 @@ function preReadHandler(event) {
     recordFileRead(normalized);
     return contextOutput(manifestHint.text);
   }
-  if (isTsConfigFile(basename8) && wasFileReadThisSession(normalized)) {
+  if (isTsConfigFile(basename9) && wasFileReadThisSession(normalized)) {
     recordFileRead(normalized);
     return contextOutput(
-      "Already read " + basename8 + '. Use `token-goat section "' + normalized + '::compilerOptions"` to extract compiler options, or `token-goat config-get ' + normalized + " compilerOptions.target` for a single value."
+      "Already read " + basename9 + '. Use `token-goat section "' + normalized + '::compilerOptions"` to extract compiler options, or `token-goat config-get ' + normalized + " compilerOptions.target` for a single value."
     );
   }
-  if (isManifestFile(basename8) && wasFileReadThisSession(normalized)) {
+  if (isManifestFile(basename9) && wasFileReadThisSession(normalized)) {
     recordFileRead(normalized);
     return contextOutput(
-      "You've already read " + basename8 + '. Use `token-goat section "' + normalized + '::<field>"` or `token-goat config-get ' + normalized + " <key>` to extract just the value you need."
+      "You've already read " + basename9 + '. Use `token-goat section "' + normalized + '::<field>"` or `token-goat config-get ' + normalized + " <key>` to extract just the value you need."
     );
   }
-  const isMarkdown = /\.(md|mdx|markdown|rst)$/i.test(basename8);
+  const isMarkdown = /\.(md|mdx|markdown|rst)$/i.test(basename9);
   if (isMarkdown) {
     let fileContent = null;
     try {
       const sz = statSize(normalized);
       if (sz !== null && sz >= MARKDOWN_SIZE_THRESHOLD) {
-        fileContent = fs8.readFileSync(normalized, "utf8");
+        fileContent = fs10.readFileSync(normalized, "utf8");
       }
     } catch {
     }
@@ -15167,9 +15471,9 @@ function preReadHandler(event) {
       if (headings.length >= 3) {
         recordFileRead(normalized);
         const hintText = formatHeadingTree(headings, normalized);
-        const wellKnown = getWellKnownSections(basename8);
+        const wellKnown = getWellKnownSections(basename9);
         const wellKnownText = wellKnown.length > 0 ? "\nQuick access: " + wellKnown.map((s) => 'token-goat section "' + normalized + "::" + s + '"').join(" | ") : "";
-        const changelogExtra = basename8.toLowerCase() === "changelog.md" ? extractChangelogVersionHint(fileContent, normalized) : "";
+        const changelogExtra = basename9.toLowerCase() === "changelog.md" ? extractChangelogVersionHint(fileContent, normalized) : "";
         return denyOutput(hintText + wellKnownText + changelogExtra);
       }
     }
@@ -15178,19 +15482,19 @@ function preReadHandler(event) {
   if (isMemoryMd && wasFileReadThisSession(normalized)) {
     recordFileRead(normalized);
     recordStat("session_hint", 0, 0);
-    const isMainMemory = basename8.toLowerCase() === "memory.md";
+    const isMainMemory = basename9.toLowerCase() === "memory.md";
     return denyOutput(
       isMainMemory ? "MEMORY.md was read this session. Its content is in the compact manifest as 'session memory'." : normalized + ' was already read this session. Memory files rarely change mid-session. Use `token-goat section "' + normalized + '::SectionHeading"` to extract one section.'
     );
   }
-  if (/^\.improve-state-.*\.json$/.test(basename8) && wasFileReadThisSession(normalized)) {
+  if (/^\.improve-state-.*\.json$/.test(basename9) && wasFileReadThisSession(normalized)) {
     recordFileRead(normalized);
     recordStat("session_hint", 0, 0);
     return denyOutput(
       "Orchestrator state already read this session. Use `token-goat bash-output <id>` or recall it from the compact manifest."
     );
   }
-  if (/^\.env(\.\w+)?$/.test(basename8) && wasFileReadThisSession(normalized)) {
+  if (/^\.env(\.\w+)?$/.test(basename9) && wasFileReadThisSession(normalized)) {
     recordFileRead(normalized);
     recordStat("session_hint", 0, 0);
     return denyOutput(
@@ -15203,7 +15507,7 @@ function preReadHandler(event) {
         recordFileRead(normalized);
         recordStat("session_hint", 0, 0);
         return denyOutput(
-          "File was truncated on last read. Use `token-goat bash-output --tail N` or `--grep PATTERN` to read a slice."
+          "File was truncated on last read. " + sessionArtifactRecall(normalized)
         );
       }
       const artifactSessionId = getSessionId();
@@ -15212,7 +15516,7 @@ function preReadHandler(event) {
         try {
           const sz = statSize(normalized);
           if (sz !== null && sz <= 256 * 1024) {
-            const currentContent = fs8.readFileSync(normalized, "utf8");
+            const currentContent = fs10.readFileSync(normalized, "utf8");
             const TRUNC_MARKER = "\n<snapshot truncated at ";
             const oldRaw = oldArtifactSnap.toString("utf8");
             const truncIdx = oldRaw.indexOf(TRUNC_MARKER);
@@ -15221,16 +15525,16 @@ function preReadHandler(event) {
               recordFileRead(normalized);
               recordStat("session_hint", 0, 0);
               return denyOutput(
-                basename8 + " is unchanged since last read. Use `token-goat bash-output --tail N` or `--grep PATTERN` to read a slice."
+                basename9 + " is unchanged since last read. " + sessionArtifactRecall(normalized)
               );
             }
-            const diff = buildLineDiff(oldContent, currentContent, basename8);
+            const diff = buildLineDiff(oldContent, currentContent, basename9);
             if (diff !== "") {
               recordFileRead(normalized);
               const savedBytes = Math.max(0, currentContent.length - diff.length);
               recordStat("session_hint", savedBytes, Math.round(savedBytes / 4));
               return denyOutput(
-                "Content changed since last read of " + basename8 + ". Here is what changed:\n\n```diff\n" + diff + "\n```\n\nUse `token-goat bash-output --tail N` or `--grep PATTERN` to read a slice."
+                "Content changed since last read of " + basename9 + ". Here is what changed:\n\n```diff\n" + diff + "\n```\n\n" + sessionArtifactRecall(normalized)
               );
             }
           }
@@ -15240,18 +15544,16 @@ function preReadHandler(event) {
       recordFileRead(normalized);
       recordStat("session_hint", 0, 0);
       return denyOutput(
-        normalized + " was already read this session. Use `token-goat bash-output --tail N` or `--grep PATTERN` to read a slice."
+        normalized + " was already read this session. " + sessionArtifactRecall(normalized)
       );
     }
     if (/[/\\]tasks[/\\][a-z0-9]+\.output$/i.test(normalized)) {
       recordFileRead(normalized);
-      return contextOutput(
-        "Session transcript: use `token-goat bash-output --tail N` or `--grep PATTERN` to read a slice instead of the full file."
-      );
+      return contextOutput("Session transcript: " + sessionArtifactRecall(normalized));
     }
   }
-  const isDocDiffable = /\.(md|mdx|rst|txt)$/i.test(basename8);
-  const isSourceDiffable = loadConfig().hints.serve_diff_on_reread && DIFFABLE_SOURCE_RE.test(basename8);
+  const isDocDiffable = /\.(md|mdx|rst|txt)$/i.test(basename9);
+  const isSourceDiffable = loadConfig().hints.serve_diff_on_reread && DIFFABLE_SOURCE_RE.test(basename9);
   if ((isDocDiffable || isSourceDiffable) && wasFileReadThisSession(normalized)) {
     if (wasFileTruncatedThisSession(normalized)) {
       recordFileRead(normalized);
@@ -15266,7 +15568,7 @@ function preReadHandler(event) {
       try {
         const sz = statSize(normalized);
         if (sz !== null && sz <= 256 * 1024) {
-          const currentContent = fs8.readFileSync(normalized, "utf8");
+          const currentContent = fs10.readFileSync(normalized, "utf8");
           const TRUNC_MARKER = "\n<snapshot truncated at ";
           const oldRaw = oldSnap.toString("utf8");
           const truncIdx = oldRaw.indexOf(TRUNC_MARKER);
@@ -15275,10 +15577,10 @@ function preReadHandler(event) {
             recordFileRead(normalized);
             recordStat("session_hint", 0, 0);
             return denyOutput(
-              basename8 + " is unchanged since last read. " + surgicalHint(normalized, basename8)
+              basename9 + " is unchanged since last read. " + surgicalHint(normalized, basename9)
             );
           }
-          const diff = buildLineDiff(oldContent, currentContent, basename8);
+          const diff = buildLineDiff(oldContent, currentContent, basename9);
           if (diff !== "") {
             if (isSourceDiffable && !isDocDiffable && diff.length > currentContent.length * 0.6) {
             } else {
@@ -15286,7 +15588,7 @@ function preReadHandler(event) {
               const savedBytes = Math.max(0, currentContent.length - diff.length);
               recordStat("session_hint", savedBytes, Math.round(savedBytes / 4));
               return denyOutput(
-                "Content changed since last read of " + basename8 + ". Here is what changed:\n\n```diff\n" + diff + "\n```\n\n" + surgicalHint(normalized, basename8)
+                "Content changed since last read of " + basename9 + ". Here is what changed:\n\n```diff\n" + diff + "\n```\n\n" + surgicalHint(normalized, basename9)
               );
             }
           }
@@ -15298,7 +15600,7 @@ function preReadHandler(event) {
   if (wasFileReadThisSession(normalized)) {
     const entry = getSessionFiles().get(normalized);
     const reads = entry?.readCount ?? 1;
-    const plural = reads === 1 ? "read" : "reads";
+    const plural2 = reads === 1 ? "read" : "reads";
     recordFileRead(normalized);
     const rereadBytes = statSize(normalized) ?? 0;
     recordStat("session_hint", rereadBytes, Math.round(rereadBytes / 4));
@@ -15307,12 +15609,12 @@ function preReadHandler(event) {
         'File was truncated on last read (>33K tokens). Use `token-goat skeleton "' + normalized + '"` for structure or `token-goat read "' + normalized + '::SymbolName"` for one function.'
       );
     }
-    if (/\.(md|mdx)$/i.test(basename8)) {
+    if (/\.(md|mdx)$/i.test(basename9)) {
       return denyOutput(
         'Markdown file already read this session. Use `token-goat section "' + normalized + '::HeadingName"` to read one section.'
       );
     }
-    const isSourceExt = /\.(ts|tsx|js|jsx|py|go|rs|java|rb|php|swift|kt|cpp|c|h)$/i.test(basename8);
+    const isSourceExt = /\.(ts|tsx|js|jsx|py|go|rs|java|rb|php|swift|kt|cpp|c|h)$/i.test(basename9);
     if (isSourceExt && reads >= 2) {
       recordStat("read_count_deny", rereadBytes, Math.round(rereadBytes / 4));
       return denyOutput(
@@ -15322,11 +15624,11 @@ function preReadHandler(event) {
     const hint = _isDocFile(normalized) ? 'Use `token-goat section "' + normalized + '::SectionName"` to read one section.' : "Use token-goat read/section/symbol to re-read surgically.";
     if (rereadBytes >= REREAD_DENY_BYTES || reads >= 2) {
       return denyOutput(
-        normalized + " was already read this session (" + reads + " " + plural + "). " + hint
+        normalized + " was already read this session (" + reads + " " + plural2 + "). " + hint
       );
     }
     return contextOutput(
-      "Note: " + normalized + " was already read this session (" + reads + " " + plural + "). " + hint
+      "Note: " + normalized + " was already read this session (" + reads + " " + plural2 + "). " + hint
     );
   }
   const size = statSize(normalized);
@@ -15344,7 +15646,7 @@ function preReadHandler(event) {
       "Note: " + normalized + " is large (" + kb + "KB). " + hint
     );
   }
-  const fileTypeExt = path10.extname(normalized).slice(1).toLowerCase();
+  const fileTypeExt = path13.extname(normalized).slice(1).toLowerCase();
   const binaryExts = /* @__PURE__ */ new Set(["pdf", "docx", "xlsx", "pptx", "odt", "ods", "ott", "odp"]);
   const textTypeExts = /* @__PURE__ */ new Set(["html", "htm", "xhtml", "txt", "log", "out", "err", "trace", "csv", "tsv"]);
   const fileStatSize = size ?? statSize(normalized) ?? 0;
@@ -15353,7 +15655,7 @@ function preReadHandler(event) {
     let ftContent = "";
     if (!binaryExts.has(fileTypeExt)) {
       try {
-        ftContent = fs8.readFileSync(normalized, "utf8");
+        ftContent = fs10.readFileSync(normalized, "utf8");
       } catch {
       }
     }
@@ -15387,13 +15689,13 @@ function postReadHandler(event) {
   if (respText.includes("[Truncated:") || respText.includes("Truncated: PARTIAL view")) {
     markFileTruncated(normalized);
   }
-  const postBasename = path10.basename(normalized);
+  const postBasename = path13.basename(normalized);
   const diffSourcesEnabled = loadConfig().hints.serve_diff_on_reread;
   if (/\.(md|mdx|rst|txt)$/i.test(postBasename) || isSessionArtifactFile(normalized) || diffSourcesEnabled && DIFFABLE_SOURCE_RE.test(postBasename)) {
     try {
       const sz = statSize(normalized);
       if (sz !== null && sz <= 256 * 1024) {
-        const content = fs8.readFileSync(normalized);
+        const content = fs10.readFileSync(normalized);
         store(getSessionId(), normalized, content);
       }
     } catch {
@@ -15405,31 +15707,31 @@ registerHook("post_tool_use", postReadHandler, { toolName: "Read" });
 
 // src/hooks_edit.ts
 init_define_import_meta_env();
-import * as path12 from "node:path";
+import * as path15 from "node:path";
 
 // src/hooks_index.ts
 init_define_import_meta_env();
-import * as fs9 from "node:fs";
-import * as path11 from "node:path";
+import * as fs11 from "node:fs";
+import * as path14 from "node:path";
 function dirtyQueuePath() {
-  return path11.join(dataDir(), "queue", "dirty.txt");
+  return path14.join(dataDir(), "queue", "dirty.txt");
 }
 function appendDirtyPath(normalizedPath) {
   const queuePath = dirtyQueuePath();
-  const dir = path11.dirname(queuePath);
+  const dir = path14.dirname(queuePath);
   try {
-    fs9.mkdirSync(dir, { recursive: true });
+    fs11.mkdirSync(dir, { recursive: true });
   } catch (e) {
-    if (e.code !== "EEXIST" || !fs9.existsSync(dir)) throw e;
+    if (e.code !== "EEXIST" || !fs11.existsSync(dir)) throw e;
   }
-  fs9.appendFileSync(queuePath, `${normalizedPath}
+  fs11.appendFileSync(queuePath, `${normalizedPath}
 `);
 }
 function getDirtyPaths() {
   const queuePath = dirtyQueuePath();
   let raw;
   try {
-    raw = fs9.readFileSync(queuePath, "utf8");
+    raw = fs11.readFileSync(queuePath, "utf8");
   } catch {
     return [];
   }
@@ -15445,16 +15747,16 @@ function getDirtyPaths() {
 }
 function clearDirtyQueue() {
   try {
-    fs9.rmSync(dirtyQueuePath(), { force: true });
+    fs11.rmSync(dirtyQueuePath(), { force: true });
   } catch {
   }
 }
 function preCompactIndexHandler(_event) {
   const paths = getDirtyPaths();
   if (paths.length > 0) {
-    const sidecar = path11.join(dataDir(), "queue", "pending.txt");
+    const sidecar = path14.join(dataDir(), "queue", "pending.txt");
     try {
-      fs9.mkdirSync(path11.dirname(sidecar), { recursive: true });
+      fs11.mkdirSync(path14.dirname(sidecar), { recursive: true });
       atomicWriteBytes(sidecar, Buffer.from(`${paths.join("\n")}
 `, "utf8"));
       clearDirtyQueue();
@@ -15472,7 +15774,7 @@ function postEditHandler(event) {
   const normalized = normalizePath(filePath);
   recordFileEdit(normalized);
   appendDirtyPath(normalized);
-  const editedBasename = path12.basename(normalized);
+  const editedBasename = path15.basename(normalized);
   if (/\.(md|mdx|markdown|rst)$/i.test(editedBasename)) {
     const escapedPath = normalized.replace(/`/g, "\\`");
     return contextOutput(
@@ -15489,9 +15791,9 @@ init_define_import_meta_env();
 var MAX_ROWS = 40;
 function renderReadRow(entry) {
   const kb = Math.max(1, Math.round(entry.sizeBytes / 1024));
-  const plural = entry.readCount === 1 ? "read" : "reads";
+  const plural2 = entry.readCount === 1 ? "read" : "reads";
   const edited = entry.wasEdited ? ", edited" : "";
-  return `- ${entry.path} (${kb}kb, ${entry.readCount} ${plural}${edited})`;
+  return `- ${entry.path} (${kb}kb, ${entry.readCount} ${plural2}${edited})`;
 }
 function buildManifest() {
   const files = [...getSessionFiles().values()];
@@ -15620,6 +15922,50 @@ registerHook("subagent_stop", subagentStopHandler);
 
 // src/hooks_fetch.ts
 init_define_import_meta_env();
+
+// src/web_cache.ts
+init_define_import_meta_env();
+var WEB_OUTPUT_SUBDIR = "web_outputs";
+var _byId = /* @__PURE__ */ new Map();
+var _urlIndex = /* @__PURE__ */ new Map();
+function cacheIdForUrl(url) {
+  return shortFingerprint(url);
+}
+function storeWebOutput(url, content) {
+  const cacheId = cacheIdForUrl(url);
+  _byId.set(cacheId, content);
+  _urlIndex.set(url, cacheId);
+  storeBlob(WEB_OUTPUT_SUBDIR, cacheId, { url, content });
+  return cacheId;
+}
+function coerceWebBlob(raw) {
+  if (raw === null || typeof raw !== "object") return null;
+  const o = raw;
+  if (typeof o["content"] !== "string") return null;
+  return { url: typeof o["url"] === "string" ? o["url"] : null, content: o["content"] };
+}
+function getWebOutput(cacheId) {
+  const hit = _byId.get(cacheId);
+  if (hit !== void 0) return hit;
+  const blob = coerceWebBlob(loadBlob(WEB_OUTPUT_SUBDIR, cacheId));
+  if (blob === null) return null;
+  _byId.set(cacheId, blob.content);
+  if (blob.url !== null) _urlIndex.set(blob.url, cacheId);
+  return blob.content;
+}
+function getWebOutputByUrl(url) {
+  const cacheId = _urlIndex.get(url);
+  if (cacheId === void 0) return null;
+  const content = _byId.get(cacheId);
+  if (content === void 0) return null;
+  return { cacheId, content };
+}
+registerReset(() => {
+  _byId = /* @__PURE__ */ new Map();
+  _urlIndex = /* @__PURE__ */ new Map();
+});
+
+// src/hooks_fetch.ts
 function extractToolResponse(raw) {
   const toolResponse = raw["tool_response"];
   if (typeof toolResponse === "string") {
@@ -15670,6 +16016,8 @@ function postFetchHandler(event) {
     if (!body || body.length < 1024) {
       return passOutput();
     }
+    const cacheId = storeWebOutput(url, body);
+    recordWebFetch(url, cacheId);
     return passOutput();
   } catch {
     return passOutput();
@@ -15754,9 +16102,10 @@ init_define_import_meta_env();
 
 // src/bash_output_cache.ts
 init_define_import_meta_env();
-import * as fs10 from "fs/promises";
-import { resolve as resolve4 } from "path";
-var _byId = /* @__PURE__ */ new Map();
+import * as fs12 from "fs/promises";
+import { resolve as resolve5 } from "path";
+var BASH_OUTPUT_SUBDIR = "bash_outputs";
+var _byId2 = /* @__PURE__ */ new Map();
 var _globsByKey = /* @__PURE__ */ new Map();
 var _grepsByKey = /* @__PURE__ */ new Map();
 var COMMAND_PATTERNS = {
@@ -15797,7 +16146,7 @@ async function gitStateFingerprint(cwd) {
     const headSha = headResult.stdout.trim();
     let indexMtime = "";
     try {
-      const stat3 = await fs10.stat(resolve4(cwd, ".git", "index"));
+      const stat3 = await fs12.stat(resolve5(cwd, ".git", "index"));
       indexMtime = stat3.mtimeMs.toString();
     } catch {
     }
@@ -15807,9 +16156,9 @@ async function gitStateFingerprint(cwd) {
     return null;
   }
 }
-async function dirStateFingerprint(path19) {
+async function dirStateFingerprint(path22) {
   try {
-    const stat3 = await fs10.stat(path19);
+    const stat3 = await fs12.stat(path22);
     if (!stat3.isDirectory()) return null;
     return shortFingerprint(stat3.mtimeMs.toString());
   } catch {
@@ -15825,7 +16174,7 @@ async function depLockfileFingerprint(cmd, cwd) {
   if (!candidates) return null;
   for (const lockfile of candidates) {
     try {
-      const content = await fs10.readFile(resolve4(cwd, lockfile));
+      const content = await fs12.readFile(resolve5(cwd, lockfile));
       return shortFingerprint(content);
     } catch {
       continue;
@@ -15895,78 +16244,1195 @@ async function storeBashOutput(command, output, exitCode, cwd = null) {
     storedAt: Date.now(),
     sizeBytes: Buffer.byteLength(output, "utf-8")
   };
-  _byId.set(id, entry);
+  _byId2.set(id, entry);
+  storeBlob(BASH_OUTPUT_SUBDIR, id, entry);
   return id;
 }
+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;
+  }
+  return {
+    id: o["id"],
+    command: o["command"],
+    output: o["output"],
+    exitCode: o["exitCode"],
+    storedAt: o["storedAt"],
+    sizeBytes: o["sizeBytes"]
+  };
+}
 function getBashOutput(id) {
-  return _byId.get(id) ?? null;
+  const hit = _byId2.get(id);
+  if (hit !== void 0) return hit;
+  const entry = coerceBashEntry(loadBlob(BASH_OUTPUT_SUBDIR, id));
+  if (entry === null) return null;
+  _byId2.set(id, entry);
+  return entry;
 }
 registerReset(() => {
-  _byId = /* @__PURE__ */ new Map();
+  _byId2 = /* @__PURE__ */ new Map();
   _globsByKey = /* @__PURE__ */ new Map();
   _grepsByKey = /* @__PURE__ */ new Map();
 });
 
-// src/hooks_bash.ts
-function stripCdPrefix(cmd) {
-  const stripped = cmd.replace(/^(?:cd\s+(?:"[^"]*"|'[^']*'|\S+)\s*&&\s*)+/, "");
-  return stripped.trim() || cmd;
+// src/tool_filters/index.ts
+init_define_import_meta_env();
+
+// src/tool_filters/helpers.ts
+init_define_import_meta_env();
+
+// src/bash_compress.ts
+init_define_import_meta_env();
+
+// src/filters.ts
+init_define_import_meta_env();
+
+// src/bash_compress.ts
+var ANSI_ESCAPE_RE = (
+  // eslint-disable-next-line no-control-regex -- intentionally matches ESC (\x1B) and BEL (\x07) control bytes
+  /\x1B\[[0-?]*[ -/]*[@-~]|\x1B\].*?(?:\x07|\x1B\\)|\x1B[PX^_].*?\x1B\\|\x1B[@-Z\\-_]/gs
+);
+function stripAnsiCodes(text) {
+  if (!text.includes("\x1B")) return text;
+  return text.replace(ANSI_ESCAPE_RE, "");
 }
-function stripOutputPipeline(cmd) {
-  let inSingle = false;
-  let inDouble = false;
-  let cut = cmd.length;
-  for (let i = 0; i < cmd.length; i++) {
-    const ch = cmd[i];
-    if (ch === "'" && !inDouble) {
-      inSingle = !inSingle;
-    } else if (ch === '"' && !inSingle) {
-      inDouble = !inDouble;
-    } else if (ch === "|" && !inSingle && !inDouble) {
-      if (cmd[i + 1] === "|") {
-        i++;
-        continue;
+
+// src/tool_filters/helpers.ts
+var DEFAULT_MAX_LINES = 1e3;
+var DEFAULT_MAX_BYTES = 64 * 1024;
+var MAX_INSPECT_BYTES = 2 * 1024 * 1024;
+var DEFAULT_MAX_INPUT_BYTES = 500 * 1024;
+var FALLBACK_MAX_LINE_CHARS = 400;
+function getMaxInputBytes() {
+  const raw = process.env["TOKEN_GOAT_FILTER_MAX_BYTES"];
+  const v = raw ? Number.parseInt(raw, 10) : 0;
+  return Number.isFinite(v) && v > 0 ? v : DEFAULT_MAX_INPUT_BYTES;
+}
+function compressionMarker(filter, pct) {
+  return `
+[token-goat: ${filter} filter -${Math.round(pct)}%; disable via TOKEN_GOAT_BASH_COMPRESS]`;
+}
+var ERROR_SIGNAL_RE = /error:|Error:|ERROR|FAILED|failed|fatal:|Traceback|exception:|Exception:|AssertionError|assert |panic:/i;
+var REDIRECT_TOKEN_RE = /^(\d*)(>>?|<<?).*$|^&>$|^>&.*$/;
+var BYTES_ELIDED_MARKER_RE = /\n\.\.\. \[\d+ bytes elided by token-goat\]$/;
+var CONTROL_CHAR_RE = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g;
+function utf8Len(s) {
+  return Buffer.byteLength(s, "utf8");
+}
+function safeDecode(text) {
+  return text.indexOf("\0") === -1 ? text : text.split("\0").join("");
+}
+function sanitizeControlChars(text) {
+  return text.replace(CONTROL_CHAR_RE, "");
+}
+function stripProgress(text) {
+  if (!text.includes("\r")) return text;
+  return text.split("\n").map((line) => line.includes("\r") ? line.slice(line.lastIndexOf("\r") + 1) : line).join("\n");
+}
+function normalise(text, opts = {}) {
+  if (!text) return "";
+  let t = text.replace(/\r\n/g, "\n");
+  if (!opts.skipProgress) t = stripProgress(t);
+  t = stripAnsiCodes(t);
+  return sanitizeControlChars(t);
+}
+var UUID_RE = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i;
+var LONG_HEX_RE = /\b[0-9a-f]{32,}\b/i;
+var JWT_RE = /\b[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/;
+function hasHighEntropyToken(line) {
+  if (UUID_RE.test(line) || LONG_HEX_RE.test(line) || JWT_RE.test(line)) return true;
+  for (const tok of line.split(/[\s"'`,;:()[\]{}<>]+/)) {
+    if (tok.length < 24) continue;
+    if (/[a-z]/.test(tok) && /[A-Z]/.test(tok) && /[0-9]/.test(tok) && /^[A-Za-z0-9+/=_-]+$/.test(tok)) {
+      return true;
+    }
+  }
+  return false;
+}
+function dedupeConsecutive(lines, opts = {}) {
+  const minRun = opts.minRun ?? 2;
+  const fmt = opts.fmt ?? ((line, count2) => `${line}  (\xD7${count2})`);
+  const entropyBypass = opts.entropyBypass ?? false;
+  const out2 = [];
+  let prev = null;
+  let count = 0;
+  const flush = () => {
+    if (prev === null) return;
+    if (count >= minRun) out2.push(fmt(prev, count));
+    else for (let i = 0; i < count; i++) out2.push(prev);
+  };
+  for (const line of lines) {
+    if (entropyBypass && hasHighEntropyToken(line)) {
+      flush();
+      prev = null;
+      count = 0;
+      out2.push(line);
+      continue;
+    }
+    if (line === prev) {
+      count += 1;
+      continue;
+    }
+    flush();
+    prev = line;
+    count = 1;
+  }
+  flush();
+  return out2;
+}
+function truncateMiddle(lines, maxLines, opts = {}) {
+  if (lines.length <= maxLines) return lines;
+  const headRatio = opts.headRatio ?? 0.4;
+  const markerFmt = opts.markerFmt ?? ((n) => `... [${n} lines elided by token-goat]`);
+  const headKeep = Math.max(1, Math.floor(maxLines * headRatio));
+  const tailKeep = Math.max(1, maxLines - headKeep);
+  const elided = lines.length - headKeep - tailKeep;
+  return [...lines.slice(0, headKeep), markerFmt(elided), ...lines.slice(lines.length - tailKeep)];
+}
+function truncateMiddleSmart(lines, maxLines, opts = {}) {
+  if (lines.length <= maxLines) return lines;
+  const headKeep = opts.headKeep ?? 10;
+  const tailKeep = opts.tailKeep ?? 10;
+  const errorContext = opts.errorContext ?? 2;
+  const maxErrorLines = opts.maxErrorLines ?? 10;
+  const markerFmt = opts.markerFmt ?? ((n) => `--- ${n} lines omitted ---`);
+  const errorIndices = [];
+  for (let i = 0; i < lines.length; i++) if (ERROR_SIGNAL_RE.test(lines[i])) errorIndices.push(i);
+  if (errorIndices.length === 0) return truncateMiddle(lines, maxLines, { markerFmt });
+  const total = lines.length;
+  const effHead = Math.min(headKeep, Math.floor(total / 4));
+  const effTail = Math.min(tailKeep, Math.floor(total / 4));
+  const middle = /* @__PURE__ */ new Set();
+  for (let k = 0; k < errorIndices.length && k < maxErrorLines; k++) {
+    const ei = errorIndices[k];
+    for (let ci = Math.max(0, ei - errorContext); ci < Math.min(total, ei + errorContext + 1); ci++) {
+      middle.add(ci);
+    }
+  }
+  for (let i = 0; i < effHead; i++) middle.delete(i);
+  for (let i = total - effTail; i < total; i++) middle.delete(i);
+  const budgetForMiddle = Math.max(0, maxLines - effHead - effTail);
+  let sortedMiddle = Array.from(middle).sort((a, b) => a - b);
+  if (sortedMiddle.length > budgetForMiddle) sortedMiddle = sortedMiddle.slice(0, budgetForMiddle);
+  const result = [];
+  const appendSection = (indices) => {
+    for (let pos = 0; pos < indices.length; pos++) {
+      const idx = indices[pos];
+      if (pos > 0) {
+        const prevIdx = indices[pos - 1];
+        if (idx !== prevIdx + 1) result.push(markerFmt(idx - prevIdx - 1));
       }
-      cut = i;
-      break;
+      result.push(lines[idx]);
     }
+  };
+  const headList = Array.from({ length: effHead }, (_, i) => i);
+  const tailList = Array.from({ length: effTail }, (_, i) => total - effTail + i);
+  appendSection(headList);
+  if (sortedMiddle.length) {
+    const gapAfterHead = sortedMiddle[0] - (headList.length ? headList[headList.length - 1] : -1) - 1;
+    if (gapAfterHead > 0) result.push(markerFmt(gapAfterHead));
+    appendSection(sortedMiddle);
+  }
+  if (tailList.length) {
+    const lastKept = sortedMiddle.length ? sortedMiddle[sortedMiddle.length - 1] : headList.length ? headList[headList.length - 1] : -1;
+    const gapBeforeTail = tailList[0] - lastKept - 1;
+    if (gapBeforeTail > 0) result.push(markerFmt(gapBeforeTail));
+    appendSection(tailList);
   }
-  let base = cmd.slice(0, cut);
-  let prev;
-  do {
-    prev = base;
-    const masked = base.replace(/"((?:[^"\\]|\\.)*)"/g, (_m, inner) => '"' + " ".repeat(inner.length) + '"').replace(/'([^']*)'/g, (_m, inner) => "'" + " ".repeat(inner.length) + "'");
-    const newMasked = masked.replace(/\s*(?:[0-9]*>&[0-9]+|[0-9&]*>>?\s*(?:"[^"]*"|'[^']*'|[^\s|]+))\s*$/, "");
-    if (newMasked.length < masked.length) {
-      base = base.slice(0, newMasked.length);
+  return result;
+}
+function capBytes(text, maxBytes) {
+  const encoded = Buffer.from(text, "utf8");
+  if (encoded.length <= maxBytes) return text;
+  const marker = `
+... [${encoded.length - maxBytes} bytes elided by token-goat]`;
+  const budget = maxBytes - Buffer.byteLength(marker, "utf8");
+  if (budget <= 0) return marker.trim();
+  let slice = encoded.subarray(0, budget);
+  const nl = slice.lastIndexOf(10);
+  if (nl > budget / 2) slice = slice.subarray(0, nl);
+  return slice.toString("utf8") + marker;
+}
+function capTokens(text, maxTokens) {
+  const clean = stripAnsiCodes(text);
+  if (clean.length / 3.5 <= maxTokens) return text;
+  const maxBytes = Math.floor(maxTokens * 3.5);
+  let truncated = capBytes(clean, maxBytes);
+  if (!truncated.includes("[token-goat: output capped at")) {
+    truncated = truncated.replace(BYTES_ELIDED_MARKER_RE, "");
+    truncated += `
+[token-goat: output capped at ~${maxTokens} tokens]`;
+  }
+  return truncated;
+}
+function trimRepeatedPrefix(lines, pattern, keep) {
+  const out2 = [];
+  let matched = 0;
+  let dropped = 0;
+  for (const line of lines) {
+    if (pattern.test(line)) {
+      matched += 1;
+      if (matched <= keep) out2.push(line);
+      else dropped += 1;
+    } else {
+      out2.push(line);
     }
-  } while (base !== prev);
-  return base.trim();
+  }
+  if (dropped) out2.push(`[token-goat: +${dropped} more lines matching ${pattern.source}]`);
+  return out2;
 }
-function extractCommand(event) {
-  const cmd = event.toolInput["command"];
-  return typeof cmd === "string" && cmd.trim() !== "" ? cmd.trim() : void 0;
+function maybeNote(notes, value, msg) {
+  if (value) notes.push(msg);
 }
-function isTempPath(fp) {
-  const norm = fp.replace(/\\/g, "/");
-  return /^\/tmp\//i.test(norm) || /\/var\/folders\//i.test(norm) || /AppData\/Local\/Temp\//i.test(norm) || norm.startsWith("/c/Users/") && norm.includes("/AppData/Local/Temp/");
+function squeezeBlankLines(text) {
+  return text.replace(/\n\s*\n\s*\n+/g, "\n\n");
 }
-function isOrchestratorStateFile(filePath) {
-  const basename8 = (filePath.includes("/") ? filePath.split("/").at(-1) : filePath.split("\\").at(-1)) ?? filePath;
-  return /^\.improve-state-/.test(basename8);
+function preserveStderrOnError(stdout, stderr, exitCode) {
+  if (exitCode !== 0 && stderr.trim()) {
+    return stdout.trim() ? `${stdout.replace(/\s+$/, "")}
+---
+${stderr.replace(/\s+$/, "")}` : stderr;
+  }
+  return null;
 }
-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|css|scss|sass|less))\s*$/.exec(cmd);
-  return m?.[1] ?? null;
+var PASSTHROUGH_PREFIXES = /* @__PURE__ */ new Set([
+  "sudo",
+  "doas",
+  "time",
+  "nice",
+  "ionice",
+  "nohup",
+  "exec",
+  "env",
+  "stdbuf",
+  "unbuffer",
+  "script"
+]);
+var TWO_TOKEN_PREFIXES = {
+  python: /* @__PURE__ */ new Set(["-m"]),
+  python3: /* @__PURE__ */ new Set(["-m"]),
+  py: /* @__PURE__ */ new Set(["-m"]),
+  uv: /* @__PURE__ */ new Set(["run", "tool"]),
+  uvx: /* @__PURE__ */ new Set(),
+  poetry: /* @__PURE__ */ new Set(["run"]),
+  rye: /* @__PURE__ */ new Set(["run"]),
+  pdm: /* @__PURE__ */ new Set(["run"]),
+  pipenv: /* @__PURE__ */ new Set(["run"]),
+  npx: /* @__PURE__ */ new Set(),
+  pnpm: /* @__PURE__ */ new Set(["exec", "dlx"]),
+  yarn: /* @__PURE__ */ new Set(["exec", "dlx"]),
+  bundle: /* @__PURE__ */ new Set(["exec"]),
+  tox: /* @__PURE__ */ new Set(["-e"]),
+  hatch: /* @__PURE__ */ new Set(["run"])
+};
+function pathName(p) {
+  const norm = p.replace(/\\/g, "/");
+  const idx = norm.lastIndexOf("/");
+  return idx >= 0 ? norm.slice(idx + 1) : norm;
+}
+function pathStem(p) {
+  const name = pathName(p);
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(0, dot) : name;
+}
+function positionalArgs(args) {
+  return args.filter((a) => !a.startsWith("-"));
+}
+var SHORT_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set(["-n", "-c", "-i", "-u", "-e"]);
+function stripPrefixes(argv) {
+  if (argv.length === 0) return [];
+  let out2 = [...argv];
+  while (out2.length && out2[0].includes("=") && !out2[0].startsWith("-") && !out2[0].includes("/")) {
+    const head = out2[0].split("=", 1)[0];
+    if (head && (/[A-Za-z]/.test(head[0]) || head[0] === "_") && /^[A-Za-z0-9_]+$/.test(head)) out2.shift();
+    else break;
+  }
+  while (out2.length) {
+    if (!PASSTHROUGH_PREFIXES.has(pathStem(out2[0]).toLowerCase())) break;
+    out2.shift();
+    while (out2.length && out2[0].startsWith("-")) {
+      const flag = out2.shift();
+      if (SHORT_FLAGS_WITH_VALUE.has(flag) && out2.length) out2.shift();
+    }
+  }
+  if (out2.length === 0) return out2;
+  const stem = pathStem(out2[0]).toLowerCase();
+  const triggers = TWO_TOKEN_PREFIXES[stem];
+  if (triggers !== void 0 && out2.length >= 2) {
+    const nextTok = out2[1];
+    if (triggers.size === 0 || triggers.has(nextTok)) {
+      const consume = triggers.size === 0 ? 1 : 2;
+      if (out2.length > consume) out2 = out2.slice(consume);
+    }
+  }
+  return out2;
 }
-function extractCatFile(cmd) {
-  const m = /^cat(?:\s+(?:-[a-zA-Z]+|--[a-zA-Z-]+))*\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s*$/.exec(cmd);
-  if (!m) return null;
+function shlexSplit(cmd) {
+  const tokens = [];
+  let cur = "";
+  let has = false;
+  let i = 0;
+  const n = cmd.length;
+  while (i < n) {
+    const ch = cmd[i];
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+      if (has) {
+        tokens.push(cur);
+        cur = "";
+        has = false;
+      }
+      i += 1;
+      continue;
+    }
+    has = true;
+    if (ch === "\\") {
+      if (i + 1 < n) {
+        cur += cmd[i + 1];
+        i += 2;
+      } else {
+        i += 1;
+      }
+      continue;
+    }
+    if (ch === "'") {
+      i += 1;
+      const end = cmd.indexOf("'", i);
+      if (end === -1) throw new Error("No closing quotation");
+      cur += cmd.slice(i, end);
+      i = end + 1;
+      continue;
+    }
+    if (ch === '"') {
+      i += 1;
+      let buf = "";
+      while (i < n && cmd[i] !== '"') {
+        if (cmd[i] === "\\" && i + 1 < n && (cmd[i + 1] === '"' || cmd[i + 1] === "\\")) {
+          buf += cmd[i + 1];
+          i += 2;
+        } else {
+          buf += cmd[i];
+          i += 1;
+        }
+      }
+      if (i >= n) throw new Error("No closing quotation");
+      cur += buf;
+      i += 1;
+      continue;
+    }
+    cur += ch;
+    i += 1;
+  }
+  if (has) tokens.push(cur);
+  return tokens;
+}
+function capLongLines(lines, maxChars = FALLBACK_MAX_LINE_CHARS) {
+  return lines.map(
+    (line) => line.length > maxChars ? `${line.slice(0, maxChars)}  \u2026 [${line.length - maxChars} chars elided]` : line
+  );
+}
+function fallbackTruncate(stdout, stderr, maxLines) {
+  const half = Math.floor(maxLines / 2);
+  const outLines = truncateMiddle(capLongLines(dedupeConsecutive(stdout.split("\n"))), half);
+  const errLines = truncateMiddle(capLongLines(dedupeConsecutive(stderr.split("\n"))), half);
+  if (stderr) return `${outLines.join("\n")}
+---
+${errLines.join("\n")}`;
+  return outLines.join("\n");
+}
+function compressBashOutput(stdout, stderr) {
+  let body = dedupeConsecutive(stdout.split("\n"), { entropyBypass: true }).join("\n");
+  if (stderr.trim()) {
+    const err2 = dedupeConsecutive(stderr.split("\n"), { entropyBypass: true }).join("\n");
+    body = `${body.replace(/\s+$/, "")}
+---
+${err2.replace(/\s+$/, "")}`;
+  }
+  return body;
+}
+function byteLength(s) {
+  return utf8Len(s);
+}
+
+// src/tool_filters/base.ts
+init_define_import_meta_env();
+var CompressedOutput = class {
+  constructor(text, originalBytes, compressedBytes, filterName, exitCode = 0, notes = []) {
+    this.text = text;
+    this.originalBytes = originalBytes;
+    this.compressedBytes = compressedBytes;
+    this.filterName = filterName;
+    this.exitCode = exitCode;
+    this.notes = notes;
+  }
+  /** Non-negative byte savings (`original - compressed`, clamped at 0). */
+  get bytesSaved() {
+    return Math.max(0, this.originalBytes - this.compressedBytes);
+  }
+  /** Estimated token savings (`n // 3 + 1`, matching `estimateTokens`). */
+  get tokensSaved() {
+    const n = this.bytesSaved;
+    return n <= 0 ? 0 : Math.max(1, Math.floor(n / 3) + 1);
+  }
+  /** Reduction as a percentage of the original size (0 when no input). */
+  get percentSaved() {
+    if (this.originalBytes <= 0) return 0;
+    return 100 * this.bytesSaved / this.originalBytes;
+  }
+  /**
+   * `text` with the trailing compression-summary marker appended. Skipped
+   * entirely on a no-op (savings ≤ 0) so raw output never carries a marker.
+   */
+  withMarker() {
+    if (this.bytesSaved <= 0 || this.originalBytes <= 0) return this.text;
+    return this.text + compressionMarker(this.filterName, this.percentSaved);
+  }
+};
+var ToolFilter = class {
+  /** Command basenames this filter handles (lowercased stems). */
+  binaries = /* @__PURE__ */ new Set();
+  /** Optional subcommand gate; matched against the first 3 positional args. */
+  subcommands = /* @__PURE__ */ new Set();
+  /** When true, pass raw error output through on non-zero exit. */
+  errorPassthrough = false;
+  /** Detect whether this filter applies to the raw command string. */
+  detectFromCommand(cmd) {
+    try {
+      if (!cmd || cmd.length > 65536) return false;
+      const resolved = stripPrefixes(shlexSplit(cmd));
+      if (resolved.length === 0) return false;
+      return this.matches(resolved);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Return true when this filter should run for `argv`. Checks `binaries`
+   * against the lowercased stem (and full name, for dot-in-name binaries like
+   * `py.test`) of `argv[0]`; when `subcommands` is non-empty, requires one in
+   * the first three positional args.
+   */
+  matches(argv) {
+    if (argv.length === 0) return false;
+    const first = argv[0];
+    const stem = pathStem(first).toLowerCase();
+    const name = pathName(first).toLowerCase();
+    if (!this.binaries.has(stem) && !this.binaries.has(name)) return false;
+    if (this.subcommands.size === 0) return true;
+    return positionalArgs(argv.slice(1)).slice(0, 3).some((tok) => this.subcommands.has(tok));
+  }
+  /** Combine stdout/stderr with a `---` separator when both are present. */
+  combineOutput(stdout, stderr) {
+    if (stderr.trim() && stdout.trim()) return `${stdout.replace(/\s+$/, "")}
+---
+${stderr.replace(/\s+$/, "")}`;
+    return stdout.trim() ? stdout.replace(/\s+$/, "") : stderr.replace(/\s+$/, "");
+  }
+  /** Append a `[token-goat: <joined notes>]` summary line to `kept`. */
+  emitNotes(kept, notes, prefix = "token-goat: ") {
+    if (notes.length) kept.push(`[${prefix}${notes.join("; ")}]`);
+  }
+  /** Join `kept` with newlines and squeeze runs of blank lines. */
+  finalize(kept) {
+    return squeezeBlankLines(kept.join("\n"));
+  }
+  /**
+   * Hook applied to each stream right after {@link normalise}. Identity by
+   * default; the git filter family overrides it to strip CRLF warnings. Keeps
+   * `apply` free of per-family name checks.
+   */
+  postNormalise(text) {
+    return text;
+  }
+  /**
+   * Template: when {@link errorPassthrough} is set, return the raw combined
+   * error output on non-zero exit before delegating to {@link compressBody}.
+   * Filters that handle errors structurally (pytest, cargo) override this
+   * directly and leave `errorPassthrough` false.
+   */
+  compress(stdout, stderr, exitCode, argv) {
+    if (this.errorPassthrough) {
+      const err2 = preserveStderrOnError(stdout, stderr, exitCode);
+      if (err2 !== null) return err2;
+    }
+    return this.compressBody(stdout, stderr, exitCode, argv);
+  }
+  /**
+   * Inner compression logic, called after the error-passthrough guard.
+   * Default is a passthrough that joins the two streams — useful when the only
+   * compression is the ANSI / progress strip `apply` already performed.
+   */
+  compressBody(stdout, stderr, _exitCode, _argv) {
+    if (stderr && stdout) return `${stdout.replace(/\s+$/, "")}
+---
+${stderr.replace(/\s+$/, "")}`;
+    return stdout || stderr;
+  }
+  /**
+   * Top-level entry: sanitise → input cap → normalise → compress → line/byte
+   * cap → wrap in {@link CompressedOutput}. Faithful port of the Python
+   * `apply` 10-step pipeline. Errors from {@link compress} fall back to a
+   * truncated view so the agent always sees something.
+   */
+  apply(stdout, stderr, exitCode, argv, opts = {}) {
+    const maxLines = opts.maxLines ?? DEFAULT_MAX_LINES;
+    const maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES;
+    const skipProgress = opts.skipProgress ?? false;
+    let so = safeDecode(stdout);
+    let se = safeDecode(stderr);
+    const maxInput = getMaxInputBytes();
+    const notes = [];
+    const soBytes = Buffer.from(so, "utf8");
+    const seBytes = Buffer.from(se, "utf8");
+    if (soBytes.length > maxInput) {
+      so = soBytes.subarray(0, maxInput).toString("utf8");
+      notes.push(`input truncated at ${Math.floor(maxInput / 1024)}KB (TOKEN_GOAT_FILTER_MAX_BYTES)`);
+    }
+    if (seBytes.length > maxInput) {
+      se = seBytes.subarray(0, maxInput).toString("utf8");
+      if (!notes.some((n) => n.includes("input truncated"))) {
+        notes.push(`stderr truncated at ${Math.floor(maxInput / 1024)}KB (TOKEN_GOAT_FILTER_MAX_BYTES)`);
+      }
+    }
+    const originalBytes = soBytes.length + seBytes.length;
+    if (!so.trim() && !se.trim()) {
+      const text = notes.length ? `[${notes.join("; ")}]
+` : "";
+      return new CompressedOutput(text, originalBytes, byteLength(text), this.name, exitCode, notes);
+    }
+    let body;
+    try {
+      const normOut = this.postNormalise(normalise(so, { skipProgress }));
+      const normErr = this.postNormalise(normalise(se, { skipProgress }));
+      const normBytes = byteLength(normOut) + byteLength(normErr);
+      if (originalBytes > 0 && normBytes <= originalBytes * 0.6) {
+        body = compressBashOutput(normOut, normErr);
+        notes.push("early-exit: normalisation alone sufficient");
+      } else if (normBytes > MAX_INSPECT_BYTES) {
+        notes.push(`input exceeded inspect budget (${Math.floor(MAX_INSPECT_BYTES / 1024)} KiB); fell back to truncation`);
+        body = fallbackTruncate(normOut, normErr, maxLines);
+      } else {
+        body = this.compress(normOut, normErr, exitCode, argv);
+      }
+    } catch (exc) {
+      const kind = exc instanceof Error ? exc.constructor.name : "Error";
+      notes.push(`${this.name} filter raised ${kind}; truncated raw`);
+      const fbOut = this.postNormalise(normalise(so, { skipProgress }));
+      const fbErr = this.postNormalise(normalise(se, { skipProgress }));
+      body = fallbackTruncate(fbOut, fbErr, maxLines);
+    }
+    const lines = body.split("\n");
+    if (lines.length > maxLines) body = truncateMiddleSmart(lines, maxLines).join("\n");
+    body = capBytes(body, maxBytes);
+    if (notes.length) body = `[${notes.join("; ")}]
+${body}`;
+    return new CompressedOutput(body, originalBytes, byteLength(body), this.name, exitCode, notes);
+  }
+};
+
+// src/tool_filters/generic.ts
+init_define_import_meta_env();
+var GenericFilter = class extends ToolFilter {
+  name = "generic";
+  compress(stdout, stderr, _exitCode, _argv) {
+    const outLines = dedupeConsecutive(stdout.split("\n"), { entropyBypass: true });
+    const errLines = dedupeConsecutive(stderr.split("\n"), { entropyBypass: true });
+    let result;
+    if (stderr.trim()) {
+      const outPart = outLines.join("\n").replace(/\s+$/, "");
+      const errPart = errLines.join("\n").replace(/\s+$/, "");
+      result = outPart ? `${outPart}
+---
+${errPart}` : errPart;
+    } else {
+      result = outLines.join("\n");
+    }
+    return capTokens(result, 2e3);
+  }
+};
+
+// src/tool_filters/families.ts
+init_define_import_meta_env();
+function plural(n, suffix = "s") {
+  return n === 1 ? "" : suffix;
+}
+function makeNodeTestRunnerFilter(cfg) {
+  return new class extends ToolFilter {
+    name = cfg.name;
+    binaries = new Set(cfg.binaries);
+    compress(stdout, stderr, _exitCode, _argv) {
+      const merged = this.combineOutput(stdout, stderr);
+      const lines = merged.split("\n");
+      const kept = [];
+      let passFile = 0;
+      let tick = 0;
+      let inFail = false;
+      let blockLines = 0;
+      let inBlock = false;
+      let inFailuresSection = false;
+      let failuresDropped = 0;
+      const flush = () => {
+        if (blockLines) {
+          kept.push(`  [token-goat: collapsed ${blockLines} ${cfg.outputNoun} line${plural(blockLines)}]`);
+        }
+        blockLines = 0;
+        inBlock = false;
+      };
+      for (const line of lines) {
+        if (cfg.failuresSection) {
+          if (line.trim() === "Failures:") {
+            flush();
+            inFail = false;
+            inFailuresSection = true;
+            failuresDropped += 1;
+            continue;
+          }
+          if (inFailuresSection) {
+            if (cfg.summaryRe.test(line)) {
+              inFailuresSection = false;
+              kept.push(line);
+            } else {
+              failuresDropped += 1;
+            }
+            continue;
+          }
+        }
+        if (cfg.passFileRe.test(line) && !inFail) {
+          flush();
+          passFile += 1;
+          continue;
+        }
+        if (cfg.failFileRe.test(line)) {
+          flush();
+          inFail = true;
+          kept.push(line);
+          continue;
+        }
+        if (cfg.summaryRe.test(line)) {
+          flush();
+          kept.push(line);
+          continue;
+        }
+        if (!line.trim() && inFail) {
+          inFail = false;
+          kept.push(line);
+          continue;
+        }
+        if (inFail) {
+          kept.push(line);
+          continue;
+        }
+        if (cfg.outputHdrRe.test(line)) {
+          flush();
+          inBlock = true;
+          blockLines = 1;
+          continue;
+        }
+        if (inBlock) {
+          const stripped = line.trim();
+          if (!stripped || line.length > 0 && !/^\s/.test(line)) {
+            flush();
+          } else {
+            blockLines += 1;
+            continue;
+          }
+        }
+        if (cfg.testTickRe.test(line)) {
+          tick += 1;
+          continue;
+        }
+        kept.push(line);
+      }
+      flush();
+      const notes = [];
+      maybeNote(notes, passFile, `collapsed ${passFile} ${cfg.passFileNoun}${plural(passFile)}`);
+      maybeNote(notes, tick, `collapsed ${tick} passing tick${plural(tick)}`);
+      if (failuresDropped) {
+        notes.push(
+          `collapsed ${failuresDropped} line${plural(failuresDropped)} from duplicate 'Failures:' section (already shown inline)`
+        );
+      }
+      this.emitNotes(kept, notes);
+      return this.finalize(kept);
+    }
+  }();
+}
+
+// src/tool_filters/test_runners.ts
+init_define_import_meta_env();
+var jestFilter = makeNodeTestRunnerFilter({
+  name: "jest",
+  binaries: ["jest", "mocha", "ava", "tap"],
+  // File-level PASS header: `PASS  src/foo.test.js`, or a bare `✓ file` at col 0.
+  passFileRe: /^(?:\s*PASS\s+\S|[✓√]\s+\S)/,
+  failFileRe: /^\s*(?:FAIL|✗|×|✘)\s+\S/,
+  summaryRe: /^(Test Suites|Tests|Snapshots|Time|Ran all test suites):/,
+  // Per-test tick: any ✓/√ line not already claimed as a file header above.
+  testTickRe: /^\s*[✓√]/,
+  outputHdrRe: /^\s*console\.(log|error|warn|info|debug)\s/,
+  outputNoun: "console output",
+  passFileNoun: "PASS file",
+  failuresSection: true
+});
+var vitestFilter = makeNodeTestRunnerFilter({
+  name: "vitest",
+  binaries: ["vitest"],
+  // File-level pass header carries a duration: `✓ src/x.test.ts (12ms)`.
+  passFileRe: /^\s*✓\s+\S.*\([\d.]+\s*\w+\)/,
+  failFileRe: /^\s*(?:×|FAIL|✗|✘)\s+\S/,
+  summaryRe: /^(Test Files|Tests|Modules|Duration|Start at)[\s:]+\d/,
+  // Per-test tick is indented ≥2 spaces: `  ✓ should pass`.
+  testTickRe: /^\s{2,}✓\s/,
+  outputHdrRe: /^\s*stdout\s*\|/,
+  outputNoun: "stdout",
+  passFileNoun: "passing file"
+});
+var TEST_RUNNER_FILTERS = [jestFilter, vitestFilter];
+
+// src/tool_filters/pytest.ts
+init_define_import_meta_env();
+var XDIST_PREFIX_RE = /^\[gw\d+\]\s*(?:\[\s*\d+%\]\s*)?/;
+var DOTS_RE = /^[.FxXEsS]+\s*(\[\s*\d+%\])?\s*$/;
+var BANNER_RE = /^(?:platform\s|cachedir:\s|rootdir:\s|plugins:\s|configfile:\s|bringing up\s|cacheprovider-)/;
+var PREAMBLE_RE = /^collecting\s/;
+var HEADER_RE2 = /^=+\s*(?:test session starts|FAILURES|ERRORS|short test summary info|warnings summary|slowest \d+ durations|\d+ failed|\d+ passed|\d+ error)\b/;
+var COV_TOTAL_RE = /^TOTAL\s+\d/;
+var WARN_DOCS_RE = /^\s*--\s+Docs:\s+https?:\/\//;
+var WARN_MSG_RE = /^\s+\S.*:\d+:\s+\S.*Warning\b/;
+var SLOW_DURATION_RE = /^\d+\.\d+s\s+(?:call|setup|teardown)\s+\S/;
+var FAIL_LINE_RE = /^(FAILED|ERROR|PASSED|SKIPPED|XFAIL|XPASS)\s+\S/;
+var VERBOSE_LINE_RE = /^\S.+::\S+[ \t]+(PASSED|FAILED|ERROR|SKIPPED|XFAIL|XPASS)(?:[ \t]|$)/;
+var COLLECT_RE = /^collected \d+ items?/;
+var COV_SEP_RE = /^[-=]+\s*$/;
+var COV_ROW_RE = /^\S.*\s+\d+\s+\d+\s+\d+%?\s*$/;
+var MAX_SLOW_KEPT = 5;
+var PytestFilter = class extends ToolFilter {
+  name = "pytest";
+  binaries = /* @__PURE__ */ new Set(["pytest", "py.test"]);
+  compress(stdout, stderr, _exitCode, _argv) {
+    const text = this.combineOutput(stdout, stderr);
+    const lines = text.split("\n");
+    let kept = [];
+    let passedCount = 0;
+    let inFailures = false;
+    let inErrors = false;
+    let inSlowSection = false;
+    let inWarningsSection = false;
+    let slowKept = 0;
+    let slowDropped = 0;
+    let inCovTable = false;
+    let covTableRowsDropped = 0;
+    const warnMsgSeen = /* @__PURE__ */ new Map();
+    let warningsDropped = 0;
+    for (let line of lines) {
+      if (XDIST_PREFIX_RE.test(line)) line = line.replace(XDIST_PREFIX_RE, "");
+      if (DOTS_RE.test(line)) continue;
+      if (BANNER_RE.test(line)) continue;
+      if (PREAMBLE_RE.test(line)) continue;
+      if (HEADER_RE2.test(line)) {
+        inFailures = line.includes("FAILURES");
+        inErrors = line.includes("ERRORS") || line.includes("short test summary");
+        inSlowSection = line.includes("slowest") && line.includes("durations");
+        inWarningsSection = line.includes("warnings summary");
+        inCovTable = false;
+        if (line.includes("test session starts")) continue;
+        kept.push(line);
+        continue;
+      }
+      if (line.startsWith("Name") && line.includes("Stmts") && line.includes("Miss")) {
+        inCovTable = true;
+        kept.push(line);
+        continue;
+      }
+      if (inCovTable) {
+        if (COV_TOTAL_RE.test(line)) {
+          if (covTableRowsDropped) {
+            kept.push(`[token-goat: collapsed ${covTableRowsDropped} coverage table rows]`);
+            covTableRowsDropped = 0;
+          }
+          kept.push(line);
+          inCovTable = false;
+          continue;
+        }
+        if (COV_SEP_RE.test(line)) {
+          kept.push(line);
+          continue;
+        }
+        if (COV_ROW_RE.test(line)) {
+          covTableRowsDropped += 1;
+          continue;
+        }
+        inCovTable = false;
+      }
+      if (inWarningsSection) {
+        if (WARN_DOCS_RE.test(line)) {
+          warningsDropped += 1;
+          continue;
+        }
+        if (WARN_MSG_RE.test(line)) {
+          const colonIdx = line.lastIndexOf("Warning");
+          const normKey = colonIdx >= 0 ? line.slice(colonIdx).trim() : line.trim();
+          const count = warnMsgSeen.get(normKey) ?? 0;
+          warnMsgSeen.set(normKey, count + 1);
+          if (count === 0) kept.push(line);
+          else warningsDropped += 1;
+          continue;
+        }
+      }
+      if (inSlowSection) {
+        if (SLOW_DURATION_RE.test(line)) {
+          if (slowKept < MAX_SLOW_KEPT) {
+            kept.push(line);
+            slowKept += 1;
+          } else {
+            slowDropped += 1;
+          }
+          continue;
+        }
+        if (!line.trim() || HEADER_RE2.test(line)) {
+          if (slowDropped) {
+            kept.push(`[token-goat: collapsed ${slowDropped} slow-test duration lines]`);
+            slowDropped = 0;
+          }
+          inSlowSection = false;
+          if (!line.trim()) continue;
+          if (HEADER_RE2.test(line)) {
+            inFailures = line.includes("FAILURES");
+            inErrors = line.includes("ERRORS") || line.includes("short test summary");
+            inWarningsSection = line.includes("warnings summary");
+            kept.push(line);
+            continue;
+          }
+        } else {
+          kept.push(line);
+          continue;
+        }
+      }
+      if (!inFailures && !inErrors && FAIL_LINE_RE.test(line)) {
+        const tag = line.split(/\s+/, 1)[0];
+        if (tag === "PASSED") {
+          passedCount += 1;
+          continue;
+        }
+        kept.push(line);
+        continue;
+      }
+      if (!inFailures && !inErrors) {
+        const m = VERBOSE_LINE_RE.exec(line);
+        if (m) {
+          if (m[1] === "PASSED") {
+            passedCount += 1;
+            continue;
+          }
+          kept.push(line);
+          continue;
+        }
+      }
+      kept.push(line);
+    }
+    if (slowDropped) kept.push(`[token-goat: collapsed ${slowDropped} slow-test duration lines]`);
+    if (covTableRowsDropped)
+      kept.push(`[token-goat: collapsed ${covTableRowsDropped} coverage table rows]`);
+    kept = trimRepeatedPrefix(kept, COLLECT_RE, 3);
+    if (passedCount) kept.push(`[token-goat: collapsed ${passedCount} PASSED lines]`);
+    if (warningsDropped)
+      kept.push(`[token-goat: collapsed ${warningsDropped} duplicate/docs warning lines]`);
+    return this.finalize(kept);
+  }
+};
+var pytestFilter = new PytestFilter();
+
+// src/tool_filters/go_test.ts
+init_define_import_meta_env();
+var TEST_RUN_RE = /^=== (RUN|PAUSE|CONT|NAME)\s/;
+var RACE_FENCE_RE = /^={10,}\s*$/;
+var RACE_WARNING_RE = /^WARNING: DATA RACE/;
+var TEST_PASS_RE = /^\s*--- PASS:\s/;
+var TEST_FAIL_RE = /^\s*--- FAIL:\s/;
+var TEST_RPC_RE = /^=== (RUN|PAUSE|CONT)\s/;
+var SKIP_RE = /^\s*--- SKIP:\s/;
+var GOROUTINE_HEADER_RE = /^(?:Goroutine \d+|Previous|Current)\s/;
+var OK_PKG_RE = /^ok\s+\S+\s+\d/;
+var FAIL_PKG_RE = /^FAIL\t\S+/;
+var MAX_RACE_GOROUTINE_FRAMES = 5;
+var GoTestFilter = class extends ToolFilter {
+  name = "go-test";
+  binaries = /* @__PURE__ */ new Set(["go"]);
+  // Fire only for `go test` (test as the FIRST positional), not `go build`/`run`.
+  matches(argv) {
+    if (argv.length === 0) return false;
+    const stem = argv[0].replace(/\\/g, "/").split("/").pop().toLowerCase().replace(/\.exe$/, "");
+    if (stem !== "go") return false;
+    return positionalArgs(argv.slice(1)).slice(0, 1)[0] === "test";
+  }
+  compress(stdout, stderr, _exitCode, argv) {
+    if (argv.includes("-json")) return this.combineOutput(stdout, stderr);
+    const merged = this.combineOutput(stdout, stderr);
+    const lines = merged.split("\n");
+    const kept = [];
+    let passCount = 0;
+    let skipCount = 0;
+    let inFailBlock = false;
+    let droppedRun = 0;
+    let droppedDownload = 0;
+    let inRaceBlock = false;
+    let raceBlockLines = [];
+    let racePendingFence = false;
+    let raceCount = 0;
+    const flushRaceBlock = () => {
+      let inGoroutine = false;
+      let goroutineFrameCount = 0;
+      let goroutineFramesDropped = 0;
+      for (const rline of raceBlockLines) {
+        if (GOROUTINE_HEADER_RE.test(rline)) {
+          if (goroutineFramesDropped) {
+            kept.push(`    [token-goat: +${goroutineFramesDropped} goroutine frames omitted]`);
+          }
+          inGoroutine = true;
+          goroutineFrameCount = 0;
+          goroutineFramesDropped = 0;
+          kept.push(rline);
+          continue;
+        }
+        if (inGoroutine) {
+          if ((rline.startsWith(" ") || rline.startsWith("	")) && rline.trim()) {
+            goroutineFrameCount += 1;
+            if (goroutineFrameCount <= MAX_RACE_GOROUTINE_FRAMES) kept.push(rline);
+            else goroutineFramesDropped += 1;
+            continue;
+          }
+          if (goroutineFramesDropped) {
+            kept.push(`    [token-goat: +${goroutineFramesDropped} goroutine frames omitted]`);
+          }
+          inGoroutine = false;
+          goroutineFrameCount = 0;
+          goroutineFramesDropped = 0;
+        }
+        kept.push(rline);
+      }
+      if (goroutineFramesDropped) {
+        kept.push(`    [token-goat: +${goroutineFramesDropped} goroutine frames omitted]`);
+      }
+    };
+    for (const line of lines) {
+      if (line.startsWith("go: downloading")) {
+        droppedDownload += 1;
+        continue;
+      }
+      if (RACE_FENCE_RE.test(line)) {
+        if (inRaceBlock) {
+          raceBlockLines.push(line);
+          flushRaceBlock();
+          raceBlockLines = [];
+          inRaceBlock = false;
+          racePendingFence = false;
+        } else if (!racePendingFence) {
+          racePendingFence = true;
+          raceBlockLines = [line];
+        } else {
+          kept.push(...raceBlockLines, line);
+          raceBlockLines = [];
+          racePendingFence = false;
+        }
+        continue;
+      }
+      if (racePendingFence) {
+        raceBlockLines.push(line);
+        if (RACE_WARNING_RE.test(line)) {
+          inRaceBlock = true;
+          raceCount += 1;
+          racePendingFence = false;
+        } else if (!line.trim()) {
+          kept.push(...raceBlockLines);
+          raceBlockLines = [];
+          racePendingFence = false;
+        }
+        continue;
+      }
+      if (inRaceBlock) {
+        raceBlockLines.push(line);
+        continue;
+      }
+      if (TEST_RPC_RE.test(line)) {
+        droppedRun += 1;
+        continue;
+      }
+      if (TEST_FAIL_RE.test(line)) {
+        inFailBlock = true;
+        kept.push(line);
+        continue;
+      }
+      if (TEST_PASS_RE.test(line)) {
+        inFailBlock = false;
+        passCount += 1;
+        continue;
+      }
+      if (SKIP_RE.test(line)) {
+        skipCount += 1;
+        continue;
+      }
+      if (TEST_RUN_RE.test(line)) {
+        if (inFailBlock) {
+          inFailBlock = false;
+        } else {
+          droppedRun += 1;
+          continue;
+        }
+      }
+      if (inFailBlock && (line.startsWith("    ") || line.startsWith("	") || !line.trim())) {
+        kept.push(line);
+        continue;
+      }
+      inFailBlock = false;
+      kept.push(line);
+    }
+    if (raceBlockLines.length) flushRaceBlock();
+    const goOkCount = kept.filter((l) => OK_PKG_RE.test(l)).length;
+    const goFailCount = kept.filter((l) => FAIL_PKG_RE.test(l)).length;
+    if (goOkCount + goFailCount >= 2) {
+      kept.push(`[${goOkCount} packages passed, ${goFailCount} packages failed]`);
+    }
+    const notes = [];
+    maybeNote(
+      notes,
+      raceCount,
+      `kept ${raceCount} DATA RACE block(s) verbatim (goroutine stacks collapsed)`
+    );
+    maybeNote(notes, passCount, `collapsed ${passCount} PASS testcases`);
+    maybeNote(notes, skipCount, `collapsed ${skipCount} SKIP testcases`);
+    maybeNote(notes, droppedRun, `dropped ${droppedRun} === RUN/PAUSE/CONT lines`);
+    maybeNote(notes, droppedDownload, `dropped ${droppedDownload} 'go: downloading' lines`);
+    this.emitNotes(kept, notes);
+    return this.finalize(kept);
+  }
+};
+var goTestFilter = new GoTestFilter();
+
+// src/tool_filters/dispatch.ts
+init_define_import_meta_env();
+var TOOL_FILTERS = [
+  // Batch A — test runners. Node family (jest/mocha/ava/tap, vitest) first, then
+  // the bespoke runners (pytest, go test) that need their own structural logic.
+  // No overlap with later batches; safe at the head — except `go-test`, which
+  // must precede any future `go build`/`go run` filter (both match `go`), so it
+  // is registered here ahead of the build batch.
+  ...TEST_RUNNER_FILTERS,
+  pytestFilter,
+  goTestFilter
+  // Batches append here: package-managers · linters · vcs · build · containers ·
+  // cloud/iac · ci · ai-clis · shell/file · lang.
+];
+var PROFILE_CAPS = { aggressive: 50, balanced: 200, minimal: 500 };
+function selectFilter(argv) {
+  if (argv.length === 0) return null;
+  let resolved = stripPrefixes(argv);
+  if (resolved.length === 0) {
+    resolved = argv.slice(0, 1);
+    if (resolved.length === 0) return null;
+  }
+  for (const f of TOOL_FILTERS) {
+    try {
+      if (f.matches(resolved)) return f;
+    } catch {
+    }
+  }
+  return null;
+}
+function hasRedirect(argv) {
+  return argv.some((tok) => REDIRECT_TOKEN_RE.test(tok));
+}
+function detectFromCommand(command) {
+  if (!command || command.length > 65536) return null;
+  if (["&&", "||", "$(", "`"].some((op) => command.includes(op))) return null;
+  if (command.includes("|") || command.includes(";")) return null;
+  let argv;
+  try {
+    argv = shlexSplit(command);
+  } catch {
+    return null;
+  }
+  if (hasRedirect(argv)) return null;
+  const filter = selectFilter(argv);
+  if (filter === null) return null;
+  return { filter, argv: stripPrefixes(argv) };
+}
+function compressOutput(filter, stdout, stderr, exitCode, argv, opts = {}) {
+  const profile = opts.compressionProfile ?? "balanced";
+  const maxLines = opts.maxLines ?? 1e3;
+  let effectiveMaxLines = PROFILE_CAPS[profile] ?? 200;
+  if (maxLines < effectiveMaxLines) effectiveMaxLines = maxLines;
+  const skipProgress = profile === "minimal";
+  const applyOpts = { maxLines: effectiveMaxLines, skipProgress };
+  if (opts.maxBytes !== void 0) applyOpts.maxBytes = opts.maxBytes;
+  return filter.apply(stdout, stderr, exitCode, argv, applyOpts);
+}
+function filterByName(name) {
+  if (name === "generic") return new GenericFilter();
+  for (const f of TOOL_FILTERS) if (f.name === name) return f;
+  return null;
+}
+
+// src/hooks_bash.ts
+function stripCdPrefix(cmd) {
+  const stripped = cmd.replace(/^(?:cd\s+(?:"[^"]*"|'[^']*'|\S+)\s*&&\s*)+/, "");
+  return stripped.trim() || cmd;
+}
+function stripOutputPipeline(cmd) {
+  let inSingle = false;
+  let inDouble = false;
+  let cut = cmd.length;
+  for (let i = 0; i < cmd.length; i++) {
+    const ch = cmd[i];
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle;
+    } else if (ch === '"' && !inSingle) {
+      inDouble = !inDouble;
+    } else if (ch === "|" && !inSingle && !inDouble) {
+      if (cmd[i + 1] === "|") {
+        i++;
+        continue;
+      }
+      cut = i;
+      break;
+    }
+  }
+  let base = cmd.slice(0, cut);
+  let prev;
+  do {
+    prev = base;
+    const masked = base.replace(/"((?:[^"\\]|\\.)*)"/g, (_m, inner) => '"' + " ".repeat(inner.length) + '"').replace(/'([^']*)'/g, (_m, inner) => "'" + " ".repeat(inner.length) + "'");
+    const newMasked = masked.replace(/\s*(?:[0-9]*>&[0-9]+|[0-9&]*>>?\s*(?:"[^"]*"|'[^']*'|[^\s|]+))\s*$/, "");
+    if (newMasked.length < masked.length) {
+      base = base.slice(0, newMasked.length);
+    }
+  } while (base !== prev);
+  return base.trim();
+}
+function extractCommand(event) {
+  const cmd = event.toolInput["command"];
+  return typeof cmd === "string" && cmd.trim() !== "" ? cmd.trim() : void 0;
+}
+function isTempPath(fp) {
+  const norm = fp.replace(/\\/g, "/");
+  return /^\/tmp\//i.test(norm) || /\/var\/folders\//i.test(norm) || /AppData\/Local\/Temp\//i.test(norm) || norm.startsWith("/c/Users/") && norm.includes("/AppData/Local/Temp/");
+}
+function isOrchestratorStateFile(filePath) {
+  const basename9 = (filePath.includes("/") ? filePath.split("/").at(-1) : filePath.split("\\").at(-1)) ?? filePath;
+  return /^\.improve-state-/.test(basename9);
+}
+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|css|scss|sass|less))\s*$/.exec(cmd);
+  return m?.[1] ?? null;
+}
+function extractCatFile(cmd) {
+  const m = /^cat(?:\s+(?:-[a-zA-Z]+|--[a-zA-Z-]+))*\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s*$/.exec(cmd);
+  if (!m) return null;
   const filePath = m[1] ?? m[2] ?? m[3];
   if (filePath === void 0) return null;
   if (isTempPath(filePath)) return null;
-  const basename8 = (filePath.includes("/") ? filePath.split("/").at(-1) : filePath.split("\\").at(-1)) ?? filePath;
-  const isEnvFile = /^\.env(\.\w+)?$/i.test(basename8);
+  const basename9 = (filePath.includes("/") ? filePath.split("/").at(-1) : filePath.split("\\").at(-1)) ?? filePath;
+  const isEnvFile = /^\.env(\.\w+)?$/i.test(basename9);
   const hasKnownExt = /\.(?:java|py|ts|tsx|js|jsx|go|rb|rs|cpp|cc|cxx|c|h|hpp|kt|swift|cs|php|scala|clj|css|scss|sass|less|md|mdx|rst|txt|json|yaml|yml|toml|xml|conf|cfg|ini|properties|sql|env)$/i.test(filePath);
   if (!hasKnownExt && !isEnvFile) return null;
   const isSql = /\.sql$/i.test(filePath);
@@ -16007,8 +17473,8 @@ function extractWslCatFile(cmd) {
   if (!drive || !pathRest) return null;
   const filePath = drive + ":/" + pathRest;
   if (isTempPath(filePath)) return null;
-  const basename8 = (filePath.includes("/") ? filePath.split("/").at(-1) : filePath.split("\\").at(-1)) ?? filePath;
-  const isEnvFile = /^\.env(\.\w+)?$/i.test(basename8);
+  const basename9 = (filePath.includes("/") ? filePath.split("/").at(-1) : filePath.split("\\").at(-1)) ?? filePath;
+  const isEnvFile = /^\.env(\.\w+)?$/i.test(basename9);
   const hasKnownExt = /\.(?:java|py|ts|tsx|js|jsx|go|rb|rs|cpp|cc|cxx|c|h|hpp|kt|swift|cs|php|scala|clj|css|scss|sass|less|md|mdx|rst|txt|json|yaml|yml|toml|xml|conf|cfg|ini|properties|sql|env)$/i.test(filePath);
   if (!hasKnownExt && !isEnvFile) return null;
   const isSql = /\.sql$/i.test(filePath);
@@ -16124,7 +17590,7 @@ function extractTasksOutput(cmd) {
     const fp = catM[1] ?? catM[2] ?? catM[3];
     if (fp) {
       const m = taskOutputRe.exec(fp);
-      if (m) return { id: m[1] };
+      if (m) return { id: m[1], path: fp };
     }
   }
   if (!/-f\b/.test(cmd) && !/-n\s*\+/.test(cmd)) {
@@ -16136,7 +17602,7 @@ function extractTasksOutput(cmd) {
         if (m) {
           const nStr = tailM[1] ?? tailM[2];
           const n = nStr !== void 0 ? parseInt(nStr, 10) : void 0;
-          return n !== void 0 ? { id: m[1], n } : { id: m[1] };
+          return n !== void 0 ? { id: m[1], path: fp, n } : { id: m[1], path: fp };
         }
       }
     }
@@ -16145,7 +17611,7 @@ function extractTasksOutput(cmd) {
       const fp = byteTailM[1] ?? byteTailM[2] ?? byteTailM[3];
       if (fp) {
         const m = taskOutputRe.exec(fp);
-        if (m) return { id: m[1] };
+        if (m) return { id: m[1], path: fp };
       }
     }
   }
@@ -16236,6 +17702,53 @@ function buildRecallHint(cmd, outputId) {
   }
   return "Output from a prior `" + cmdPreview + "` run is cached. Use `token-goat bash-output " + outputId + "` (or `--tail 50`, `--grep ERROR`) to re-inspect it without re-running.";
 }
+function shellQuoteSingle(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function isCompressibleSingleCommand(cmd) {
+  if (!cmd || cmd.length > 65536) return false;
+  if (["&&", "||", "$(", "`"].some((op) => cmd.includes(op))) return false;
+  if (cmd.includes("|") || cmd.includes(";")) return false;
+  if (/[<>]/.test(cmd)) return false;
+  return true;
+}
+function maybeCompressRewrite(event, rawCmd, cmd) {
+  if (process.env["TOKEN_GOAT_BASH_COMPRESS"] === "0") return null;
+  let cfg;
+  try {
+    cfg = loadConfig().bash_compress;
+  } catch {
+    return null;
+  }
+  if (!cfg.enabled) return null;
+  const detected = detectFromCommand(cmd);
+  let filterName;
+  if (detected !== null) {
+    filterName = detected.filter.name;
+  } else if (isCompressibleSingleCommand(cmd)) {
+    filterName = "generic";
+  } else {
+    return null;
+  }
+  if (cfg.disabled_filters.includes(filterName)) return null;
+  const wrapped = `token-goat compress -f ${filterName} -c ${shellQuoteSingle(rawCmd)}`;
+  return { hookType: "rewriteInput", updatedInput: { ...event.toolInput, command: wrapped } };
+}
+function unwrapCompressCommand(executed) {
+  const t = executed.trim();
+  if (!/^token-goat\s+compress\b/.test(t)) return null;
+  let argv;
+  try {
+    argv = shlexSplit(t);
+  } catch {
+    return null;
+  }
+  for (let i = 0; i + 1 < argv.length; i++) {
+    const tok = argv[i];
+    if (tok === "-c" || tok === "--cmd") return argv[i + 1] ?? null;
+  }
+  return null;
+}
 function preBashHandler(event) {
   const rawCmd = extractCommand(event);
   if (rawCmd === void 0) return passOutput();
@@ -16243,10 +17756,11 @@ function preBashHandler(event) {
   const cdStripped = cmd !== rawCmd;
   const taskOutput = extractTasksOutput(cmd);
   if (taskOutput !== null) {
-    const { id } = taskOutput;
+    const { id, path: outPath, n } = taskOutput;
     recordStat("session_hint", 0, 0);
+    const tail = n ?? 50;
     return denyOutput(
-      "Use `token-goat bash-output " + id + "` to recall this task output (already cached). Append `--tail <n>` or `--grep PATTERN` to slice it."
+      "Task output " + id + ' is on disk. Use `token-goat bash-output --file "' + outPath + '" --tail ' + tail + "` (or `--grep PATTERN`) to read a slice instead of the whole file."
     );
   }
   const findResult = extractFindCommand(cmd);
@@ -16375,9 +17889,9 @@ function preBashHandler(event) {
   if (monitoringHint !== null) {
     const monCmdHash = shortFingerprint(stripOutputPipeline(cmd));
     const monOutputId = getBashOutputId(monCmdHash);
-    if (monOutputId !== null) {
-      const monEntry = getBashOutput(monOutputId);
-      const monBytes = monEntry?.sizeBytes ?? 0;
+    const monEntry = monOutputId !== null ? getBashOutput(monOutputId) : null;
+    if (monOutputId !== null && monEntry !== null) {
+      const monBytes = monEntry.sizeBytes;
       const catFile = extractCatSourceFile(cmd);
       if (catFile !== null) {
         recordStat("bash_compress:recall", monBytes, Math.round(monBytes / 4));
@@ -16406,9 +17920,9 @@ function preBashHandler(event) {
     const curlCacheKey = extractCurlUrl(cmd) ?? cmd;
     const curlHash = shortFingerprint(curlCacheKey);
     const curlOutputId = getBashOutputId(curlHash);
-    if (curlOutputId !== null) {
-      const curlEntry = getBashOutput(curlOutputId);
-      const curlBytes = curlEntry?.sizeBytes ?? 0;
+    const curlEntry = curlOutputId !== null ? getBashOutput(curlOutputId) : null;
+    if (curlOutputId !== null && curlEntry !== null) {
+      const curlBytes = curlEntry.sizeBytes;
       recordStat("bash_compress:recall", curlBytes, Math.round(curlBytes / 4));
       const curlPreview = cmd.length > 60 ? cmd.slice(0, 57) + "..." : cmd;
       return contextOutput(
@@ -16416,14 +17930,16 @@ function preBashHandler(event) {
       );
     }
   }
-  if (!isBuildCommand(cmd)) return passOutput();
+  if (!isBuildCommand(cmd) && detectFromCommand(cmd) === null) return passOutput();
   const cmdHash = shortFingerprint(stripOutputPipeline(cmd));
   const outputId = getBashOutputId(cmdHash);
-  if (outputId === null) return passOutput();
-  const entry = getBashOutput(outputId);
-  const bytes = entry?.sizeBytes ?? 0;
-  recordStat("bash_compress:recall", bytes, Math.round(bytes / 4));
-  return contextOutput(buildRecallHint(cmd, outputId));
+  const entry = outputId !== null ? getBashOutput(outputId) : null;
+  if (outputId !== null && entry !== null) {
+    const bytes = entry.sizeBytes;
+    recordStat("bash_compress:recall", bytes, Math.round(bytes / 4));
+    return contextOutput(buildRecallHint(cmd, outputId));
+  }
+  return maybeCompressRewrite(event, rawCmd, cmd) ?? passOutput();
 }
 registerHook("pre_tool_use", preBashHandler, { toolName: "Bash" });
 var MIN_CACHE_BYTES = 512;
@@ -16438,15 +17954,57 @@ function extractBashOutput(raw) {
   }
   return "";
 }
+function extractExitCode(raw) {
+  const resp = raw["tool_response"];
+  if (resp !== null && typeof resp === "object") {
+    const r = resp;
+    for (const key of ["exit_code", "exitCode", "returncode", "code"]) {
+      if (typeof r[key] === "number") return r[key];
+    }
+  }
+  return null;
+}
+var GH_SECURITY_PATHS = ["/security_advisories", "/advisories", "security_events"];
+var GH_SCOPE_PHRASES = ["Must have push access", "Resource not accessible by integration", "Must be an admin"];
+function buildGhApiHint(cmd, stdout, exitCode) {
+  if (stdout === "" || !cmd.startsWith("gh api")) return null;
+  const hints = [];
+  const isSecurityPath = GH_SECURITY_PATHS.some((p) => cmd.includes(p));
+  const hasScopePhrase = GH_SCOPE_PHRASES.some((p) => stdout.includes(p));
+  const failedSecurityCall = exitCode !== null && exitCode !== 0 && isSecurityPath;
+  if (hasScopePhrase || failedSecurityCall) {
+    hints.push("[token-goat] GitHub API scope issue: try gh auth refresh -s security_events");
+  }
+  const trimmed = stdout.trimStart();
+  if (trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(stdout);
+      if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+        const keyCount = Object.keys(parsed).length;
+        if (keyCount >= 15) {
+          hints.push(`[token-goat] Large API response (${keyCount} keys). Filter with --jq '.key1,.key2' to reduce tokens.`);
+        }
+      }
+    } catch {
+    }
+  }
+  return hints.length > 0 ? hints.join(" ") : null;
+}
 async function postBashHandler(event) {
   try {
-    const rawCmd = extractCommand(event);
-    if (rawCmd === void 0) return passOutput();
+    const rawCmdRaw = extractCommand(event);
+    if (rawCmdRaw === void 0) return passOutput();
+    const rawCmd = unwrapCompressCommand(rawCmdRaw) ?? rawCmdRaw;
     const cmd = stripCdPrefix(rawCmd);
     const curlDl = extractCurlDownload(cmd);
     if (curlDl !== null) {
       recordCurlDownload(curlDl.url, curlDl.outputPath);
     }
+    const ghHint = buildGhApiHint(cmd, extractBashOutput(event.raw), extractExitCode(event.raw));
+    if (ghHint !== null) {
+      recordStat("session_hint", 0, 0);
+      return contextOutput(ghHint);
+    }
     const isMonitoring = getMonitoringRecallHint(cmd) !== null;
     if (!isMonitoring && !isBuildCommand(cmd) && !isCurlGetCommand(cmd)) return passOutput();
     const output = extractBashOutput(event.raw);
@@ -16464,8 +18022,8 @@ registerHook("post_tool_use", postBashHandler, { toolName: "Bash" });
 
 // src/image_shrink.ts
 init_define_import_meta_env();
-import * as fs11 from "node:fs";
-import * as path13 from "node:path";
+import * as fs13 from "node:fs";
+import * as path16 from "node:path";
 var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".png",
   ".jpg",
@@ -16492,7 +18050,7 @@ async function loadSharp() {
   return _sharpCache;
 }
 function isImagePath(p) {
-  return IMAGE_EXTENSIONS.has(path13.extname(p).toLowerCase());
+  return IMAGE_EXTENSIONS.has(path16.extname(p).toLowerCase());
 }
 async function shrinkImage(input, opts) {
   const maxDimension = opts?.maxDimension ?? DEFAULT_MAX_DIMENSION;
@@ -16524,7 +18082,7 @@ async function shrinkImage(input, opts) {
 }
 function statSize2(absPath) {
   try {
-    const st = fs11.statSync(absPath);
+    const st = fs13.statSync(absPath);
     return st.isFile() ? st.size : null;
   } catch {
     return null;
@@ -16538,7 +18096,7 @@ async function preReadImageHandler(event) {
   if (size === null || size < DEFAULT_SIZE_THRESHOLD_BYTES) return passOutput();
   let input;
   try {
-    input = fs11.readFileSync(filePath);
+    input = fs13.readFileSync(filePath);
   } catch {
     return passOutput();
   }
@@ -16547,7 +18105,7 @@ async function preReadImageHandler(event) {
   const saved = result.originalBytes - result.shrunkBytes;
   const pct = Math.round(saved / result.originalBytes * 100);
   const dataUrl = `data:image/${result.format};base64,${result.data.toString("base64")}`;
-  const summary = `token-goat shrank ${path13.basename(filePath)}: ${Math.round(result.originalBytes / 1024)}kb -> ${Math.round(result.shrunkBytes / 1024)}kb (${pct}% smaller, ${result.width}x${result.height} ${result.format}).`;
+  const summary = `token-goat shrank ${path16.basename(filePath)}: ${Math.round(result.originalBytes / 1024)}kb -> ${Math.round(result.shrunkBytes / 1024)}kb (${pct}% smaller, ${result.width}x${result.height} ${result.format}).`;
   return contextOutput(`${summary}
 ${dataUrl}`);
 }
@@ -16556,7 +18114,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((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const chunks = [];
     let settled = false;
     const finish = (fn) => {
@@ -16582,7 +18140,7 @@ function readStdinJson(timeoutMs = DEFAULT_STDIN_TIMEOUT_MS) {
           return;
         }
         try {
-          resolve7(JSON.parse(text));
+          resolve8(JSON.parse(text));
         } catch (err2) {
           reject(err2 instanceof Error ? err2 : new Error(String(err2)));
         }
@@ -16617,7 +18175,15 @@ async function relay(eventName) {
     }
     const payload = await readStdinJson();
     const event = buildEvent(eventName, payload);
+    try {
+      loadSessionState(event.sessionId);
+    } catch {
+    }
     const output = await runHook(event);
+    try {
+      saveSessionState(event.sessionId);
+    } catch {
+    }
     process.stdout.write(serializeOutput(output));
   } catch {
     process.stdout.write("{}");
@@ -16626,9 +18192,9 @@ async function relay(eventName) {
 
 // src/install.ts
 init_define_import_meta_env();
-import * as fs12 from "node:fs";
-import * as os3 from "node:os";
-import * as path14 from "node:path";
+import * as fs14 from "node:fs";
+import * as os5 from "node:os";
+import * as path17 from "node:path";
 var HOOK_EVENT_MAP = [
   ["PreToolUse", "pre_tool_use"],
   ["PostToolUse", "post_tool_use"],
@@ -16639,13 +18205,13 @@ function hookCommand(eventArg) {
   return `token-goat hook ${eventArg}`;
 }
 function settingsPath(scope) {
-  const base = scope === "user" ? path14.join(os3.homedir(), ".claude") : path14.join(process.cwd(), ".claude");
-  return path14.join(base, "settings.json");
+  const base = scope === "user" ? path17.join(os5.homedir(), ".claude") : path17.join(process.cwd(), ".claude");
+  return path17.join(base, "settings.json");
 }
 function readSettings(p) {
   let raw;
   try {
-    raw = fs12.readFileSync(p, "utf8");
+    raw = fs14.readFileSync(p, "utf8");
   } catch {
     return {};
   }
@@ -16685,7 +18251,7 @@ function installHooks(scope = "user") {
     return { scope, settingsPath: p, alreadyInstalled: true };
   }
   settings.hooks = hooks;
-  fs12.mkdirSync(path14.dirname(p), { recursive: true });
+  fs14.mkdirSync(path17.dirname(p), { recursive: true });
   atomicWriteText(p, `${JSON.stringify(settings, null, 2)}
 `);
   return { scope, settingsPath: p, alreadyInstalled: false };
@@ -16724,7 +18290,7 @@ function uninstallHooks(scope = "user") {
   } else {
     settings.hooks = hooks;
   }
-  fs12.mkdirSync(path14.dirname(p), { recursive: true });
+  fs14.mkdirSync(path17.dirname(p), { recursive: true });
   atomicWriteText(p, `${JSON.stringify(settings, null, 2)}
 `);
   return true;
@@ -16733,21 +18299,21 @@ function uninstallHooks(scope = "user") {
 // src/worker.ts
 init_define_import_meta_env();
 import { spawn } from "node:child_process";
-import * as fs13 from "node:fs";
-import * as path15 from "node:path";
+import * as fs15 from "node:fs";
+import * as path18 from "node:path";
 import { Worker, isMainThread, parentPort, workerData } from "node:worker_threads";
 import { fileURLToPath } from "node:url";
 var DEFAULT_POLL_INTERVAL_MS = 2e3;
 function dirtyQueuePathFor(dir) {
-  return path15.join(dir, "queue", "dirty.txt");
+  return path18.join(dir, "queue", "dirty.txt");
 }
 function workerPidPath(dir = dataDir()) {
-  return path15.join(dir, "worker.pid");
+  return path18.join(dir, "worker.pid");
 }
 function getDirtyPathsFor(dir) {
   let raw;
   try {
-    raw = fs13.readFileSync(dirtyQueuePathFor(dir), "utf8");
+    raw = fs15.readFileSync(dirtyQueuePathFor(dir), "utf8");
   } catch {
     return [];
   }
@@ -16755,15 +18321,19 @@ function getDirtyPathsFor(dir) {
   const out2 = [];
   for (const line of raw.split("\n")) {
     const trimmed = line.trim();
-    if (trimmed === "" || seen.has(trimmed)) continue;
-    seen.add(trimmed);
+    if (trimmed === "") continue;
+    const normalized = normalizePath(trimmed);
+    const caseInsensitiveFs = process.platform === "win32" || process.platform === "darwin";
+    const dedupeKey = caseInsensitiveFs ? normalized.toLowerCase() : normalized;
+    if (seen.has(dedupeKey)) continue;
+    seen.add(dedupeKey);
     out2.push(trimmed);
   }
   return out2;
 }
 function clearDirtyQueueFor(dir) {
   try {
-    fs13.rmSync(dirtyQueuePathFor(dir), { force: true });
+    fs15.rmSync(dirtyQueuePathFor(dir), { force: true });
   } catch {
   }
 }
@@ -16778,7 +18348,7 @@ function makeIndexer(dbPath) {
 function processDirtyBatch(paths, index = makeIndexer(globalDbPath())) {
   let indexed = 0;
   for (const p of paths) {
-    if (!p || !fs13.existsSync(p)) continue;
+    if (!p || !fs15.existsSync(p)) continue;
     const sha = fingerprintFile(p);
     if (sha === null) continue;
     index(p, sha);
@@ -16789,7 +18359,7 @@ function processDirtyBatch(paths, index = makeIndexer(globalDbPath())) {
 function drainOnce(dir, index) {
   const paths = getDirtyPathsFor(dir);
   if (paths.length === 0) return 0;
-  const indexed = processDirtyBatch(paths, index ?? makeIndexer(path15.join(dir, "global.db")));
+  const indexed = processDirtyBatch(paths, index ?? makeIndexer(path18.join(dir, "global.db")));
   clearDirtyQueueFor(dir);
   return indexed;
 }
@@ -16803,7 +18373,7 @@ function pidAlive(pid) {
 }
 function readPidFile(dir) {
   try {
-    const raw = fs13.readFileSync(workerPidPath(dir), "utf8").trim();
+    const raw = fs15.readFileSync(workerPidPath(dir), "utf8").trim();
     if (!/^\d+$/.test(raw)) return null;
     return parseInt(raw, 10);
   } catch {
@@ -16826,7 +18396,7 @@ function stopWorker(dir = dataDir()) {
     }
   }
   try {
-    fs13.rmSync(workerPidPath(dir), { force: true });
+    fs15.rmSync(workerPidPath(dir), { force: true });
   } catch {
   }
   return alive;
@@ -16835,9 +18405,9 @@ function startDetachedWorker(opts) {
   const pollIntervalMs = opts?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
   const dir = opts?.dataDir ?? dataDir();
   try {
-    fs13.mkdirSync(dir, { recursive: true });
+    fs15.mkdirSync(dir, { recursive: true });
   } catch (e) {
-    if (e.code !== "EEXIST" || !fs13.existsSync(dir)) throw e;
+    if (e.code !== "EEXIST" || !fs15.existsSync(dir)) throw e;
   }
   const child = spawn(
     process.execPath,
@@ -16857,7 +18427,7 @@ function startDetachedWorker(opts) {
   if (pid === void 0) {
     throw new Error("startDetachedWorker: spawn produced no pid");
   }
-  fs13.writeFileSync(workerPidPath(dir), `${pid}
+  fs15.writeFileSync(workerPidPath(dir), `${pid}
 `);
   child.unref();
   return pid;
@@ -16869,7 +18439,7 @@ async function runWorkerLoop(dir, pollIntervalMs, shouldStop = () => false) {
     } catch {
     }
     if (shouldStop()) break;
-    await new Promise((resolve7) => setTimeout(resolve7, pollIntervalMs));
+    await new Promise((resolve8) => setTimeout(resolve8, pollIntervalMs));
   }
 }
 function workerEntry() {
@@ -16898,42 +18468,131 @@ function workerEntry() {
 }
 workerEntry();
 
-// src/web_cache.ts
+// src/bash_runner.ts
 init_define_import_meta_env();
-var _byId2 = /* @__PURE__ */ new Map();
-var _urlIndex = /* @__PURE__ */ new Map();
-function cacheIdForUrl(url) {
-  return shortFingerprint(url);
+import { spawnSync as spawnSync2 } from "node:child_process";
+import * as os6 from "node:os";
+var DEFAULT_TIMEOUT_SECONDS = 600;
+var MAX_CAPTURE_BYTES = 32 * 1024 * 1024;
+var MIN_RECORD_STAT_BYTES = 32;
+function resolveFilter(command, filterName) {
+  if (filterName) {
+    const named = filterByName(filterName);
+    if (named !== null) return named;
+  }
+  let argv;
+  try {
+    argv = shlexSplit(command);
+  } catch {
+    return null;
+  }
+  return selectFilter(argv);
 }
-function storeWebOutput(url, content) {
-  const cacheId = cacheIdForUrl(url);
-  _byId2.set(cacheId, content);
-  _urlIndex.set(url, cacheId);
-  return cacheId;
+function signalExitCode(signal) {
+  const num = os6.constants.signals[signal];
+  return 128 + (num ?? 0);
 }
-function getWebOutput(cacheId) {
-  return _byId2.get(cacheId) ?? null;
+function resolveProfile(explicit) {
+  if (explicit) return explicit;
+  try {
+    const p = loadConfig().compression.profile;
+    return p && p !== "auto" ? p : "balanced";
+  } catch {
+    return "balanced";
+  }
 }
-function getWebOutputByUrl(url) {
-  const cacheId = _urlIndex.get(url);
-  if (cacheId === void 0) return null;
-  const content = _byId2.get(cacheId);
-  if (content === void 0) return null;
-  return { cacheId, content };
+function run(command, opts = {}) {
+  const timeout = opts.timeout ?? DEFAULT_TIMEOUT_SECONDS;
+  const filter = resolveFilter(command, opts.filterName);
+  if (filter === null) {
+    return passthrough(command, timeout, opts.cwd, opts.env);
+  }
+  return wrapAndCompress(command, filter, timeout, resolveProfile(opts.compressionProfile), opts);
+}
+function runRaw(command, timeout = DEFAULT_TIMEOUT_SECONDS) {
+  return passthrough(command, timeout, void 0, void 0);
+}
+function passthrough(command, timeout, cwd, env) {
+  const result = spawnSync2(command, {
+    shell: true,
+    stdio: "inherit",
+    timeout: timeout * 1e3,
+    cwd,
+    env
+  });
+  if (isTimeout(result.error)) return 124;
+  if (result.status !== null) return result.status;
+  if (result.signal) return signalExitCode(result.signal);
+  return 0;
+}
+function isTimeout(error) {
+  return !!error && error.code === "ETIMEDOUT";
+}
+function decode(buf) {
+  if (buf == null) return "";
+  return typeof buf === "string" ? buf : buf.toString("utf8");
+}
+function wrapAndCompress(command, filter, timeout, profile, opts) {
+  const writeStdout = opts.writeStdout ?? ((s) => process.stdout.write(s));
+  const start = Date.now();
+  const result = spawnSync2(command, {
+    shell: true,
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: timeout * 1e3,
+    maxBuffer: MAX_CAPTURE_BYTES,
+    cwd: opts.cwd,
+    env: opts.env
+  });
+  const timedOut = isTimeout(result.error);
+  const overflowed = !!result.error && result.error.code === "ENOBUFS";
+  let stdoutText = decode(result.stdout);
+  let stderrText = decode(result.stderr);
+  if (overflowed) {
+    stdoutText += `
+[token-goat: capture capped at ${MAX_CAPTURE_BYTES / (1024 * 1024)} MiB]`;
+  }
+  let exitCode;
+  if (timedOut) {
+    exitCode = 124;
+    stderrText = (stderrText ? stderrText + "\n" : "") + `[token-goat: command exceeded ${timeout}s timeout and was killed]`;
+  } else if (result.status !== null) {
+    exitCode = result.status;
+  } else if (result.signal) {
+    exitCode = signalExitCode(result.signal);
+  } else {
+    exitCode = 0;
+  }
+  let argv;
+  try {
+    argv = shlexSplit(command);
+  } catch {
+    argv = [command];
+  }
+  const compressed = compressOutput(filter, stdoutText, stderrText, exitCode, argv, {
+    compressionProfile: profile
+  });
+  let text = compressed.text;
+  const maxTokens = opts.maxTokens ?? 0;
+  if (maxTokens > 0) text = capTokens(text, maxTokens);
+  const marker = compressed.withMarker().slice(compressed.text.length);
+  const body = text + marker;
+  writeStdout(body.endsWith("\n") ? body : body + "\n");
+  recordSavings(compressed, Date.now() - start);
+  return exitCode;
+}
+function recordSavings(result, _elapsedMs) {
+  if (result.bytesSaved < MIN_RECORD_STAT_BYTES) return;
+  recordStat(`bash_compress:${result.filterName}`, result.bytesSaved, result.tokensSaved);
 }
-registerReset(() => {
-  _byId2 = /* @__PURE__ */ new Map();
-  _urlIndex = /* @__PURE__ */ new Map();
-});
 
 // src/read_commands.ts
 init_define_import_meta_env();
-import * as fs14 from "node:fs";
-import * as path16 from "node:path";
+import * as fs16 from "node:fs";
+import * as path19 from "node:path";
 
 // src/section_reader.ts
 init_define_import_meta_env();
-import { readFileSync as readFileSync10 } from "node:fs";
+import { readFileSync as readFileSync12 } from "node:fs";
 function parseHeadingSpec(spec) {
   const m = /^(.*?)#(\d+)$/.exec(spec);
   if (m !== null && m[1] !== void 0 && m[2] !== void 0) {
@@ -17027,7 +18686,7 @@ function sectionEndIndex(headers, headerPos, totalLines) {
 function readSection(filePath, headingSpec) {
   let text;
   try {
-    text = readFileSync10(filePath, "utf-8");
+    text = readFileSync12(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -17069,7 +18728,7 @@ function readSection(filePath, headingSpec) {
 function listAllSections(filePath) {
   let text;
   try {
-    text = readFileSync10(filePath, "utf-8");
+    text = readFileSync12(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -17083,7 +18742,7 @@ var DIDYOUMEAN_LIMIT = 5;
 var GREP_MAX_LINES = 200;
 function fileExists(p) {
   try {
-    fs14.statSync(p);
+    fs16.statSync(p);
     return true;
   } catch {
     return false;
@@ -17091,7 +18750,7 @@ function fileExists(p) {
 }
 function readFileText(p) {
   try {
-    return fs14.readFileSync(p, "utf-8");
+    return fs16.readFileSync(p, "utf-8");
   } catch {
     return null;
   }
@@ -17385,7 +19044,7 @@ function runGrep(opts) {
   const hits = [];
   function searchFile(filePath) {
     try {
-      const text = fs14.readFileSync(filePath, "utf-8");
+      const text = fs16.readFileSync(filePath, "utf-8");
       const lines = text.split("\n");
       lines.forEach((lineText, idx) => {
         if (regex.test(lineText)) {
@@ -17397,10 +19056,10 @@ function runGrep(opts) {
   }
   function searchDir(dir) {
     try {
-      for (const entry of fs14.readdirSync(dir)) {
+      for (const entry of fs16.readdirSync(dir)) {
         if (entry.startsWith(".")) continue;
-        const full = path16.join(dir, entry);
-        const stat4 = fs14.statSync(full);
+        const full = path19.join(dir, entry);
+        const stat4 = fs16.statSync(full);
         if (stat4.isDirectory()) {
           if (opts.recursive !== false) searchDir(full);
         } else {
@@ -17414,7 +19073,7 @@ function runGrep(opts) {
     emitErr(`Path not found: ${searchPath}`);
     return 1;
   }
-  const stat3 = fs14.statSync(searchPath);
+  const stat3 = fs16.statSync(searchPath);
   if (stat3.isDirectory()) {
     searchDir(searchPath);
   } else {
@@ -17443,7 +19102,7 @@ function runConfigGet(opts) {
     emitErr(`Could not read: ${opts.file}`);
     return 1;
   }
-  const ext = path16.extname(opts.file).toLowerCase();
+  const ext = path19.extname(opts.file).toLowerCase();
   if (ext === ".json") {
     try {
       let obj = JSON.parse(text);
@@ -17465,10 +19124,22 @@ function runConfigGet(opts) {
       return 1;
     }
   }
-  const leafKey = opts.key.split(".").at(-1) ?? opts.key;
+  const keyParts = opts.key.split(".");
+  const leafKey = keyParts.at(-1) ?? opts.key;
+  const sectionPath = keyParts.length > 1 ? keyParts.slice(0, -1).join(".") : null;
   const lines = text.split("\n");
+  let currentSection = "";
   for (const line of lines) {
     const trimmed = line.trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      currentSection = trimmed.slice(1, -1);
+      continue;
+    }
+    if (sectionPath !== null) {
+      if (currentSection !== sectionPath) {
+        continue;
+      }
+    }
     if (trimmed.startsWith(`${leafKey} =`) || trimmed.startsWith(`${leafKey}=`)) {
       const eqIdx = trimmed.indexOf("=");
       emit(trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, ""));
@@ -17524,7 +19195,7 @@ function runExports(opts) {
       names.push(s.name);
     }
   }
-  const ext = path16.extname(opts.file).toLowerCase();
+  const ext = path19.extname(opts.file).toLowerCase();
   const text = readFileText(opts.file);
   if (text !== null) {
     if (ext === ".go") {
@@ -17636,7 +19307,7 @@ function runImports(opts) {
     emitErr(`Could not read: ${opts.file}`);
     return 1;
   }
-  const imports = extractImports(text, path16.extname(opts.file));
+  const imports = extractImports(text, path19.extname(opts.file));
   if (imports.length === 0) {
     emit(`No imports found in '${opts.file}'`);
     return 0;
@@ -17653,8 +19324,8 @@ function runImports(opts) {
 
 // src/skill_cache.ts
 init_define_import_meta_env();
-import * as fs15 from "fs/promises";
-import { resolve as resolve5 } from "path";
+import * as fs17 from "fs/promises";
+import { resolve as resolve6 } from "path";
 var COMPACT_END_MARKER = "<!-- COMPACT_END -->";
 var _skillOutputsDirOverride = null;
 registerReset(() => {
@@ -17662,11 +19333,11 @@ registerReset(() => {
 });
 function skillOutputsDir() {
   if (_skillOutputsDirOverride) return _skillOutputsDirOverride;
-  return resolve5(dataDir(), "skills");
+  return resolve6(dataDir(), "skills");
 }
 async function ensureSkillsDir() {
   try {
-    await fs15.mkdir(skillOutputsDir(), { recursive: true });
+    await fs17.mkdir(skillOutputsDir(), { recursive: true });
   } catch {
   }
 }
@@ -17685,6 +19356,9 @@ function safeSkillName(skillName) {
   if (!/^[A-Za-z0-9_:-]+$/.test(skillName)) return null;
   return skillName.replace(/[^a-zA-Z0-9_:-]/g, "_");
 }
+function sanitizeSkillId(name) {
+  return name.replace(/:/g, "_");
+}
 function extractCompactFromMarker(body) {
   if (!body || !body.includes(COMPACT_END_MARKER)) {
     return null;
@@ -17708,14 +19382,14 @@ function extractCompactFromMarker(body) {
 async function listOutputs() {
   try {
     const dir = skillOutputsDir();
-    const entries = await fs15.readdir(dir, { withFileTypes: true });
+    const entries = await fs17.readdir(dir, { withFileTypes: true });
     const metas = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".meta")) {
         continue;
       }
       try {
-        const content = await fs15.readFile(resolve5(dir, entry.name), "utf-8");
+        const content = await fs17.readFile(resolve6(dir, entry.name), "utf-8");
         const meta = JSON.parse(content);
         metas.push(meta);
       } catch {
@@ -17733,14 +19407,14 @@ async function storeCompact(sessionId, skillName, compactText, sourceSha) {
     const name = safeSkillName(skillName);
     if (!name) return;
     const safeSession = safeSessionFragment(sessionId);
-    const fileId = `${safeSession}-${name}-compact`;
+    const fileId = `${safeSession}-${sanitizeSkillId(name)}-compact`;
     const dir = skillOutputsDir();
     let text = compactText;
     if (sourceSha) {
       text = `<!-- source_sha: ${sourceSha.slice(0, 12)} -->
 ${text}`;
     }
-    await atomicWriteText(resolve5(dir, fileId), text);
+    await atomicWriteText(resolve6(dir, fileId), text);
   } catch {
   }
 }
@@ -17757,16 +19431,16 @@ async function listSkills(sessionId) {
       seen.add(meta.skillName);
       const dir = skillOutputsDir();
       const safeSession = safeSessionFragment(meta.outputId.split("-")[0]);
-      const compactFileId = `${safeSession}-${meta.skillName.replace(":", "_")}-compact`;
+      const compactFileId = `${safeSession}-${sanitizeSkillId(meta.skillName)}-compact`;
       let compactLen = 0;
       try {
-        const stat3 = await fs15.stat(resolve5(dir, compactFileId));
+        const stat3 = await fs17.stat(resolve6(dir, compactFileId));
         compactLen = stat3.size;
       } catch {
         compactLen = 0;
       }
       const hasMarker = extractCompactFromMarker(
-        await fs15.readFile(resolve5(dir, `${meta.outputId}.txt`), "utf-8").catch(() => "")
+        await fs17.readFile(resolve6(dir, `${meta.outputId}.txt`), "utf-8").catch(() => "")
       ) !== null;
       results.push({
         name: meta.skillName,
@@ -17798,9 +19472,9 @@ async function getSkillFilePath(skillName) {
 
 // src/cli_doctor.ts
 init_define_import_meta_env();
-import * as fs16 from "fs";
-import * as path17 from "path";
-import { execSync, spawnSync as spawnSync2 } from "child_process";
+import * as fs18 from "fs";
+import * as path20 from "path";
+import { execSync, spawnSync as spawnSync3 } from "child_process";
 function checkWorkerRunning() {
   try {
     const output = execSync("tasklist", { encoding: "utf-8" });
@@ -17810,8 +19484,8 @@ function checkWorkerRunning() {
   }
 }
 function checkDbExists(dataDir2) {
-  const dbPath = path17.join(dataDir2, "index.db");
-  if (!fs16.existsSync(dbPath)) {
+  const dbPath = path20.join(dataDir2, "index.db");
+  if (!fs18.existsSync(dbPath)) {
     return {
       name: "Database",
       status: "warn",
@@ -17821,7 +19495,7 @@ function checkDbExists(dataDir2) {
   return {
     name: "Database",
     status: "ok",
-    message: `index.db exists (${Math.round(fs16.statSync(dbPath).size / 1024)} KB)`
+    message: `index.db exists (${Math.round(fs18.statSync(dbPath).size / 1024)} KB)`
   };
 }
 function checkInstall() {
@@ -17841,7 +19515,7 @@ function checkInstall() {
   }
 }
 function checkConfigValid(configPath2) {
-  if (!fs16.existsSync(configPath2)) {
+  if (!fs18.existsSync(configPath2)) {
     return {
       name: "Config",
       status: "warn",
@@ -17849,7 +19523,7 @@ function checkConfigValid(configPath2) {
     };
   }
   try {
-    const content = fs16.readFileSync(configPath2, "utf-8");
+    const content = fs18.readFileSync(configPath2, "utf-8");
     JSON.parse(content);
     return {
       name: "Config",
@@ -17866,7 +19540,7 @@ function checkConfigValid(configPath2) {
 }
 function checkDiskSpace(dataDir2) {
   try {
-    const result = spawnSync2("df", ["-h", dataDir2], { encoding: "utf-8" });
+    const result = spawnSync3("df", ["-h", dataDir2], { encoding: "utf-8" });
     const stdout = typeof result.stdout === "string" ? result.stdout : "";
     if (result.error !== void 0 || result.status !== 0 || !stdout) {
       return { name: "Disk Space", status: "warn", message: "could not determine" };
@@ -17887,9 +19561,9 @@ function runDoctor(dataDir2, configPath2) {
   results.push(checkInstall());
   results.push(checkWorkerRunning() ? { name: "Worker", status: "ok", message: "running" } : { name: "Worker", status: "warn", message: "not running" });
   const homeDir = process.env["HOME"] || process.env["USERPROFILE"] || "~";
-  const actualDataDir = dataDir2 || path17.join(homeDir, ".token-goat");
+  const actualDataDir = dataDir2 || path20.join(homeDir, ".token-goat");
   results.push(checkDbExists(actualDataDir));
-  const actualConfigPath = configPath2 || path17.join(actualDataDir, "config.json");
+  const actualConfigPath = configPath2 || path20.join(actualDataDir, "config.json");
   results.push(checkConfigValid(actualConfigPath));
   results.push(checkDiskSpace(actualDataDir));
   return results;
@@ -18042,11 +19716,16 @@ function cmdSemantic(query, opts) {
 ${previewLines(s.body, 3)}`);
   out(blocks.join("\n\n"));
 }
-function cmdIndex(pathArg) {
+function cmdIndex(pathArg, opts = {}) {
   const root = pathArg ?? process.cwd();
-  const files = getTrackedFiles(root);
+  let files = getTrackedFiles(root);
   if (files.length === 0) {
-    throw new CliError(`no tracked files found under '${root}' (is it a git repo?)`);
+    if (opts.walk !== true) {
+      throw new CliError(
+        `no tracked files found under '${root}' (is it a git repo?). Pass --walk to index a non-git folder.`
+      );
+    }
+    files = collectWalkIndexFiles(root);
   }
   let indexed = 0;
   for (const f of files) {
@@ -18149,11 +19828,11 @@ function cmdBashOutput(id, opts) {
     }
     let content;
     try {
-      const st = fs17.statSync(opts.file);
+      const st = fs19.statSync(opts.file);
       if (st.isFIFO() || st.isSocket()) {
         throw new CliError(`--file '${opts.file}' is a special file (FIFO or socket) \u2014 only regular files are supported`);
       }
-      content = fs17.readFileSync(opts.file, "utf-8");
+      content = fs19.readFileSync(opts.file, "utf-8");
     } catch (e) {
       if (e instanceof CliError) throw e;
       throw new CliError(`cannot read file: ${opts.file}`);
@@ -18188,12 +19867,34 @@ function runExit(fn) {
     process.exitCode = 1;
   }
 }
+function cmdCompress(opts) {
+  try {
+    if (opts.compress === false) {
+      process.exitCode = runRaw(opts.cmd, parseTimeout(opts.timeout));
+      return;
+    }
+    const maxTokens = opts.maxTokens ? parseInt(opts.maxTokens, 10) || 0 : 0;
+    process.exitCode = run(opts.cmd, {
+      filterName: opts.filter,
+      timeout: parseTimeout(opts.timeout),
+      maxTokens,
+      ...opts.profile !== void 0 ? { compressionProfile: opts.profile } : {}
+    });
+  } catch (e) {
+    err(`token-goat: ${extractErrorMessage(e)}`);
+    process.exitCode = 1;
+  }
+}
+function parseTimeout(raw) {
+  const sec = raw ? parseInt(raw, 10) : 0;
+  return Number.isFinite(sec) && sec > 0 ? sec : DEFAULT_TIMEOUT_SECONDS;
+}
 async function cmdSkillBody(name, opts) {
   const filePath = await getSkillFilePath(name);
   if (filePath === null) {
     throw new CliError(`skill '${name}' not found`);
   }
-  const body = fs17.readFileSync(filePath, "utf-8");
+  const body = fs19.readFileSync(filePath, "utf-8");
   if (opts.compact === true) {
     const lines = body.split("\n");
     const end = lines.findIndex((l) => l.includes("COMPACT_END"));
@@ -18211,7 +19912,7 @@ async function cmdSkillCompact(name) {
   if (filePath === null) {
     throw new CliError(`skill '${name}' not found`);
   }
-  const body = fs17.readFileSync(filePath, "utf-8");
+  const body = fs19.readFileSync(filePath, "utf-8");
   const sessionFiles = getSessionFiles();
   const sessionId = Array.from(sessionFiles.keys())[0] ?? "default";
   await storeCompact(sessionId, name, body);
@@ -18252,7 +19953,7 @@ async function cmdSkillSize(opts) {
 }
 function atomicWriteBuffer(dest, data) {
   try {
-    if (fs17.statSync(dest).isDirectory()) {
+    if (fs19.statSync(dest).isDirectory()) {
       const e = Object.assign(new Error(`EISDIR: illegal operation on a directory, open '${dest}'`), { code: "EISDIR", path: dest });
       throw e;
     }
@@ -18260,16 +19961,16 @@ function atomicWriteBuffer(dest, data) {
     if (e.code !== "ENOENT") throw e;
   }
   const rnd = Math.random().toString(36).slice(2, 8);
-  const tmp = path18.join(path18.dirname(path18.resolve(dest)), `.tmp.${process.pid}.${rnd}`);
+  const tmp = path21.join(path21.dirname(path21.resolve(dest)), `.tmp.${process.pid}.${rnd}`);
   try {
-    fs17.writeFileSync(tmp, data, { mode: 384 });
+    fs19.writeFileSync(tmp, data, { mode: 384 });
     try {
-      fs17.renameSync(tmp, dest);
+      fs19.renameSync(tmp, dest);
     } catch (e) {
       if (e.code === "EXDEV") {
-        fs17.copyFileSync(tmp, dest);
+        fs19.copyFileSync(tmp, dest);
         try {
-          fs17.unlinkSync(tmp);
+          fs19.unlinkSync(tmp);
         } catch (ue) {
           process.stderr.write(`token-goat write-file: warning: could not remove temp file ${tmp}: ${ue.message}
 `);
@@ -18280,7 +19981,7 @@ function atomicWriteBuffer(dest, data) {
     }
   } catch (e) {
     try {
-      fs17.unlinkSync(tmp);
+      fs19.unlinkSync(tmp);
     } catch {
     }
     throw e;
@@ -18290,9 +19991,9 @@ function mapFsError(e, src, dest) {
   const fe = e;
   if (fe.code === "ENOENT") {
     const errPath = fe.path ?? "";
-    const isSource = src !== void 0 && path18.resolve(errPath) === path18.resolve(src);
+    const isSource = src !== void 0 && path21.resolve(errPath) === path21.resolve(src);
     if (isSource) throw new CliError(`source file not found: ${src}`);
-    const destDir = dest ? path18.dirname(path18.resolve(dest)) : path18.dirname(path18.resolve(errPath || "."));
+    const destDir = dest ? path21.dirname(path21.resolve(dest)) : path21.dirname(path21.resolve(errPath || "."));
     throw new CliError(`destination directory does not exist: ${destDir}`);
   }
   if (fe.code === "ENOTDIR") {
@@ -18300,7 +20001,7 @@ function mapFsError(e, src, dest) {
   }
   if (fe.code === "EISDIR") {
     const errPath = fe.path ?? "";
-    const isSource = src !== void 0 && (errPath === "" || path18.resolve(errPath) === path18.resolve(src));
+    const isSource = src !== void 0 && (errPath === "" || path21.resolve(errPath) === path21.resolve(src));
     if (isSource) throw new CliError(`source is a directory, not a file: ${src}`);
     throw new CliError(`destination is a directory, not a file: ${dest ?? (errPath || "(unknown)")}`);
   }
@@ -18366,7 +20067,7 @@ function cmdWriteFile(dest, opts) {
     throw new CliError("destination path contains a null byte");
   }
   if (isWindows()) {
-    const base = path18.basename(dest);
+    const base = path21.basename(dest);
     const stem = base.replace(/\.[^.]*$/, "").toUpperCase();
     if (WIN_RESERVED.has(stem)) {
       throw new CliError(`destination '${base}' is a reserved Windows device name`);
@@ -18389,7 +20090,7 @@ function cmdWriteFile(dest, opts) {
       throw new CliError("--from /dev/stdin requires piped input; use piped stdin mode or --b64 for interactive use");
     }
     try {
-      const st = fs17.statSync(opts.from);
+      const st = fs19.statSync(opts.from);
       if (st.isFIFO() || st.isSocket()) {
         throw new CliError(`--from '${opts.from}' is a special file (FIFO or socket) \u2014 only regular files are supported`);
       }
@@ -18401,7 +20102,7 @@ function cmdWriteFile(dest, opts) {
       if (st.size > maxFromBytes) {
         throw new CliError(`--from source exceeds size limit (${Math.round(st.size / 1024 / 1024)} MB); set TOKEN_GOAT_MAX_STDIN_MB to override`);
       }
-      atomicWriteBuffer(dest, fs17.readFileSync(opts.from));
+      atomicWriteBuffer(dest, fs19.readFileSync(opts.from));
     } catch (e) {
       if (e instanceof CliError) throw e;
       mapFsError(e, opts.from, dest);
@@ -18443,7 +20144,7 @@ function cmdWriteFile(dest, opts) {
     throw new CliError(`TOKEN_GOAT_MAX_STDIN_MB must be a positive integer; got '${process.env["TOKEN_GOAT_MAX_STDIN_MB"] ?? ""}'`);
   }
   const maxBytes = maxMB * 1024 * 1024;
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const chunks = [];
     let totalBytes = 0;
     let settled = false;
@@ -18466,7 +20167,7 @@ function cmdWriteFile(dest, opts) {
       cleanup();
       try {
         atomicWriteBuffer(dest, Buffer.concat(chunks));
-        resolve7();
+        resolve8();
       } catch (e) {
         try {
           mapFsError(e, void 0, dest);
@@ -18569,7 +20270,7 @@ function buildProgram() {
       })
     )
   );
-  program2.command("index [path]").description("parse all git-tracked files and (re)build the symbol index").action(guard(cmdIndex));
+  program2.command("index [path]").description("parse all git-tracked files and (re)build the symbol index").option("--walk", "if not a git repo, index a bounded directory walk instead (skips .env / generated / oversized trees)").action(guard(cmdIndex));
   program2.command("map").description("project overview").option("-c, --compact", "compact, low-token summary").action(guard(cmdMap));
   program2.command("hook <event>").description("hook relay entrypoint (reads JSON on stdin)").action(guard(cmdHook));
   program2.command("install").description("install hooks into Claude Code settings").option("-p, --project", "install into project scope instead of user scope").action(guard(cmdInstall));
@@ -18624,6 +20325,7 @@ function buildProgram() {
   program2.command("config-get <file> <key>").description("read one value from a config file (TOML/JSON/YAML/INI)").action((file, key) => runExit(() => runConfigGet({ file, key })));
   program2.command("write-file <dest>").description("write exact bytes to a file \u2014 handles backticks, quotes, $vars, CRLF without escaping\n\nModes: --b64 PAYLOAD (base64), --from SOURCE (copy file), or piped stdin").option("--from <source>", "copy bytes from this source file instead of stdin/base64").option("--b64 <payload>", "decode base64 payload and write to dest").action(guard(cmdWriteFile));
   program2.command("gdrive-sections <file-id>").description("fetch and list sections from a public Google Doc").option("--heading <name>", "get content of one named section").action(guard(cmdGdriveSections));
+  program2.command("compress").description("run a shell command and emit a compressed view of its output").requiredOption("-c, --cmd <command>", "the shell command to run, as one string").option("-f, --filter <name>", "filter name (auto-detected from the command when omitted)").option("--timeout <seconds>", "wall-clock timeout in seconds (0 = built-in default)").option("--no-compress", "stream output raw without compression (debug the wrapper)").option("--profile <name>", "compression profile: aggressive | balanced | minimal").option("--max-tokens <n>", "post-compress token cap (0 = no cap)").action(cmdCompress);
   program2.command("version").description("print the token-goat version").action(
     guard(() => {
       out(VERSION);
@@ -18631,7 +20333,7 @@ function buildProgram() {
   );
   return program2;
 }
-async function run(argv = process.argv) {
+async function run2(argv = process.argv) {
   const program2 = buildProgram();
   program2.exitOverride();
   try {
@@ -18653,7 +20355,7 @@ async function run(argv = process.argv) {
 }
 
 // src/main.ts
-void run();
+void run2();
 /*! Bundled license information:
 
 smol-toml/dist/date.js: