token-goat 2.9.30 → 2.9.31

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

@@ -0,0 +1,547 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  GENERIC_SERVED_OUTPUT_KEY,
+  MAX_BASH_START_CWDS,
+  MAX_GENERIC_SERVED_OUTPUTS,
+  MAX_OUTSTANDING_AGENT_SPAWNS,
+  MAX_RANGES_PER_FILE,
+  MAX_SEEN_IMAGE_HASHES,
+  MAX_SERVED_OUTPUTS_PER_FILE,
+  MAX_VERIFICATION_RUNS,
+  bashStartCwdsAtLoad,
+  coerceReadRangeEvasion,
+  consumedBashStartCwdKeys,
+  consumedCurlDownloadKeys,
+  consumedFileLineRangeKeys,
+  consumedFileServedOutputKeys,
+  consumedOutstandingAgentSpawnKeys,
+  consumedPendingLargeFileHintKeys,
+  curlDownloadsAtLoad,
+  exportSessionState,
+  filesFullReadCountAtLoad,
+  filesReadCountAtLoad,
+  importSessionState,
+  markCompacted,
+  mergeEpochBase,
+  mergeReadRangeEvasion,
+  migrateCurlDownloadKey,
+  migrateWebFetchKey,
+  outstandingAgentSpawnKey,
+  outstandingAgentSpawnsAtLoad,
+  pendingLargeFileHintsAtLoad
+} from "./token-goat-chunk-GL3ETKSC.mjs";
+import {
+  redactSerializedJson
+} from "./token-goat-chunk-T5P5ACNQ.mjs";
+import {
+  atomicWriteText,
+  ensureDirSync,
+  sanitizeIdForFilename,
+  withFileLock,
+  withRetryOnLock
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  foldPath
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  normalizePath
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  tokenGoatHome
+} from "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/sessions_dir.ts
+init_define_import_meta_env();
+import * as path from "node:path";
+var SESSIONS_SUBDIR = "sessions";
+function sessionsDir() {
+  return path.join(tokenGoatHome(), SESSIONS_SUBDIR);
+}
+
+// src/session_store.ts
+init_define_import_meta_env();
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path2 from "node:path";
+var MAX_FILES = 500;
+var AGENT_SALT_MARKER = sanitizeIdForFilename(":agent:");
+var AGENT_SALT_SEPARATOR = ":agent:";
+var AGENT_DIGEST_CHARS = 12;
+var SALTED_SESSION_MAX = 64 - AGENT_SALT_MARKER.length - AGENT_DIGEST_CHARS;
+function saltedStemPrefix(sessionId) {
+  return `${sanitizeIdForFilename(sessionId, SALTED_SESSION_MAX)}${AGENT_SALT_MARKER}`;
+}
+function sessionFileStem(sessionId) {
+  const sep = sessionId.indexOf(AGENT_SALT_SEPARATOR);
+  if (sep < 0) return sanitizeIdForFilename(sessionId, 64);
+  const agentId = sessionId.slice(sep + AGENT_SALT_SEPARATOR.length);
+  const digest = createHash("sha256").update(agentId).digest("hex").slice(0, AGENT_DIGEST_CHARS);
+  return `${saltedStemPrefix(sessionId.slice(0, sep))}${digest}`;
+}
+function sessionPath(sessionId) {
+  return sessionSidecarPath(sessionId, ".json");
+}
+function sessionSidecarPath(sessionId, suffix) {
+  if (!sessionId) return null;
+  const safe = sessionFileStem(sessionId);
+  if (!safe) return null;
+  if (suffix.includes("/") || suffix.includes("\\") || suffix.includes("..")) return null;
+  if (suffix !== ".json" && suffix.endsWith(".json")) return null;
+  const dir = sessionsDir();
+  const candidate = path2.join(dir, `${safe}${suffix}`);
+  try {
+    const rel = path2.relative(dir, candidate);
+    if (rel.startsWith("..")) return null;
+  } catch {
+    return null;
+  }
+  return candidate;
+}
+function asStringPairs(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    if (Array.isArray(item) && typeof item[0] === "string" && typeof item[1] === "string") {
+      out.push([item[0], item[1]]);
+    }
+  }
+  return out;
+}
+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;
+  }
+  let entry = {
+    path: o["path"],
+    readCount: o["readCount"],
+    lastReadAt: o["lastReadAt"],
+    wasEdited: o["wasEdited"],
+    sizeBytes: o["sizeBytes"]
+  };
+  if (o["wasTruncated"] === true) entry = { ...entry, wasTruncated: true };
+  if (typeof o["lastFullReadAt"] === "number") entry = { ...entry, lastFullReadAt: o["lastFullReadAt"] };
+  if (typeof o["fullReadCount"] === "number") entry = { ...entry, fullReadCount: o["fullReadCount"] };
+  if (typeof o["lastEditedAt"] === "number") entry = { ...entry, lastEditedAt: o["lastEditedAt"] };
+  if (Array.isArray(o["symbols_read"])) {
+    const symbols = o["symbols_read"].filter((s) => typeof s === "string");
+    if (symbols.length > 0) entry = { ...entry, symbols_read: symbols };
+  }
+  const rangeIdentity = o["rangeFileIdentity"];
+  if (rangeIdentity !== null && typeof rangeIdentity === "object" && typeof rangeIdentity["size"] === "number" && typeof rangeIdentity["mtimeMs"] === "number") {
+    entry = { ...entry, rangeFileIdentity: { size: rangeIdentity["size"], mtimeMs: rangeIdentity["mtimeMs"] } };
+  }
+  const epochBase = o["epochBase"];
+  if (epochBase !== null && typeof epochBase === "object") {
+    const b = epochBase;
+    if (typeof b["at"] === "number" && typeof b["readCount"] === "number" && typeof b["fullReadCount"] === "number") {
+      entry = { ...entry, epochBase: { at: b["at"], readCount: b["readCount"], fullReadCount: b["fullReadCount"] } };
+    }
+  }
+  return entry;
+}
+function asPyFileEntry(dictKey, raw) {
+  if (raw === null || typeof raw !== "object") return null;
+  const v = raw;
+  const p = typeof v["rel_or_abs"] === "string" ? v["rel_or_abs"] : dictKey;
+  if (!p) return null;
+  const readCount = typeof v["read_count"] === "number" ? Math.max(1, Math.round(v["read_count"])) : 1;
+  const lastReadTs = typeof v["last_read_ts"] === "number" ? v["last_read_ts"] : 0;
+  const sizeBytes = typeof v["read_size"] === "number" ? Math.round(v["read_size"]) : 0;
+  const wasEdited = typeof v["last_edit_ts"] === "number" && v["last_edit_ts"] > 0;
+  return { path: p, readCount, lastReadAt: lastReadTs * 1e3, wasEdited, sizeBytes };
+}
+function asRangeIdentities(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const pair of raw) {
+    if (!Array.isArray(pair) || pair.length !== 2 || typeof pair[0] !== "string") continue;
+    const id = pair[1];
+    if (id !== null && typeof id === "object" && typeof id["size"] === "number" && typeof id["mtimeMs"] === "number") out.push([pair[0], { size: id["size"], mtimeMs: id["mtimeMs"] }]);
+  }
+  return out;
+}
+function asLineRanges(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const pair of raw) {
+    if (!Array.isArray(pair) || pair.length !== 2) continue;
+    const filePath = pair[0];
+    const ranges = pair[1];
+    if (typeof filePath !== "string" || !Array.isArray(ranges)) continue;
+    const valid = [];
+    for (const r of ranges) {
+      if (Array.isArray(r) && r.length === 2 && typeof r[0] === "number" && typeof r[1] === "number") valid.push([r[0], r[1]]);
+    }
+    out.push([filePath, valid]);
+  }
+  return out;
+}
+function asServedOutputs(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const pair of raw) {
+    if (!Array.isArray(pair) || pair.length !== 2) continue;
+    const filePath = pair[0];
+    const ids = pair[1];
+    if (typeof filePath !== "string" || !Array.isArray(ids)) continue;
+    out.push([filePath, ids.filter((id) => typeof id === "string")]);
+  }
+  return out;
+}
+function migrateKeys(pairs, migrate) {
+  return pairs.map(([key, value]) => [migrate(key), value]);
+}
+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);
+    }
+  } else if (o["files"] !== null && typeof o["files"] === "object") {
+    for (const [key, val] of Object.entries(o["files"])) {
+      const e = asPyFileEntry(key, val);
+      if (e !== null) files.push(e);
+    }
+  }
+  const hintsShown = Array.isArray(o["hintsShown"]) ? o["hintsShown"].filter((h) => typeof h === "string") : Array.isArray(o["hints_seen"]) ? o["hints_seen"].filter((h) => typeof h === "string") : [];
+  const scheduledPromptCounts = Array.isArray(o["scheduledPromptCounts"]) ? o["scheduledPromptCounts"].filter(
+    (p) => Array.isArray(p) && p.length === 2 && typeof p[0] === "string" && typeof p[1] === "number" && Number.isSafeInteger(p[1]) && p[1] >= 0
+  ) : [];
+  const cliReads = Array.isArray(o["cliReads"]) ? o["cliReads"].filter((h) => typeof h === "string") : [];
+  const bashReruns = Array.isArray(o["bashReruns"]) ? o["bashReruns"].filter((h) => typeof h === "string") : [];
+  const seenImageHashes = Array.isArray(o["seenImageHashes"]) ? o["seenImageHashes"].filter((h) => typeof h === "string") : [];
+  const verificationRuns = Array.isArray(o["verificationRuns"]) ? o["verificationRuns"].filter(
+    (r) => r !== null && typeof r === "object" && typeof r.command === "string" && typeof r.at === "number" && (r.exitCode === null || typeof r.exitCode === "number")
+  ) : [];
+  const pendingLargeFileHints = Array.isArray(o["pendingLargeFileHints"]) ? o["pendingLargeFileHints"].filter(
+    (p) => Array.isArray(p) && p.length === 2 && typeof p[0] === "string" && typeof p[1] === "number"
+  ) : [];
+  const grepQueries = Array.isArray(o["grepQueries"]) ? o["grepQueries"].filter(
+    (p) => Array.isArray(p) && p.length === 2 && typeof p[0] === "string" && typeof p[1] === "number"
+  ) : [];
+  const globQueries = Array.isArray(o["globQueries"]) ? o["globQueries"].filter(
+    (p) => Array.isArray(p) && p.length === 2 && typeof p[0] === "string" && typeof p[1] === "number"
+  ) : [];
+  const outstandingAgentSpawns = Array.isArray(o["outstandingAgentSpawns"]) ? o["outstandingAgentSpawns"].filter(
+    (p) => Array.isArray(p) && p.length === 2 && typeof p[0] === "string" && typeof p[1] === "number"
+  ) : [];
+  const rangeIdentities = asRangeIdentities(o["fileLineRangeIdentities"]);
+  return {
+    files,
+    hintsShown,
+    ...scheduledPromptCounts.length > 0 ? { scheduledPromptCounts } : {},
+    webFetches: migrateKeys(asStringPairs(o["webFetches"]), migrateWebFetchKey),
+    bashOutputs: asStringPairs(o["bashOutputs"]),
+    curlDownloads: migrateKeys(asStringPairs(o["curlDownloads"]), migrateCurlDownloadKey),
+    fileLineRanges: asLineRanges(o["fileLineRanges"]),
+    readRangeEvasion: coerceReadRangeEvasion(o["readRangeEvasion"]),
+    ...rangeIdentities.length > 0 ? { fileLineRangeIdentities: rangeIdentities } : {},
+    fileServedOutputs: asServedOutputs(o["fileServedOutputs"]),
+    cliReads,
+    bashReruns,
+    pendingLargeFileHints,
+    bashStartCwds: asStringPairs(o["bashStartCwds"]),
+    grepQueries,
+    globQueries,
+    outstandingAgentSpawns,
+    ...typeof o["lastTabContextDigest"] === "string" ? { lastTabContextDigest: o["lastTabContextDigest"] } : {},
+    ...seenImageHashes.length > 0 ? { seenImageHashes } : {},
+    ...verificationRuns.length > 0 ? { verificationRuns } : {},
+    ...typeof o["compactedAt"] === "number" ? { compactedAt: o["compactedAt"] } : {},
+    ...typeof o["created_ts"] === "number" ? { created_ts: o["created_ts"] } : {}
+  };
+}
+function mergeFileEntry(a, b) {
+  const newest = a.lastReadAt >= b.lastReadAt ? a : b;
+  const baseline = filesReadCountAtLoad().get(b.path) ?? 0;
+  const newReadsThisProcess = Math.max(0, b.readCount - baseline);
+  let merged = {
+    path: a.path,
+    readCount: a.readCount + newReadsThisProcess,
+    lastReadAt: Math.max(a.lastReadAt, b.lastReadAt),
+    wasEdited: a.wasEdited || b.wasEdited,
+    sizeBytes: newest.sizeBytes
+  };
+  if (newest.rangeFileIdentity) merged = { ...merged, rangeFileIdentity: newest.rangeFileIdentity };
+  if (a.wasTruncated || b.wasTruncated) merged = { ...merged, wasTruncated: true };
+  const lastFullReadAt = Math.max(a.lastFullReadAt ?? 0, b.lastFullReadAt ?? 0);
+  if (lastFullReadAt > 0) merged = { ...merged, lastFullReadAt };
+  const fullReadBaseline = filesFullReadCountAtLoad().get(b.path) ?? 0;
+  const newFullReadsThisProcess = Math.max(0, (b.fullReadCount ?? 0) - fullReadBaseline);
+  const fullReadCount = (a.fullReadCount ?? 0) + newFullReadsThisProcess;
+  if (fullReadCount > 0) merged = { ...merged, fullReadCount };
+  const lastEditedAt = Math.max(a.lastEditedAt ?? 0, b.lastEditedAt ?? 0);
+  if (lastEditedAt > 0) merged = { ...merged, lastEditedAt };
+  const epochBase = mergeEpochBase(a.epochBase, b.epochBase);
+  if (epochBase !== void 0) merged = { ...merged, epochBase };
+  const symbols = Array.from(/* @__PURE__ */ new Set([...a.symbols_read ?? [], ...b.symbols_read ?? []]));
+  if (symbols.length > 0) merged = { ...merged, symbols_read: symbols };
+  return merged;
+}
+function mergePairs(disk, mem) {
+  return Array.from(new Map([...disk, ...mem]).entries());
+}
+function mergeMaxNumberPairs(disk, mem) {
+  const merged = new Map(disk);
+  for (const [key, value] of mem) {
+    merged.set(key, Math.max(merged.get(key) ?? 0, value));
+  }
+  return Array.from(merged.entries());
+}
+function mergeLineRanges(disk, mem) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const [filePath, ranges] of disk) byPath.set(filePath, [...ranges]);
+  for (const [filePath, ranges] of mem) {
+    const prev = byPath.get(filePath) ?? [];
+    const seen = new Set(prev.map(([s, e]) => s + ":" + e));
+    for (const [s, e] of ranges) {
+      const key = s + ":" + e;
+      if (seen.has(key) || prev.length >= MAX_RANGES_PER_FILE) continue;
+      prev.push([s, e]);
+      seen.add(key);
+    }
+    byPath.set(filePath, prev);
+  }
+  return Array.from(byPath.entries());
+}
+var GENERIC_SERVED_OUTPUT_FOLDED_KEY = foldPath(normalizePath(GENERIC_SERVED_OUTPUT_KEY));
+function mergeServedOutputs(disk, mem) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const [filePath, ids] of disk) byPath.set(filePath, [...ids]);
+  for (const [filePath, ids] of mem) {
+    const prev = byPath.get(filePath) ?? [];
+    const merged = [...prev.filter((id) => !ids.includes(id)), ...ids];
+    const cap = filePath === GENERIC_SERVED_OUTPUT_FOLDED_KEY ? MAX_GENERIC_SERVED_OUTPUTS : MAX_SERVED_OUTPUTS_PER_FILE;
+    if (merged.length > cap) merged.splice(0, merged.length - cap);
+    byPath.set(filePath, merged);
+  }
+  return Array.from(byPath.entries());
+}
+function mergePendingLargeFileHints(disk, mem) {
+  const merged = new Map(disk);
+  for (const key of consumedPendingLargeFileHintKeys()) merged.delete(key);
+  const atLoad = pendingLargeFileHintsAtLoad();
+  for (const [key, size] of mem) {
+    if (atLoad.get(key) === size) continue;
+    merged.set(key, size);
+  }
+  return Array.from(merged.entries());
+}
+function mergeCurlDownloads(disk, mem) {
+  const merged = new Map(disk);
+  for (const key of consumedCurlDownloadKeys()) merged.delete(key);
+  const atLoad = curlDownloadsAtLoad();
+  for (const [url, savedPath] of mem) {
+    if (atLoad.get(url) === savedPath) continue;
+    merged.set(url, savedPath);
+  }
+  return Array.from(merged.entries());
+}
+function mergeBashStartCwds(disk, mem) {
+  const merged = new Map(disk);
+  for (const key of consumedBashStartCwdKeys()) merged.delete(key);
+  const atLoad = bashStartCwdsAtLoad();
+  for (const [toolUseId, cwd] of mem) {
+    if (atLoad.get(toolUseId) === cwd) continue;
+    merged.set(toolUseId, cwd);
+  }
+  const entries = Array.from(merged.entries());
+  return entries.length > MAX_BASH_START_CWDS ? entries.slice(entries.length - MAX_BASH_START_CWDS) : entries;
+}
+function mergeOutstandingAgentSpawns(disk, mem) {
+  const merged = new Map(disk.map(([prompt, ts]) => [outstandingAgentSpawnKey(prompt, ts), [prompt, ts]]));
+  for (const key of consumedOutstandingAgentSpawnKeys()) merged.delete(key);
+  const atLoad = new Set(outstandingAgentSpawnsAtLoad().map((e) => outstandingAgentSpawnKey(e.prompt, e.ts)));
+  for (const [prompt, ts] of mem) {
+    const key = outstandingAgentSpawnKey(prompt, ts);
+    if (atLoad.has(key)) continue;
+    merged.set(key, [prompt, ts]);
+  }
+  const result = Array.from(merged.values()).sort((a, b) => a[1] - b[1]);
+  if (result.length > MAX_OUTSTANDING_AGENT_SPAWNS) {
+    result.splice(0, result.length - MAX_OUTSTANDING_AGENT_SPAWNS);
+  }
+  return result;
+}
+function mergeSessionState(disk, mem) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const e of disk.files) byPath.set(foldPath(e.path), e);
+  for (const e of mem.files) {
+    const key = foldPath(e.path);
+    const prev = byPath.get(key);
+    byPath.set(key, prev ? mergeFileEntry(prev, e) : e);
+  }
+  const compactedAt = Math.max(disk.compactedAt ?? 0, mem.compactedAt ?? 0);
+  const rawDiskRanges = (disk.compactedAt ?? 0) === compactedAt ? disk.fileLineRanges ?? [] : [];
+  const memRanges = (mem.compactedAt ?? 0) === compactedAt ? mem.fileLineRanges ?? [] : [];
+  const rawDiskServed = (disk.compactedAt ?? 0) === compactedAt ? disk.fileServedOutputs ?? [] : [];
+  const memServed = (mem.compactedAt ?? 0) === compactedAt ? mem.fileServedOutputs ?? [] : [];
+  const rawDiskCliReads = (disk.compactedAt ?? 0) === compactedAt ? disk.cliReads ?? [] : [];
+  const memCliReads = (mem.compactedAt ?? 0) === compactedAt ? mem.cliReads ?? [] : [];
+  const latestRuns = /* @__PURE__ */ new Map();
+  for (const run of [...disk.verificationRuns ?? [], ...mem.verificationRuns ?? []]) {
+    const seen = latestRuns.get(run.command);
+    if (seen === void 0 || run.at >= seen.at) latestRuns.set(run.command, run);
+  }
+  const verificationRuns = Array.from(latestRuns.values()).sort((a, b) => a.at - b.at).slice(-MAX_VERIFICATION_RUNS);
+  const clearedRangeFiles = new Set(consumedFileLineRangeKeys());
+  const clearedServedFiles = new Set(consumedFileServedOutputKeys());
+  const diskRanges = rawDiskRanges.filter(([path3]) => !clearedRangeFiles.has(path3));
+  const diskServed = rawDiskServed.filter(([path3]) => !clearedServedFiles.has(path3));
+  const fileLineRanges = mergeLineRanges(diskRanges, memRanges);
+  const diskRangeEvasion = (disk.compactedAt ?? 0) === compactedAt ? disk.readRangeEvasion ?? [] : [];
+  const memRangeEvasion = (mem.compactedAt ?? 0) === compactedAt ? mem.readRangeEvasion ?? [] : [];
+  const rangedFiles = new Set(fileLineRanges.map(([path3]) => path3));
+  const rawDiskIdentities = (disk.compactedAt ?? 0) === compactedAt ? disk.fileLineRangeIdentities ?? [] : [];
+  const memIdentities = (mem.compactedAt ?? 0) === compactedAt ? mem.fileLineRangeIdentities ?? [] : [];
+  const fileLineRangeIdentities = mergePairs(rawDiskIdentities.filter(([path3]) => !clearedRangeFiles.has(path3)), memIdentities).filter(([path3]) => rangedFiles.has(path3));
+  return {
+    files: Array.from(byPath.values()),
+    hintsShown: Array.from(/* @__PURE__ */ new Set([...disk.hintsShown, ...mem.hintsShown])),
+    scheduledPromptCounts: mergeMaxNumberPairs(disk.scheduledPromptCounts ?? [], mem.scheduledPromptCounts ?? []),
+    webFetches: mergePairs(disk.webFetches, mem.webFetches),
+    bashOutputs: mergePairs(disk.bashOutputs, mem.bashOutputs),
+    curlDownloads: mergeCurlDownloads(disk.curlDownloads, mem.curlDownloads),
+    fileLineRanges,
+    readRangeEvasion: mergeReadRangeEvasion(diskRangeEvasion, memRangeEvasion),
+    ...fileLineRangeIdentities.length > 0 ? { fileLineRangeIdentities } : {},
+    fileServedOutputs: mergeServedOutputs(diskServed, memServed),
+    ...compactedAt > 0 ? { compactedAt } : {},
+    // Same epoch filter as the line ranges above: a CLI read recorded before the winning compaction is not in the model's context any more, so merging it back would resurrect the "you already ran this" note the compaction just cleared.
+    cliReads: Array.from(/* @__PURE__ */ new Set([...rawDiskCliReads, ...memCliReads])),
+    bashReruns: Array.from(/* @__PURE__ */ new Set([...disk.bashReruns ?? [], ...mem.bashReruns ?? []])),
+    pendingLargeFileHints: mergePendingLargeFileHints(disk.pendingLargeFileHints ?? [], mem.pendingLargeFileHints ?? []),
+    bashStartCwds: mergeBashStartCwds(disk.bashStartCwds ?? [], mem.bashStartCwds ?? []),
+    grepQueries: mergePairs(disk.grepQueries ?? [], mem.grepQueries ?? []),
+    globQueries: mergePairs(disk.globQueries ?? [], mem.globQueries ?? []),
+    outstandingAgentSpawns: mergeOutstandingAgentSpawns(disk.outstandingAgentSpawns ?? [], mem.outstandingAgentSpawns ?? []),
+    // An accumulating collection, so union rather than pick a winner: two hook processes can each see a screenshot the other never did. Disk first, then mem, so the order stays oldest-to-newest and the cap evicts the oldest -- the same policy recordSeenImage applies in memory, applied again here because a union of two capped lists can exceed the cap.
+    seenImageHashes: mergeSeenImageHashes(disk.seenImageHashes ?? [], mem.seenImageHashes ?? []),
+    ...verificationRuns.length > 0 ? { verificationRuns } : {},
+    // Last-seen scalar, not an accumulating collection: prefer mem's value (this process's freshest observation) over disk's, since a newer write always supersedes an older one.
+    ...mem.lastTabContextDigest !== void 0 ? { lastTabContextDigest: mem.lastTabContextDigest } : disk.lastTabContextDigest !== void 0 ? { lastTabContextDigest: disk.lastTabContextDigest } : {},
+    // Prefer the value already on disk: it marks the original creation time, and must never be bumped forward to the merge's "now". `mem` never carries one (it is not tracked in memory), so this is really "keep whatever disk has".
+    ...disk.created_ts !== void 0 ? { created_ts: disk.created_ts } : mem.created_ts !== void 0 ? { created_ts: mem.created_ts } : {}
+  };
+}
+function mergeSeenImageHashes(disk, mem) {
+  const merged = Array.from(/* @__PURE__ */ new Set([...disk, ...mem]));
+  return merged.length > MAX_SEEN_IMAGE_HASHES ? merged.slice(merged.length - MAX_SEEN_IMAGE_HASHES) : merged;
+}
+function capFiles(s, max) {
+  if (s.files.length <= max) return s;
+  const kept = [...s.files].sort((a, b) => a.wasEdited === b.wasEdited ? b.lastReadAt - a.lastReadAt : a.wasEdited ? -1 : 1).slice(0, max);
+  return { ...s, files: kept };
+}
+function readDiskState(p) {
+  try {
+    return readDiskStateForMerge(p);
+  } catch {
+    return null;
+  }
+}
+function readDiskStateForMerge(p) {
+  let text = "";
+  try {
+    withRetryOnLock(() => {
+      text = fs.readFileSync(p, "utf8");
+    });
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+  try {
+    return coerce(JSON.parse(text));
+  } catch {
+    return null;
+  }
+}
+function readSessionStateFile(sessionId) {
+  const p = sessionPath(sessionId);
+  if (!p) return null;
+  return readDiskState(p);
+}
+function listSiblingSessionStates(sessionId) {
+  if (!sessionId) return [];
+  const prefix = saltedStemPrefix(sessionId);
+  if (prefix === AGENT_SALT_MARKER) return [];
+  const dir = sessionsDir();
+  const out = [];
+  try {
+    if (!fs.existsSync(dir)) return out;
+    for (const file of fs.readdirSync(dir)) {
+      if (!file.endsWith(".json") || !file.startsWith(prefix)) continue;
+      const state = readDiskState(path2.join(dir, file));
+      if (state !== null) out.push(state);
+    }
+  } catch {
+    return out;
+  }
+  return out;
+}
+var EMPTY_SESSION = { files: [], hintsShown: [], webFetches: [], bashOutputs: [], curlDownloads: [] };
+function loadSessionState(sessionId) {
+  const p = sessionPath(sessionId);
+  importSessionState((p ? readDiskState(p) : null) ?? EMPTY_SESSION);
+  applySessionCompaction(sessionId);
+}
+var COMPACTED_AT_SUFFIX = ".compacted-at";
+function applySessionCompaction(stateKey) {
+  const at = stateKey.indexOf(":agent:");
+  const p = sessionSidecarPath(at < 0 ? stateKey : stateKey.slice(0, at), COMPACTED_AT_SUFFIX);
+  if (!p) return;
+  try {
+    const epoch = Number(fs.readFileSync(p, "utf8").trim());
+    if (Number.isFinite(epoch) && epoch > 0) markCompacted(epoch);
+  } catch {
+  }
+}
+var SESSION_SAVE_LOCK_WAIT_MS = 500;
+function saveSessionState(sessionId) {
+  const p = sessionPath(sessionId);
+  if (!p) return;
+  try {
+    const dir = path2.dirname(p);
+    if (!fs.existsSync(dir)) ensureDirSync(dir);
+    const mem = exportSessionState();
+    const writeMerged = () => {
+      const disk = readDiskStateForMerge(p);
+      const merged = capFiles(disk ? mergeSessionState(disk, mem) : mem, MAX_FILES);
+      if (merged.created_ts === void 0) merged.created_ts = Date.now() / 1e3;
+      let json;
+      try {
+        json = redactSerializedJson(JSON.stringify(merged)).text;
+      } catch {
+        return true;
+      }
+      atomicWriteText(p, json);
+      return true;
+    };
+    let heldByAnother = false;
+    if (withFileLock(`${p}.lock`, writeMerged, { waitMs: SESSION_SAVE_LOCK_WAIT_MS, onContended: () => {
+      heldByAnother = true;
+    } }) === void 0 && !heldByAnother) writeMerged();
+  } catch {
+  }
+}
+
+export {
+  SESSIONS_SUBDIR,
+  sessionsDir,
+  AGENT_SALT_MARKER,
+  sessionFileStem,
+  sessionSidecarPath,
+  readSessionStateFile,
+  listSiblingSessionStates,
+  loadSessionState,
+  COMPACTED_AT_SUFFIX,
+  saveSessionState
+};

package/dist/{token-goat-chunk-SJHWVNDQ.mjs → token-goat-chunk-WDH44VAU.mjs}

@@ -1,11 +1,14 @@
 import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
-import {
-  estimateTokensFromLength
-} from "./token-goat-chunk-JB6QN6VF.mjs";
 import {
   matchRestOfLine
 } from "./token-goat-chunk-EVMZJ27Z.mjs";
+import {
+  estimateTokensFromLength
+} from "./token-goat-chunk-BFCWY73P.mjs";
+import {
+  quotedArg
+} from "./token-goat-chunk-GGGG7RWB.mjs";
 import {
   displaySafeText
 } from "./token-goat-chunk-FNFBKLRD.mjs";
@@ -174,7 +177,7 @@ function repeatedSkillBodyHint(injections) {
   if (worst.count < SKILL_BODY_REPEAT_THRESHOLD || worst.bytes < LARGE_SKILL_BODY_BYTES) return null;
   const skill = displaySafeText(worst.skill);
   const tokens = formatTokenEstimate(estimateTokensFromLength(worst.bytes));
-  return `The \`${skill}\` skill body has been injected ${worst.count} times this session (${formatBytes(worst.bytes)} total, ~${tokens} tok est). Slash expansion and the Skill tool both send the whole body every time, and no hook can intercept either. If it is already loaded, work from it instead of re-invoking; to reread one part, use \`token-goat skill-section ${skill} '<heading>'\`.`;
+  return `The \`${skill}\` skill body has been injected ${worst.count} times this session (${formatBytes(worst.bytes)} total, ~${tokens} tok est). Slash expansion and the Skill tool both send the whole body every time, and no hook can intercept either. If it is already loaded, work from it instead of re-invoking; to reread one part, use \`token-goat skill-section ${quotedArg(skill)} "<heading>"\`.`;
 }
 function readTranscriptTail(transcriptPath, maxBytes = RESIDENT_TAIL_MAX_BYTES) {
   let fd = null;

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

@@ -0,0 +1,107 @@
+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/shell.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path from "node:path";
+var WSL_LAUNCHER_SEGMENTS = /* @__PURE__ */ new Set(["system32", "syswow64", "windowsapps"]);
+function isExecutable(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function isWslLauncherDir(dir) {
+  return dir.toLowerCase().split(/[\\/]+/).some((seg) => WSL_LAUNCHER_SEGMENTS.has(seg));
+}
+function locateBashOnPath(pathValue, isExe = isExecutable) {
+  for (const dir of (pathValue ?? "").split(path.delimiter)) {
+    if (!dir || isWslLauncherDir(dir)) continue;
+    const cand = path.join(dir, "bash.exe");
+    if (isExe(cand)) return cand;
+  }
+  return null;
+}
+function knownGitBashPaths() {
+  const localPrograms = process.env["LOCALAPPDATA"] ? path.join(process.env["LOCALAPPDATA"], "Programs") : void 0;
+  const bases = [
+    process.env["ProgramFiles"],
+    process.env["ProgramFiles(x86)"],
+    process.env["ProgramW6432"],
+    localPrograms
+  ];
+  const out = [];
+  for (const base of bases) {
+    if (!base) continue;
+    out.push(path.join(base, "Git", "bin", "bash.exe"));
+    out.push(path.join(base, "Git", "usr", "bin", "bash.exe"));
+  }
+  return out;
+}
+function resolveWindowsBash() {
+  if (process.platform !== "win32") return null;
+  const override = process.env["TOKEN_GOAT_BASH"];
+  if (override && isExecutable(override)) return override;
+  const onPath = locateBashOnPath(process.env["PATH"]);
+  if (onPath) return onPath;
+  for (const cand of knownGitBashPaths()) {
+    if (isExecutable(cand)) return cand;
+  }
+  return null;
+}
+function wrappedShell() {
+  if (process.platform !== "win32") return true;
+  return resolveWindowsBash() ?? true;
+}
+function canRunWrappedShell() {
+  return process.platform !== "win32" || resolveWindowsBash() !== null;
+}
+function resolvePowerShell(env = process.env, isExe = isExecutable) {
+  const override = env["TOKEN_GOAT_POWERSHELL"] || env["TOKEN_GOAT_PWSH"];
+  if (override && isExe(override)) return override;
+  if (process.platform === "win32") {
+    for (const dir of (env["PATH"] ?? "").split(path.delimiter)) {
+      if (!dir) continue;
+      const cand = path.join(dir, "pwsh.exe");
+      if (isExe(cand)) return cand;
+    }
+    const systemRoot = env["SystemRoot"] ?? env["windir"] ?? "C:\\Windows";
+    const defaultPs = path.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+    if (isExe(defaultPs)) return defaultPs;
+    return "powershell.exe";
+  }
+  for (const dir of (env["PATH"] ?? "").split(path.delimiter)) {
+    if (!dir) continue;
+    const cand = path.join(dir, "pwsh");
+    if (isExe(cand)) return cand;
+  }
+  for (const cand of ["/usr/bin/pwsh", "/usr/local/bin/pwsh", "/opt/microsoft/powershell/7/pwsh"]) {
+    if (isExe(cand)) return cand;
+  }
+  return "pwsh";
+}
+function canRunPowerShell(env = process.env, isExe = isExecutable) {
+  if (process.platform === "win32") return true;
+  try {
+    const ps = resolvePowerShell(env, isExe);
+    return isExe(ps);
+  } catch {
+    return false;
+  }
+}
+function powerShellCommandArgs(command) {
+  return ["-NoProfile", "-NonInteractive", "-Command", command];
+}
+
+export {
+  wrappedShell,
+  canRunWrappedShell,
+  resolvePowerShell,
+  canRunPowerShell,
+  powerShellCommandArgs
+};