token-goat 2.9.29 → 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-ONXH6NZ5.mjs → token-goat-chunk-WDH44VAU.mjs}

@@ -1,25 +1,21 @@
 import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
+import {
+  matchRestOfLine
+} from "./token-goat-chunk-EVMZJ27Z.mjs";
 import {
   estimateTokensFromLength
-} from "./token-goat-chunk-52NSDWYY.mjs";
+} from "./token-goat-chunk-BFCWY73P.mjs";
+import {
+  quotedArg
+} from "./token-goat-chunk-GGGG7RWB.mjs";
 import {
   displaySafeText
-} from "./token-goat-chunk-NMTKNYGF.mjs";
+} from "./token-goat-chunk-FNFBKLRD.mjs";
 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");
-}
-
 // src/resident_context.ts
 init_define_import_meta_env();
 import * as fs from "node:fs";
@@ -59,14 +55,16 @@ function messageText(message) {
   return out;
 }
 function skillNameFromBody(text) {
-  const dir = /^Base directory for this skill:\s*(.+?)\s*$/m.exec(text);
-  if (dir?.[1] !== void 0) {
-    const segments = dir[1].split(/[\\/]/).filter((s) => s.length > 0);
+  const dirAt = /^Base directory for this skill:/m.exec(text);
+  const dir = dirAt === null ? null : matchRestOfLine(text, dirAt.index + dirAt[0].length, 0);
+  if (dir !== null) {
+    const segments = dir.split(/[\\/]/).filter((s) => s.length > 0);
     const last = segments[segments.length - 1];
     if (last !== void 0 && last.length > 0) return last;
   }
-  const heading = /^#\s+(.+?)\s*$/m.exec(text);
-  if (heading?.[1] !== void 0 && heading[1].length > 0) return heading[1];
+  const hashAt = /^#(?=\s)/m.exec(text);
+  const heading = hashAt === null ? null : matchRestOfLine(text, hashAt.index + 1, 1);
+  if (heading !== null && heading.length > 0) return heading;
   return null;
 }
 function readTaskList(attachment, bytes) {
@@ -111,9 +109,9 @@ function collectInvokedSkills(acc, record) {
 function skillName(skill) {
   const name = skill["name"];
   if (typeof name === "string" && name.trim() !== "") return name.trim();
-  const path2 = skill["path"];
-  if (typeof path2 !== "string") return null;
-  const segments = path2.split(/[\\/]/).filter((part) => part !== "");
+  const path = skill["path"];
+  if (typeof path !== "string") return null;
+  const segments = path.split(/[\\/]/).filter((part) => part !== "");
   const last = segments[segments.length - 1];
   return last === void 0 || last === "" ? null : last;
 }
@@ -179,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;
@@ -225,7 +223,6 @@ function accumulateResidentLines(lines) {
 }
 
 export {
-  claudeConfigDir,
   createResidentContextStats,
   accumulateResidentLine,
   summarizeResidentContext,