token-goat 2.9.29 → 2.9.30

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

@@ -0,0 +1,134 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  VSCODE_TOOL_NAME_KEY,
+  getCwd
+} from "./token-goat-chunk-VPBBTSJR.mjs";
+import {
+  escapesOntoNetworkThroughLinks,
+  foldPathForContainment,
+  isInsideRoot
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  isUncOrDevicePath,
+  resolveIndexPath,
+  wslMountOfIndexKey
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/hint_suggestion_guard.ts
+init_define_import_meta_env();
+function looksLikeSuggestion(slice) {
+  return slice.includes('"');
+}
+var SAFE_OUTSIDE_QUOTES = /^[A-Za-z0-9 \t_./=:,@+-]*$/;
+var CONTROL_OR_BIDI = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F\u200E\u200F\u202A-\u202E\u2066-\u2069\u061C\u200B-\u200D\u2028\u2029\uFE00-\uFE0F]|[\u{E0000}-\u{E007F}]/u;
+function suggestionIsUnsafe(slice) {
+  if (slice.includes("$") || slice.includes("\n") || slice.includes("\r") || slice.includes("`")) return true;
+  if (CONTROL_OR_BIDI.test(slice)) return true;
+  const regions = slice.split('"');
+  if (regions.length % 2 === 0) return true;
+  for (let i = 2; i < regions.length; i += 2) {
+    if (!SAFE_OUTSIDE_QUOTES.test(regions[i] ?? "")) return true;
+  }
+  return false;
+}
+var OMITTED = "token-goat (command omitted: the path contains shell metacharacters)";
+function stripUnsafeSuggestions(text) {
+  if (!text.includes("token-goat ")) return text;
+  let out = "";
+  let at = 0;
+  for (; ; ) {
+    const start = text.indexOf("token-goat ", at);
+    if (start === -1) return out + text.slice(at);
+    const lineBreak = text.slice(start).search(/[\r\n]/);
+    const line = lineBreak === -1 ? text.slice(start) : text.slice(start, start + lineBreak);
+    const firstTick = line.indexOf("`");
+    const narrow = firstTick === -1 ? line : line.slice(0, firstTick);
+    out += text.slice(at, start);
+    if (!looksLikeSuggestion(narrow) || !suggestionIsUnsafe(narrow)) {
+      out += narrow;
+      at = start + narrow.length;
+      continue;
+    }
+    const lastTick = line.lastIndexOf("`");
+    const wide = lastTick === -1 ? line : line.slice(0, lastTick);
+    out += OMITTED;
+    at = start + wide.length;
+  }
+}
+function leadWithCommand(command, purpose = "", reason = "") {
+  const tail = reason.trim();
+  return "Run `" + command + "`" + (purpose === "" ? "" : " " + purpose) + "." + (tail === "" ? "" : (tail.includes("`") ? "\n" : " ") + tail);
+}
+function docNavigation(filePath) {
+  const ext = /\.(txt|rst)$/i.exec(filePath)?.[1]?.toLowerCase();
+  return { section: ext !== "txt", outline: ext === void 0 };
+}
+function grepLinesHint(pattern, shownPath, reason = "") {
+  return leadWithCommand('token-goat grep "' + pattern + '" "' + shownPath + '" -C 3', "to read the matching lines", reason);
+}
+function docSectionHint(shownPath, heading, reason = "") {
+  const nav = docNavigation(shownPath);
+  if (!nav.section) return grepLinesHint("<pattern>", shownPath, reason);
+  return leadWithCommand('token-goat section "' + shownPath + "::" + heading + '"', "to read one section" + (nav.outline ? ', or `token-goat outline "' + shownPath + '"` for every heading with line ranges' : ""), reason);
+}
+
+// src/vscode_path_gate.ts
+init_define_import_meta_env();
+import * as path from "node:path";
+function resolvesToUncPath(target, cwd) {
+  try {
+    return isUncOrDevicePath(path.resolve(cwd ?? process.cwd(), target));
+  } catch {
+    return false;
+  }
+}
+function vscodePathAllowed(filePath, workspace) {
+  if (isUncOrDevicePath(filePath)) return false;
+  if (workspace === void 0 || isUncOrDevicePath(workspace)) return false;
+  const resolvedRoot = path.resolve(workspace);
+  const resolvedTarget = path.resolve(workspace, filePath);
+  const root = foldPathForContainment(resolvedRoot.replace(/\\/g, "/"));
+  const target = foldPathForContainment(resolvedTarget.replace(/\\/g, "/"));
+  if (target !== root && !target.startsWith(root.endsWith("/") ? root : root + "/")) return false;
+  return isInsideRoot(resolvedTarget, resolvedRoot);
+}
+function isVscodeEvent(event) {
+  return event.raw["_tg_harness"] === "vscode" || event.raw[VSCODE_TOOL_NAME_KEY] !== void 0;
+}
+function preToolPathDeclined(event, target) {
+  if (target === void 0) return false;
+  const cwd = getCwd(event);
+  if (spellingDeclined(event, target, cwd)) return true;
+  const mount = secondSpellingAtMount(target, cwd);
+  return mount !== null && spellingDeclined(event, mount, cwd);
+}
+function spellingDeclined(event, target, cwd) {
+  if (isUncOrDevicePath(target) || resolvesToUncPath(target, cwd)) return true;
+  if (isVscodeEvent(event)) return !vscodePathAllowed(target, cwd);
+  return escapesOntoNetworkThroughLinks(target, cwd);
+}
+function secondSpellingAtMount(target, cwd) {
+  if (process.platform === "win32") return null;
+  const base = cwd ?? "/";
+  const mount = wslMountOfIndexKey(resolveIndexPath(target, base));
+  return mount !== null && mount !== path.resolve(base, target) ? mount : null;
+}
+function commandPathIsTouchable(filePath, event) {
+  if (event === void 0) return !escapesOntoNetworkThroughLinks(filePath);
+  return !preToolPathDeclined(event, filePath);
+}
+
+export {
+  stripUnsafeSuggestions,
+  leadWithCommand,
+  docNavigation,
+  grepLinesHint,
+  docSectionHint,
+  vscodePathAllowed,
+  preToolPathDeclined,
+  commandPathIsTouchable
+};

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

@@ -0,0 +1,354 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  loadConfig
+} from "./token-goat-chunk-7IN2MKDS.mjs";
+import {
+  ensureDirSync
+} from "./token-goat-chunk-GOLEOXZP.mjs";
+import {
+  displaySafeJson
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  VERSION,
+  dataDir
+} from "./token-goat-chunk-VES7EL7O.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/cli_upgrade.ts
+init_define_import_meta_env();
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as https from "node:https";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+var require2 = createRequire(import.meta.url);
+var UPDATE_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var SEMVER = /^\d+\.\d+\.\d+(?:-[\w.-]+)?$/;
+var FAILED_CHECK_TTL_MS = 60 * 60 * 1e3;
+function getCachedUpdateStatus() {
+  try {
+    const cachePath = path.join(dataDir(), "update_check.json");
+    if (!fs.existsSync(cachePath)) return null;
+    const raw = fs.readFileSync(cachePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.checkedAt === "number") {
+      const latest = typeof parsed.latest === "string" && SEMVER.test(parsed.latest) ? parsed.latest : null;
+      return { checkedAt: parsed.checkedAt, current: VERSION, latest, updateAvailable: latest !== null && compareSemver(latest, VERSION) > 0, error: latest === null && typeof parsed.error === "string" ? parsed.error : void 0 };
+    }
+  } catch {
+  }
+  return null;
+}
+function saveCachedUpdateStatus(info) {
+  try {
+    const dir = dataDir();
+    ensureDirSync(dir);
+    const cachePath = path.join(dir, "update_check.json");
+    fs.writeFileSync(cachePath, JSON.stringify(info, null, 2), "utf8");
+  } catch {
+  }
+}
+function getRegistryUrl() {
+  const envRegistry = process.env["NPM_CONFIG_REGISTRY"] || process.env["npm_config_registry"];
+  if (envRegistry && typeof envRegistry === "string") {
+    return envRegistry.endsWith("/") ? envRegistry : `${envRegistry}/`;
+  }
+  return "https://registry.npmjs.org/";
+}
+function npmInvocation(host) {
+  const named = host.env["npm_execpath"];
+  if (typeof named === "string" && /(?:^|[\\/])npm-cli\.js$/.test(named) && host.exists(named)) return { file: host.execPath, prefix: [named] };
+  if (host.platform !== "win32") return { file: "npm", prefix: [] };
+  const bundled = path.win32.join(path.win32.dirname(host.execPath), "node_modules", "npm", "bin", "npm-cli.js");
+  return host.exists(bundled) ? { file: host.execPath, prefix: [bundled] } : null;
+}
+function hostNpm() {
+  return npmInvocation({ platform: process.platform, env: process.env, execPath: process.execPath, exists: (p) => fs.existsSync(p) });
+}
+function runningPackageRoot(moduleUrl = import.meta.url) {
+  let dir;
+  try {
+    dir = fs.realpathSync(path.dirname(fileURLToPath(moduleUrl)));
+  } catch {
+    return null;
+  }
+  for (; ; ) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8"));
+      if (pkg.name === "token-goat") return dir;
+    } catch {
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function isDevCheckout(root) {
+  return root !== null && fs.existsSync(path.join(root, ".git")) && fs.existsSync(path.join(root, "esbuild.config.mjs"));
+}
+function upgradeDecision(status, offline, devCheckout) {
+  if (offline) return "offline";
+  if (status.error || !status.latest) return "unreachable";
+  if (!status.updateAvailable) return "up-to-date";
+  if (devCheckout) return "dev-checkout";
+  return "install";
+}
+function currentUpgradeDecision(status) {
+  return upgradeDecision(status, loadConfig().network.offline, isDevCheckout(runningPackageRoot()));
+}
+var DEV_CHECKOUT_ADVICE = "git pull && npm run build && token-goat install";
+function updateAdvice(decision) {
+  if (decision === "install") return "Run 'token-goat upgrade' to update.";
+  if (decision === "dev-checkout") return `This token-goat runs from a development checkout. To update it, run: ${DEV_CHECKOUT_ADVICE}`;
+  return null;
+}
+function fetchViaNpm(timeoutMs = 2500) {
+  const npm = hostNpm();
+  if (!npm) return null;
+  try {
+    const res = spawnSync(npm.file, [...npm.prefix, "view", "token-goat", "version"], {
+      encoding: "utf8",
+      timeout: timeoutMs,
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true
+    });
+    if (res.status === 0 && res.stdout) {
+      const trimmed = res.stdout.trim();
+      if (SEMVER.test(trimmed)) {
+        return trimmed;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function fetchViaHttp(registryUrl, timeoutMs = 3500) {
+  return new Promise((resolve) => {
+    try {
+      const cleanUrl = registryUrl.endsWith("/") ? registryUrl : `${registryUrl}/`;
+      const targetUrl = new URL(`token-goat/latest`, cleanUrl);
+      const isHttps = targetUrl.protocol === "https:";
+      const getFn = isHttps ? https.get : require2("node:http").get;
+      const req = getFn(
+        targetUrl,
+        {
+          headers: { "User-Agent": `token-goat/${VERSION} (node/${process.version})` },
+          timeout: timeoutMs
+        },
+        (res) => {
+          if (res.statusCode !== 200) {
+            res.resume();
+            resolve(null);
+            return;
+          }
+          let data = "";
+          res.setEncoding("utf8");
+          res.on("data", (chunk) => {
+            data += chunk;
+            if (data.length > 32768) {
+              req.destroy();
+              resolve(null);
+            }
+          });
+          res.on("end", () => {
+            try {
+              const parsed = JSON.parse(data);
+              const version = parsed.version || parsed["dist-tags"]?.latest;
+              if (version && typeof version === "string" && SEMVER.test(version)) {
+                resolve(version);
+              } else {
+                resolve(null);
+              }
+            } catch {
+              resolve(null);
+            }
+          });
+        }
+      );
+      req.on("timeout", () => {
+        req.destroy();
+        resolve(null);
+      });
+      req.on("error", () => {
+        resolve(null);
+      });
+    } catch {
+      resolve(null);
+    }
+  });
+}
+async function fetchLatestVersion(timeoutMs = 3500) {
+  if (loadConfig().network.offline) {
+    return null;
+  }
+  const npmVersion = fetchViaNpm(Math.min(timeoutMs, 2500));
+  if (npmVersion) {
+    return npmVersion;
+  }
+  const registryUrl = getRegistryUrl();
+  return fetchViaHttp(registryUrl, timeoutMs);
+}
+function compareSemver(a, b) {
+  const pa = a.split("-")[0].split(".").map((x) => parseInt(x, 10) || 0);
+  const pb = b.split("-")[0].split(".").map((x) => parseInt(x, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    const na = pa[i] ?? 0;
+    const nb = pb[i] ?? 0;
+    if (na > nb) return 1;
+    if (na < nb) return -1;
+  }
+  return 0;
+}
+async function checkUpdateStatus(timeoutMs = 3500, forceFresh = false) {
+  if (!forceFresh) {
+    const cached = getCachedUpdateStatus();
+    if (cached && Date.now() - cached.checkedAt < (cached.latest ? UPDATE_CACHE_TTL_MS : FAILED_CHECK_TTL_MS)) {
+      return { current: VERSION, latest: cached.latest, updateAvailable: cached.updateAvailable, error: cached.error };
+    }
+  }
+  const latest = await fetchLatestVersion(timeoutMs);
+  if (!latest) {
+    if (loadConfig().network.offline) {
+      return { current: VERSION, latest: null, updateAvailable: false, error: "network.offline is set, so no update check was made" };
+    }
+    const result2 = {
+      current: VERSION,
+      latest: null,
+      updateAvailable: false,
+      error: "Could not reach npm or internal registry (request failed or timed out)"
+    };
+    saveCachedUpdateStatus({
+      checkedAt: Date.now(),
+      current: VERSION,
+      latest: null,
+      updateAvailable: false,
+      error: result2.error
+    });
+    return result2;
+  }
+  const updateAvailable = compareSemver(latest, VERSION) > 0;
+  const result = {
+    current: VERSION,
+    latest,
+    updateAvailable
+  };
+  saveCachedUpdateStatus({
+    checkedAt: Date.now(),
+    current: VERSION,
+    latest,
+    updateAvailable
+  });
+  return result;
+}
+async function cmdUpgrade(opts = {}, onSyncHooks) {
+  const status = await checkUpdateStatus(3500, true);
+  if (opts.check) {
+    if (opts.json) {
+      console.log(displaySafeJson(status, 2));
+      return;
+    }
+    if (status.error) {
+      console.log(`Current version: v${status.current}`);
+      console.log(`[!] ${status.error}`);
+      return;
+    }
+    if (status.updateAvailable && status.latest) {
+      console.log(`Update available: v${status.current} -> v${status.latest}`);
+      console.log(`Run 'token-goat upgrade' to update.`);
+    } else {
+      console.log(`token-goat is up to date (v${status.current})`);
+    }
+    return;
+  }
+  const decision = currentUpgradeDecision(status);
+  switch (decision) {
+    case "offline":
+      console.error(`token-goat: network.offline is set, so no update check was made and nothing was installed. Unset it (or TOKEN_GOAT_OFFLINE) to upgrade.`);
+      process.exitCode = 1;
+      return;
+    case "unreachable":
+      console.error(`token-goat: ${status.error ?? "could not determine the latest version"}. Nothing was installed.`);
+      process.exitCode = 1;
+      return;
+    case "up-to-date":
+      console.log(`token-goat is up to date (v${status.current})`);
+      return;
+    case "dev-checkout":
+      console.log(`Update available: v${status.current} -> v${status.latest}`);
+      console.log(`This token-goat runs from a development checkout, so it was not replaced. To update it, run:`);
+      console.log(`  ${DEV_CHECKOUT_ADVICE}`);
+      return;
+    case "install":
+      break;
+  }
+  console.log(`Upgrading token-goat v${status.current} -> v${status.latest}...`);
+  const outcome = await performUpgrade(onSyncHooks);
+  if (!outcome.ok) {
+    console.error(`token-goat: ${outcome.message}`);
+    process.exitCode = 1;
+    return;
+  }
+  console.log(`[\u2713] token-goat successfully updated.`);
+}
+var MANUAL_INSTALL = "npm install -g token-goat@latest";
+async function performUpgrade(onSyncHooks, npm = hostNpm()) {
+  if (!npm) return { ok: false, message: `npm was not found next to this Node.js, so token-goat could not upgrade itself. Run '${MANUAL_INSTALL}' yourself.` };
+  try {
+    const { stopWorker } = await import("./token-goat-chunk-KQNZDCBD.mjs");
+    const { queryServers } = await import("./token-goat-hook-client.mjs");
+    await queryServers("stop");
+    stopWorker();
+  } catch {
+  }
+  const install = spawnSync(npm.file, [...npm.prefix, "install", "-g", "token-goat@latest"], { stdio: "inherit", windowsHide: true });
+  if (install.status !== 0) {
+    const why = install.error ? install.error.message : `exit code ${install.status ?? "unknown"}`;
+    return { ok: false, message: `npm install failed (${why}). If npm reported EPERM or EBUSY, another program still has token-goat's files open: close running agent sessions and run '${MANUAL_INSTALL}'.` };
+  }
+  console.log(`Syncing token-goat hooks and integration manifests...`);
+  const launcher = installedLauncher(npm);
+  if (launcher) {
+    const sync = spawnSync(process.execPath, [launcher, "install"], { stdio: "inherit", windowsHide: true });
+    if (sync.status !== 0) return { ok: false, message: `the new version installed, but 'token-goat install' failed (exit code ${sync.status ?? "unknown"}). Run 'token-goat install' to finish.` };
+    return { ok: true };
+  }
+  try {
+    if (onSyncHooks) await onSyncHooks();
+  } catch (e) {
+    return { ok: false, message: `the new version installed, but syncing hooks failed (${e instanceof Error ? e.message : String(e)}). Run 'token-goat install' to finish.` };
+  }
+  return { ok: true };
+}
+function installedLauncher(npm) {
+  const res = spawnSync(npm.file, [...npm.prefix, "root", "-g"], { encoding: "utf8", timeout: 1e4, stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
+  const root = res.status === 0 && typeof res.stdout === "string" ? res.stdout.trim() : "";
+  if (!root) return null;
+  const launcher = path.join(root, "token-goat", "dist", "token-goat.mjs");
+  return fs.existsSync(launcher) ? launcher : null;
+}
+
+export {
+  UPDATE_CACHE_TTL_MS,
+  FAILED_CHECK_TTL_MS,
+  getCachedUpdateStatus,
+  saveCachedUpdateStatus,
+  getRegistryUrl,
+  npmInvocation,
+  runningPackageRoot,
+  isDevCheckout,
+  upgradeDecision,
+  currentUpgradeDecision,
+  DEV_CHECKOUT_ADVICE,
+  updateAdvice,
+  fetchViaNpm,
+  fetchViaHttp,
+  fetchLatestVersion,
+  compareSemver,
+  checkUpdateStatus,
+  cmdUpgrade,
+  performUpgrade
+};

package/dist/{token-goat-chunk-BGYOZ6DO.mjs → token-goat-chunk-B45VMIIH.mjs}

@@ -5,16 +5,15 @@ import {
   docxTables,
   docxText,
   formatDocxTables
-} from "./token-goat-chunk-UA5BKWWQ.mjs";
-import "./token-goat-chunk-UXSXQQIY.mjs";
+} from "./token-goat-chunk-UQ5UK2T7.mjs";
+import "./token-goat-chunk-IVKIZWAB.mjs";
 import "./token-goat-chunk-XTQAOTSO.mjs";
 import "./token-goat-chunk-AH6QILZM.mjs";
-import "./token-goat-chunk-XYWPOSCN.mjs";
-import "./token-goat-chunk-TCQANXYC.mjs";
-import "./token-goat-chunk-NMTKNYGF.mjs";
-import "./token-goat-chunk-MELOKFDJ.mjs";
 import "./token-goat-chunk-Y4AFKTHK.mjs";
-import "./token-goat-chunk-JTKCQMQA.mjs";
+import "./token-goat-chunk-GOLEOXZP.mjs";
+import "./token-goat-chunk-AM5V6GSX.mjs";
+import "./token-goat-chunk-FNFBKLRD.mjs";
+import "./token-goat-chunk-VES7EL7O.mjs";
 import "./token-goat-chunk-A37V4PBF.mjs";
 export {
   docxOutline,

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

@@ -0,0 +1,30 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/claude_config_dir.ts
+init_define_import_meta_env();
+import * as os from "node:os";
+import * as path from "node:path";
+function claudeConfigDir(homeDir = os.homedir()) {
+  const override = process.env["CLAUDE_CONFIG_DIR"];
+  if (override !== void 0 && override !== "") return override;
+  return path.join(homeDir, ".claude");
+}
+function claudeGlobalJsonPath(homeDir = os.homedir()) {
+  const override = process.env["CLAUDE_CONFIG_DIR"];
+  return path.join(override !== void 0 && override !== "" ? override : homeDir, ".claude.json");
+}
+function projectTranscriptsDir(projectRoot) {
+  const rootStr = path.resolve(projectRoot);
+  const slug = rootStr.replace(/[^A-Za-z0-9]/g, "-");
+  return path.join(claudeConfigDir(), "projects", slug);
+}
+
+export {
+  claudeConfigDir,
+  claudeGlobalJsonPath,
+  projectTranscriptsDir
+};

package/dist/{token-goat-chunk-TDUT2CL6.mjs → token-goat-chunk-C63JQV5K.mjs}

@@ -2,19 +2,20 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   redactSecrets
-} from "./token-goat-chunk-CIQ2FTY3.mjs";
+} from "./token-goat-chunk-4FVIAHSI.mjs";
 import {
   shortFingerprint
-} from "./token-goat-chunk-TGOXNAHW.mjs";
+} from "./token-goat-chunk-7IN2MKDS.mjs";
 import {
   registerReset
 } from "./token-goat-chunk-YZAAZU2S.mjs";
 import {
   foldPath
-} from "./token-goat-chunk-TCQANXYC.mjs";
+} from "./token-goat-chunk-AM5V6GSX.mjs";
 import {
+  hostPathOfIndexKey,
   normalizePath
-} from "./token-goat-chunk-NMTKNYGF.mjs";
+} from "./token-goat-chunk-FNFBKLRD.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -47,11 +48,13 @@ var _compactedAt = 0;
 var _cliReads = /* @__PURE__ */ new Set();
 var _pendingLargeFileHints = /* @__PURE__ */ new Map();
 var _pendingLargeFileHintsAtLoad = /* @__PURE__ */ new Map();
+var _bashStartCwds = /* @__PURE__ */ new Map();
+var _bashStartCwdsAtLoad = /* @__PURE__ */ new Map();
 var _sessionId = null;
 var _transcriptPath = null;
 function fileSize(absPath) {
   try {
-    return fs.statSync(absPath).size;
+    return fs.statSync(hostPathOfIndexKey(absPath)).size;
   } catch {
     return 0;
   }
@@ -153,6 +156,7 @@ function markCompacted(now = Date.now()) {
   _compactedAt = now;
   _fileLineRanges = /* @__PURE__ */ new Map();
   _fileServedOutputs = /* @__PURE__ */ new Map();
+  _cliReads = /* @__PURE__ */ new Set();
 }
 function getSessionFileEntry(filePath) {
   return _files.get(resolveFilesKey(normalizePath(filePath)));
@@ -194,6 +198,31 @@ function consumedPendingLargeFileHintKeys() {
 function pendingLargeFileHintsAtLoad() {
   return _pendingLargeFileHintsAtLoad;
 }
+var MAX_BASH_START_CWDS = 32;
+function recordBashStartCwd(toolUseId, cwd) {
+  _bashStartCwds.delete(toolUseId);
+  _bashStartCwds.set(toolUseId, cwd);
+  for (const oldest of _bashStartCwds.keys()) {
+    if (_bashStartCwds.size <= MAX_BASH_START_CWDS) break;
+    _bashStartCwds.delete(oldest);
+  }
+}
+function takeBashStartCwd(toolUseId) {
+  const cwd = _bashStartCwds.get(toolUseId);
+  if (cwd === void 0) return null;
+  _bashStartCwds.delete(toolUseId);
+  return cwd;
+}
+function bashStartCwdsAtLoad() {
+  return _bashStartCwdsAtLoad;
+}
+function consumedBashStartCwdKeys() {
+  const consumed = [];
+  for (const key of _bashStartCwdsAtLoad.keys()) {
+    if (!_bashStartCwds.has(key)) consumed.push(key);
+  }
+  return consumed;
+}
 var WEB_FETCH_KEY_SEP = "\0";
 function webFetchKey(url, prompt) {
   const digest = shortFingerprint(`${url}${WEB_FETCH_KEY_SEP}${prompt}`);
@@ -327,7 +356,7 @@ function consumedFileServedOutputKeys() {
 var MAX_RANGES_PER_FILE = 64;
 function statIdentity(absPath) {
   try {
-    const st = fs.statSync(absPath);
+    const st = fs.statSync(hostPathOfIndexKey(absPath));
     return { size: st.size, mtimeMs: st.mtimeMs };
   } catch {
     return void 0;
@@ -425,6 +454,7 @@ function exportSessionState() {
     ..._fileServedOutputs.size > 0 ? { fileServedOutputs: Array.from(_fileServedOutputs.entries()) } : {},
     cliReads: Array.from(_cliReads),
     pendingLargeFileHints: Array.from(_pendingLargeFileHints.entries()),
+    ..._bashStartCwds.size > 0 ? { bashStartCwds: Array.from(_bashStartCwds.entries()) } : {},
     grepQueries: Array.from(_grepQueries.entries()),
     globQueries: Array.from(_globQueries.entries()),
     outstandingAgentSpawns: _outstandingAgentSpawns.map((e) => [e.prompt, e.ts]),
@@ -454,6 +484,8 @@ function importSessionState(s) {
   _cliReads = new Set(s.cliReads ?? []);
   _pendingLargeFileHints = new Map(s.pendingLargeFileHints ?? []);
   _pendingLargeFileHintsAtLoad = new Map(_pendingLargeFileHints);
+  _bashStartCwds = new Map(s.bashStartCwds ?? []);
+  _bashStartCwdsAtLoad = new Map(_bashStartCwds);
   _grepQueries = new Map(s.grepQueries ?? []);
   _globQueries = new Map(s.globQueries ?? []);
   _outstandingAgentSpawns = (s.outstandingAgentSpawns ?? []).map(([prompt, ts]) => ({ prompt, ts }));
@@ -480,6 +512,8 @@ registerReset(() => {
   _cliReads = /* @__PURE__ */ new Set();
   _pendingLargeFileHints = /* @__PURE__ */ new Map();
   _pendingLargeFileHintsAtLoad = /* @__PURE__ */ new Map();
+  _bashStartCwds = /* @__PURE__ */ new Map();
+  _bashStartCwdsAtLoad = /* @__PURE__ */ new Map();
   _grepQueries = /* @__PURE__ */ new Map();
   _globQueries = /* @__PURE__ */ new Map();
   _outstandingAgentSpawns = [];
@@ -512,6 +546,11 @@ export {
   takePendingLargeFileHint,
   consumedPendingLargeFileHintKeys,
   pendingLargeFileHintsAtLoad,
+  MAX_BASH_START_CWDS,
+  recordBashStartCwd,
+  takeBashStartCwd,
+  bashStartCwdsAtLoad,
+  consumedBashStartCwdKeys,
   WEB_FETCH_KEY_SEP,
   recordWebFetch,
   migrateCurlDownloadKey,