token-goat 2.9.19 → 2.9.21

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

@@ -0,0 +1,1989 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  claudeConfigDir,
+  readTranscriptTail
+} from "./token-goat-chunk-MEKVJZUN.mjs";
+import {
+  DEFAULT_MAX_AGE_MS,
+  DEFAULT_MAX_COUNT,
+  recordStat,
+  redactSecrets
+} from "./token-goat-chunk-PHDNWISV.mjs";
+import {
+  detectHarness,
+  isAutoTriggerMultiplierExplicit,
+  loadConfig,
+  shortFingerprint
+} from "./token-goat-chunk-M6CDVASA.mjs";
+import {
+  registerReset
+} from "./token-goat-chunk-EEIDFMEM.mjs";
+import {
+  LOCK_WAIT_MS_HARDENED,
+  atomicWriteText,
+  dataDir,
+  ensureDirSync,
+  foldPath,
+  isCodeFenceDelimiter,
+  normalizePathForwardSlash,
+  sanitizeIdForFilename,
+  stripLower,
+  tokenGoatHome,
+  withFileLock
+} from "./token-goat-chunk-TGBSMHPM.mjs";
+import {
+  normalizePath
+} from "./token-goat-chunk-NMTKNYGF.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/session.ts
+init_define_import_meta_env();
+import { randomBytes, randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+var _files = /* @__PURE__ */ new Map();
+var _filesAtLoad = /* @__PURE__ */ new Map();
+var _filesFullReadCountAtLoad = /* @__PURE__ */ new Map();
+var _hintsShown = /* @__PURE__ */ new Set();
+var _scheduledPromptCounts = /* @__PURE__ */ new Map();
+var _webFetches = /* @__PURE__ */ new Map();
+var _bashOutputs = /* @__PURE__ */ new Map();
+var _grepQueries = /* @__PURE__ */ new Map();
+var _globQueries = /* @__PURE__ */ new Map();
+var _lastTabContext = null;
+var _seenImageHashes = [];
+var _outstandingAgentSpawns = [];
+var _outstandingAgentSpawnsAtLoad = [];
+var _bashReruns = /* @__PURE__ */ new Set();
+var _curlDownloads = /* @__PURE__ */ new Map();
+var _curlDownloadsAtLoad = /* @__PURE__ */ new Map();
+var _fileLineRanges = /* @__PURE__ */ new Map();
+var _fileServedOutputs = /* @__PURE__ */ new Map();
+var _fileLineRangesAtLoad = /* @__PURE__ */ new Map();
+var _fileServedOutputsAtLoad = /* @__PURE__ */ new Map();
+var _compactedAt = 0;
+var _cliReads = /* @__PURE__ */ new Set();
+var _pendingLargeFileHints = /* @__PURE__ */ new Map();
+var _pendingLargeFileHintsAtLoad = /* @__PURE__ */ new Map();
+var _sessionId = null;
+var _transcriptPath = null;
+function fileSize(absPath) {
+  try {
+    return fs.statSync(absPath).size;
+  } catch {
+    return 0;
+  }
+}
+function resolveFilesKey(normalized) {
+  if (_files.has(normalized)) return normalized;
+  const folded = foldPath(normalized);
+  if (folded === normalized) return normalized;
+  for (const existingKey of _files.keys()) {
+    if (foldPath(existingKey) === folded) return existingKey;
+  }
+  return normalized;
+}
+function recordFileRead(filePath, isFullRead = true) {
+  const normalized = normalizePath(filePath);
+  const key = resolveFilesKey(normalized);
+  const now = Date.now();
+  const size = fileSize(normalized);
+  const prev = _files.get(key);
+  if (prev === void 0) {
+    _files.set(key, {
+      path: key,
+      readCount: 1,
+      lastReadAt: now,
+      wasEdited: false,
+      sizeBytes: size,
+      ...isFullRead ? { lastFullReadAt: now, fullReadCount: 1 } : {}
+    });
+    return;
+  }
+  _files.set(key, {
+    ...prev,
+    readCount: prev.readCount + 1,
+    lastReadAt: now,
+    sizeBytes: size,
+    ...isFullRead ? { lastFullReadAt: now, fullReadCount: (prev.fullReadCount ?? 0) + 1 } : {}
+  });
+}
+var MAX_SYMBOLS_PER_FILE = 25;
+function recordSymbolRead(filePath, symbol) {
+  const normalized = normalizePath(filePath);
+  const key = resolveFilesKey(normalized);
+  const prev = _files.get(key);
+  if (prev === void 0) {
+    _files.set(key, {
+      path: key,
+      readCount: 0,
+      lastReadAt: Date.now(),
+      wasEdited: false,
+      sizeBytes: fileSize(normalized),
+      symbols_read: [symbol]
+    });
+    return;
+  }
+  const existing = prev.symbols_read ?? [];
+  if (existing.includes(symbol)) return;
+  const symbols_read = [...existing, symbol].slice(-MAX_SYMBOLS_PER_FILE);
+  _files.set(key, { ...prev, symbols_read });
+}
+function filesReadCountAtLoad() {
+  return _filesAtLoad;
+}
+function filesFullReadCountAtLoad() {
+  return _filesFullReadCountAtLoad;
+}
+function recordFileEdit(filePath) {
+  const normalized = normalizePath(filePath);
+  const key = resolveFilesKey(normalized);
+  _fileLineRanges.delete(foldPath(normalized));
+  const prev = _files.get(key);
+  if (prev === void 0) {
+    _files.set(key, {
+      path: key,
+      readCount: 0,
+      lastReadAt: 0,
+      wasEdited: true,
+      sizeBytes: fileSize(normalized)
+    });
+    return;
+  }
+  _files.set(key, { ...prev, wasEdited: true });
+}
+function getSessionFiles() {
+  return _files;
+}
+function wasFileReadThisSession(filePath) {
+  const entry = _files.get(resolveFilesKey(normalizePath(filePath)));
+  return entry !== void 0 && entry.readCount > 0 && entry.lastReadAt >= _compactedAt;
+}
+function wasFileFullyReadThisSession(filePath) {
+  const entry = _files.get(resolveFilesKey(normalizePath(filePath)));
+  return entry !== void 0 && entry.lastFullReadAt !== void 0 && entry.lastFullReadAt >= _compactedAt;
+}
+function getCompactedAt() {
+  return _compactedAt;
+}
+function markCompacted(now = Date.now()) {
+  if (now <= _compactedAt) return;
+  _compactedAt = now;
+  _fileLineRanges = /* @__PURE__ */ new Map();
+  _fileServedOutputs = /* @__PURE__ */ new Map();
+}
+function getSessionFileEntry(filePath) {
+  return _files.get(resolveFilesKey(normalizePath(filePath)));
+}
+function wasHintShown(hintKey) {
+  return _hintsShown.has(hintKey);
+}
+function markHintShown(hintKey) {
+  _hintsShown.add(hintKey);
+}
+function recordScheduledPrompt(sessionId) {
+  const count = (_scheduledPromptCounts.get(sessionId) ?? 0) + 1;
+  _scheduledPromptCounts.set(sessionId, count);
+  return count;
+}
+function wasCliReadThisSession(cliReadKey) {
+  return _cliReads.has(cliReadKey);
+}
+function recordCliRead(cliReadKey) {
+  _cliReads.add(cliReadKey);
+}
+function recordLargeFileHintPending(filePath, sizeBytes) {
+  _pendingLargeFileHints.set(foldPath(normalizePath(filePath)), sizeBytes);
+}
+function takePendingLargeFileHint(filePath) {
+  const key = foldPath(normalizePath(filePath));
+  const size = _pendingLargeFileHints.get(key);
+  if (size === void 0) return null;
+  _pendingLargeFileHints.delete(key);
+  return size;
+}
+function consumedPendingLargeFileHintKeys() {
+  const consumed = [];
+  for (const key of _pendingLargeFileHintsAtLoad.keys()) {
+    if (!_pendingLargeFileHints.has(key)) consumed.push(key);
+  }
+  return consumed;
+}
+function pendingLargeFileHintsAtLoad() {
+  return _pendingLargeFileHintsAtLoad;
+}
+var WEB_FETCH_KEY_SEP = "\0";
+function webFetchKey(url, prompt) {
+  const digest = shortFingerprint(`${url}${WEB_FETCH_KEY_SEP}${prompt}`);
+  return [redactSecrets(url).text, redactSecrets(prompt).text, digest].join(WEB_FETCH_KEY_SEP);
+}
+function recordWebFetch(url, prompt, cacheId) {
+  _webFetches.set(webFetchKey(url, prompt), cacheId);
+}
+function migrateCurlDownloadKey(key) {
+  if (/^[0-9a-f]{16}$/.test(key)) return key;
+  return curlDownloadKey(key);
+}
+function migrateWebFetchKey(key) {
+  const parts = key.split(WEB_FETCH_KEY_SEP);
+  if (parts.length !== 2) return key;
+  return webFetchKey(parts[0] ?? "", parts[1] ?? "");
+}
+function getSessionWebFetches() {
+  return _webFetches;
+}
+function recordBashOutput(commandHash, outputId, _sizeBytes) {
+  _bashOutputs.set(commandHash, outputId);
+}
+function getSessionBashOutputs() {
+  return Array.from(_bashOutputs.entries());
+}
+function recordBashRerun(commandHash) {
+  _bashReruns.add(commandHash);
+}
+function getSessionBashReruns() {
+  return Array.from(_bashReruns);
+}
+function getBashOutputId(commandHash) {
+  return _bashOutputs.get(commandHash) ?? null;
+}
+function recordGrepQuery(signature, matchCount) {
+  _grepQueries.set(signature, matchCount);
+}
+function getGrepMatchCount(signature) {
+  return _grepQueries.get(signature) ?? null;
+}
+function recordGlobQuery(signature, matchCount) {
+  _globQueries.set(signature, matchCount);
+}
+function getGlobMatchCount(signature) {
+  return _globQueries.get(signature) ?? null;
+}
+function setLastTabContext(text) {
+  _lastTabContext = shortFingerprint(text);
+}
+function lastTabContextMatches(text) {
+  return _lastTabContext !== null && _lastTabContext === shortFingerprint(text);
+}
+var MAX_SEEN_IMAGE_HASHES = 16;
+function hasSeenImage(hash) {
+  return _seenImageHashes.includes(hash);
+}
+function recordSeenImage(hash) {
+  const at = _seenImageHashes.indexOf(hash);
+  if (at !== -1) _seenImageHashes.splice(at, 1);
+  _seenImageHashes.push(hash);
+  if (_seenImageHashes.length > MAX_SEEN_IMAGE_HASHES) {
+    _seenImageHashes.splice(0, _seenImageHashes.length - MAX_SEEN_IMAGE_HASHES);
+  }
+}
+var MAX_OUTSTANDING_AGENT_SPAWNS = 30;
+function recordOutstandingAgentSpawn(prompt) {
+  _outstandingAgentSpawns.push({ prompt: redactSecrets(prompt).text, ts: Date.now() });
+  if (_outstandingAgentSpawns.length > MAX_OUTSTANDING_AGENT_SPAWNS) {
+    _outstandingAgentSpawns.splice(0, _outstandingAgentSpawns.length - MAX_OUTSTANDING_AGENT_SPAWNS);
+  }
+}
+function getOutstandingAgentSpawns() {
+  return _outstandingAgentSpawns;
+}
+function removeOutstandingAgentSpawn(finishedPrompt) {
+  const idx = _outstandingAgentSpawns.findIndex((e) => finishedPrompt.startsWith(e.prompt));
+  if (idx !== -1) _outstandingAgentSpawns.splice(idx, 1);
+}
+function outstandingAgentSpawnKey(prompt, ts) {
+  return `${prompt} ${ts}`;
+}
+function outstandingAgentSpawnsAtLoad() {
+  return _outstandingAgentSpawnsAtLoad;
+}
+function consumedOutstandingAgentSpawnKeys() {
+  const currentKeys = new Set(_outstandingAgentSpawns.map((e) => outstandingAgentSpawnKey(e.prompt, e.ts)));
+  const consumed = [];
+  for (const e of _outstandingAgentSpawnsAtLoad) {
+    const key = outstandingAgentSpawnKey(e.prompt, e.ts);
+    if (!currentKeys.has(key)) consumed.push(key);
+  }
+  return consumed;
+}
+function curlDownloadKey(url) {
+  return shortFingerprint(url);
+}
+function recordCurlDownload(url, savedPath) {
+  _curlDownloads.set(curlDownloadKey(url), savedPath);
+}
+function getCurlDownloadPath(url) {
+  return _curlDownloads.get(curlDownloadKey(url)) ?? null;
+}
+function clearCurlDownload(url) {
+  _curlDownloads.delete(curlDownloadKey(url));
+}
+function curlDownloadsAtLoad() {
+  return _curlDownloadsAtLoad;
+}
+function consumedCurlDownloadKeys() {
+  const consumed = [];
+  for (const url of _curlDownloadsAtLoad.keys()) {
+    if (!_curlDownloads.has(url)) consumed.push(url);
+  }
+  return consumed;
+}
+function consumedFileLineRangeKeys() {
+  const consumed = [];
+  for (const key of _fileLineRangesAtLoad.keys()) {
+    if (!_fileLineRanges.has(key)) consumed.push(key);
+  }
+  return consumed;
+}
+function consumedFileServedOutputKeys() {
+  const consumed = [];
+  for (const key of _fileServedOutputsAtLoad.keys()) {
+    if (!_fileServedOutputs.has(key)) consumed.push(key);
+  }
+  return consumed;
+}
+var MAX_RANGES_PER_FILE = 64;
+function statIdentity(absPath) {
+  try {
+    const st = fs.statSync(absPath);
+    return { size: st.size, mtimeMs: st.mtimeMs };
+  } catch {
+    return void 0;
+  }
+}
+function recordFileLineRange(filePath, start, end) {
+  const normalized = normalizePath(filePath);
+  const key = foldPath(normalized);
+  const ranges = _fileLineRanges.get(key) ?? [];
+  if (!ranges.some(([s, e]) => s === start && e === end)) {
+    ranges.push([start, end]);
+    if (ranges.length > MAX_RANGES_PER_FILE) ranges.splice(0, ranges.length - MAX_RANGES_PER_FILE);
+    _fileLineRanges.set(key, ranges);
+  }
+  const entryKey = resolveFilesKey(normalized);
+  const entry = _files.get(entryKey);
+  const identity = statIdentity(normalized);
+  if (entry && identity) _files.set(entryKey, { ...entry, rangeFileIdentity: identity });
+}
+function getFileLineRanges(filePath) {
+  return _fileLineRanges.get(foldPath(normalizePath(filePath))) ?? [];
+}
+function resetFileLineRanges(filePath) {
+  _fileLineRanges.delete(foldPath(normalizePath(filePath)));
+}
+var MAX_SERVED_OUTPUTS_PER_FILE = 8;
+var GENERIC_SERVED_OUTPUT_KEY = "\0<bash-generic-served>";
+var GENERIC_SERVED_OUTPUT_FOLDED_KEY = foldPath(normalizePath(GENERIC_SERVED_OUTPUT_KEY));
+var MAX_GENERIC_SERVED_OUTPUTS = 32;
+function recordFileServedOutput(filePath, outputId) {
+  const key = foldPath(normalizePath(filePath));
+  const cap = key === GENERIC_SERVED_OUTPUT_FOLDED_KEY ? MAX_GENERIC_SERVED_OUTPUTS : MAX_SERVED_OUTPUTS_PER_FILE;
+  const ids = (_fileServedOutputs.get(key) ?? []).filter((id) => id !== outputId);
+  ids.push(outputId);
+  if (ids.length > cap) ids.splice(0, ids.length - cap);
+  _fileServedOutputs.set(key, ids);
+}
+function getFileServedOutputs(filePath) {
+  return _fileServedOutputs.get(foldPath(normalizePath(filePath))) ?? [];
+}
+function markFileTruncated(filePath, isFullRead = true) {
+  const normalized = normalizePath(filePath);
+  const key = resolveFilesKey(normalized);
+  const prev = _files.get(key);
+  const now = Date.now();
+  if (prev === void 0) {
+    _files.set(key, {
+      path: key,
+      readCount: 1,
+      lastReadAt: now,
+      wasEdited: false,
+      sizeBytes: fileSize(normalized),
+      wasTruncated: true,
+      ...isFullRead ? { lastFullReadAt: now, fullReadCount: 1 } : {}
+    });
+    return;
+  }
+  _files.set(key, { ...prev, wasTruncated: true });
+}
+function wasFileTruncatedThisSession(filePath) {
+  const entry = _files.get(resolveFilesKey(normalizePath(filePath)));
+  return entry?.wasTruncated === true;
+}
+function generateSessionId() {
+  try {
+    return randomUUID();
+  } catch {
+    return randomBytes(16).toString("hex");
+  }
+}
+function getSessionId() {
+  if (_sessionId !== null) return _sessionId;
+  const fromEnv = process.env["CLAUDE_CODE_SESSION_ID"];
+  _sessionId = fromEnv !== void 0 && fromEnv !== "" ? fromEnv : generateSessionId();
+  return _sessionId;
+}
+function setTranscriptPath(path4, sessionId) {
+  if (path4 === "") return;
+  _transcriptPath = { path: path4, sessionId };
+}
+function getTranscriptPath() {
+  if (_transcriptPath === null) return void 0;
+  return _transcriptPath.sessionId === getSessionId() ? _transcriptPath.path : void 0;
+}
+function exportSessionState() {
+  return {
+    files: Array.from(_files.values()),
+    hintsShown: Array.from(_hintsShown),
+    ..._scheduledPromptCounts.size > 0 ? { scheduledPromptCounts: Array.from(_scheduledPromptCounts.entries()) } : {},
+    webFetches: Array.from(_webFetches.entries()),
+    bashOutputs: Array.from(_bashOutputs.entries()),
+    bashReruns: Array.from(_bashReruns),
+    curlDownloads: Array.from(_curlDownloads.entries()),
+    fileLineRanges: Array.from(_fileLineRanges.entries()),
+    ..._fileServedOutputs.size > 0 ? { fileServedOutputs: Array.from(_fileServedOutputs.entries()) } : {},
+    cliReads: Array.from(_cliReads),
+    pendingLargeFileHints: Array.from(_pendingLargeFileHints.entries()),
+    grepQueries: Array.from(_grepQueries.entries()),
+    globQueries: Array.from(_globQueries.entries()),
+    outstandingAgentSpawns: _outstandingAgentSpawns.map((e) => [e.prompt, e.ts]),
+    ..._lastTabContext !== null ? { lastTabContextDigest: _lastTabContext } : {},
+    ..._seenImageHashes.length > 0 ? { seenImageHashes: [..._seenImageHashes] } : {},
+    ..._compactedAt > 0 ? { compactedAt: _compactedAt } : {}
+  };
+}
+function importSessionState(s) {
+  _files = /* @__PURE__ */ new Map();
+  for (const e of s.files) {
+    if (e && typeof e.path === "string") _files.set(e.path, e);
+  }
+  _filesAtLoad = new Map(Array.from(_files, ([key, e]) => [key, e.readCount]));
+  _filesFullReadCountAtLoad = new Map(Array.from(_files, ([key, e]) => [key, e.fullReadCount ?? 0]));
+  _hintsShown = new Set(s.hintsShown);
+  _scheduledPromptCounts = new Map(s.scheduledPromptCounts ?? []);
+  _webFetches = new Map(s.webFetches);
+  _bashOutputs = new Map(s.bashOutputs);
+  _bashReruns = new Set(s.bashReruns ?? []);
+  _curlDownloads = new Map(s.curlDownloads);
+  _curlDownloadsAtLoad = new Map(_curlDownloads);
+  _fileLineRanges = new Map(s.fileLineRanges ?? []);
+  _fileLineRangesAtLoad = new Map(_fileLineRanges);
+  _fileServedOutputs = new Map(s.fileServedOutputs ?? []);
+  _fileServedOutputsAtLoad = new Map(_fileServedOutputs);
+  _cliReads = new Set(s.cliReads ?? []);
+  _pendingLargeFileHints = new Map(s.pendingLargeFileHints ?? []);
+  _pendingLargeFileHintsAtLoad = new Map(_pendingLargeFileHints);
+  _grepQueries = new Map(s.grepQueries ?? []);
+  _globQueries = new Map(s.globQueries ?? []);
+  _outstandingAgentSpawns = (s.outstandingAgentSpawns ?? []).map(([prompt, ts]) => ({ prompt, ts }));
+  _outstandingAgentSpawnsAtLoad = [..._outstandingAgentSpawns];
+  _lastTabContext = s.lastTabContextDigest ?? null;
+  _seenImageHashes = [...s.seenImageHashes ?? []];
+  _compactedAt = s.compactedAt ?? 0;
+}
+registerReset(() => {
+  _files = /* @__PURE__ */ new Map();
+  _filesAtLoad = /* @__PURE__ */ new Map();
+  _filesFullReadCountAtLoad = /* @__PURE__ */ new Map();
+  _hintsShown = /* @__PURE__ */ new Set();
+  _scheduledPromptCounts = /* @__PURE__ */ new Map();
+  _webFetches = /* @__PURE__ */ new Map();
+  _bashOutputs = /* @__PURE__ */ new Map();
+  _bashReruns = /* @__PURE__ */ new Set();
+  _curlDownloads = /* @__PURE__ */ new Map();
+  _curlDownloadsAtLoad = /* @__PURE__ */ new Map();
+  _fileLineRanges = /* @__PURE__ */ new Map();
+  _fileLineRangesAtLoad = /* @__PURE__ */ new Map();
+  _fileServedOutputs = /* @__PURE__ */ new Map();
+  _fileServedOutputsAtLoad = /* @__PURE__ */ new Map();
+  _cliReads = /* @__PURE__ */ new Set();
+  _pendingLargeFileHints = /* @__PURE__ */ new Map();
+  _pendingLargeFileHintsAtLoad = /* @__PURE__ */ new Map();
+  _grepQueries = /* @__PURE__ */ new Map();
+  _globQueries = /* @__PURE__ */ new Map();
+  _outstandingAgentSpawns = [];
+  _outstandingAgentSpawnsAtLoad = [];
+  _lastTabContext = null;
+  _seenImageHashes = [];
+  _compactedAt = 0;
+  _sessionId = null;
+  _transcriptPath = null;
+});
+
+// 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 fs2 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;
+  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 (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"] } };
+  }
+  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 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 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"
+  ) : [];
+  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"]),
+    fileServedOutputs: asServedOutputs(o["fileServedOutputs"]),
+    cliReads,
+    bashReruns,
+    pendingLargeFileHints,
+    grepQueries,
+    globQueries,
+    outstandingAgentSpawns,
+    ...typeof o["lastTabContextDigest"] === "string" ? { lastTabContextDigest: o["lastTabContextDigest"] } : {},
+    ...seenImageHashes.length > 0 ? { seenImageHashes } : {},
+    ...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 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_KEY2 = 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_KEY2 ? 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 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 clearedRangeFiles = new Set(consumedFileLineRangeKeys());
+  const clearedServedFiles = new Set(consumedFileServedOutputKeys());
+  const diskRanges = rawDiskRanges.filter(([path4]) => !clearedRangeFiles.has(path4));
+  const diskServed = rawDiskServed.filter(([path4]) => !clearedServedFiles.has(path4));
+  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: mergeLineRanges(diskRanges, memRanges),
+    fileServedOutputs: mergeServedOutputs(diskServed, memServed),
+    ...compactedAt > 0 ? { compactedAt } : {},
+    cliReads: Array.from(/* @__PURE__ */ new Set([...disk.cliReads ?? [], ...mem.cliReads ?? []])),
+    bashReruns: Array.from(/* @__PURE__ */ new Set([...disk.bashReruns ?? [], ...mem.bashReruns ?? []])),
+    pendingLargeFileHints: mergePendingLargeFileHints(disk.pendingLargeFileHints ?? [], mem.pendingLargeFileHints ?? []),
+    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 ?? []),
+    // 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 {
+    if (!fs2.existsSync(p)) return null;
+    return coerce(JSON.parse(fs2.readFileSync(p, "utf8")));
+  } 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 (!fs2.existsSync(dir)) return out;
+    for (const file of fs2.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;
+}
+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 dir = path2.dirname(p);
+    if (!fs2.existsSync(dir)) ensureDirSync(dir);
+    const mem = exportSessionState();
+    const writeMerged = () => {
+      const disk = readDiskState(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 = redactSecrets(JSON.stringify(merged)).text;
+      } catch {
+        return true;
+      }
+      atomicWriteText(p, json);
+      return true;
+    };
+    if (withFileLock(`${p}.lock`, writeMerged, { waitMs: LOCK_WAIT_MS_HARDENED }) === void 0) writeMerged();
+  } catch {
+  }
+}
+
+// src/skill_cache.ts
+init_define_import_meta_env();
+import * as fs3 from "fs/promises";
+import { resolve } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync2, existsSync as existsSync2, statSync as statSync2, unlinkSync } from "node:fs";
+var COMPACT_END_MARKER = "<!-- COMPACT_END -->";
+var SKILLS_OUTPUT_SUBDIR = "skills";
+var _skillOutputsDirOverride = null;
+var _skillsSourceDirOverride = null;
+var _pluginsManifestPathOverride = null;
+registerReset(() => {
+  _skillOutputsDirOverride = null;
+  _skillsSourceDirOverride = null;
+  _pluginsManifestPathOverride = null;
+  inProcessHitLockQueues.clear();
+});
+function skillOutputsDir() {
+  if (_skillOutputsDirOverride) return _skillOutputsDirOverride;
+  return resolve(dataDir(), SKILLS_OUTPUT_SUBDIR);
+}
+function skillsSourceDir() {
+  if (_skillsSourceDirOverride) return _skillsSourceDirOverride;
+  return resolve(claudeConfigDir(), "skills");
+}
+async function ensureSkillsDir() {
+  try {
+    ensureDirSync(skillOutputsDir());
+  } catch {
+  }
+}
+function contentHash(content) {
+  return shortFingerprint(content);
+}
+function safeSessionFragment(sessionId) {
+  let result = "";
+  for (const c of sessionId) {
+    if (result.length >= 16) break;
+    if (/[a-zA-Z0-9_-]/.test(c)) {
+      result += c;
+    }
+  }
+  return result.slice(0, 16);
+}
+function safeSkillName(skillName) {
+  if (!skillName || skillName.length > 128) return null;
+  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 sessionSkillPrefix(sessionId, skillName) {
+  const safeSession = safeSessionFragment(sessionId);
+  return `${safeSession}-${sanitizeSkillId(skillName)}-`;
+}
+function outputIdFor(sessionId, skillName, contentSha) {
+  return `${sessionSkillPrefix(sessionId, skillName)}${contentSha}`;
+}
+function* contentLineEntries(lines) {
+  let inCodeBlock = false;
+  for (let i = 0; i < lines.length; i++) {
+    const stripped = lines[i].trim();
+    if (isCodeFenceDelimiter(stripped)) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (!inCodeBlock) yield [i, stripped];
+  }
+}
+function headingLevel(stripped) {
+  const match = stripped.match(/^(#{1,6}) (.*)$/);
+  if (!match) return 0;
+  return match[2].trim() ? match[1].length : 0;
+}
+function collectSectionBody(lines, startIdx, matchedLevel) {
+  const bodyLines = [];
+  let inBodyCodeBlock = false;
+  for (let j = startIdx; j < lines.length; j++) {
+    const stripped = lines[j].trim();
+    if (isCodeFenceDelimiter(stripped)) {
+      inBodyCodeBlock = !inBodyCodeBlock;
+    }
+    if (!inBodyCodeBlock) {
+      const level = headingLevel(stripped);
+      if (level >= 1 && level <= matchedLevel) break;
+    }
+    bodyLines.push(lines[j]);
+  }
+  return bodyLines;
+}
+function extractCompactFromMarker(body) {
+  if (!body || !body.includes(COMPACT_END_MARKER)) {
+    return null;
+  }
+  const lines = body.split("\n");
+  for (const [i, stripped] of contentLineEntries(lines)) {
+    if (stripped === COMPACT_END_MARKER) {
+      const preMarker = lines.slice(0, i).join("\n").trim();
+      return preMarker || null;
+    }
+  }
+  return null;
+}
+function parseSectionOrdinal(heading) {
+  const match = heading.match(/^(.*?)(?:#(\d+))?$/);
+  if (!match) return [heading, 1];
+  const baseHeading = match[1] || heading;
+  const ordinal = match[2] ? Math.max(1, parseInt(match[2], 10)) : 1;
+  return [baseHeading, ordinal];
+}
+function extractNamedSection(body, heading) {
+  if (!body || !heading) return null;
+  const [baseHeading, ordinal] = parseSectionOrdinal(heading);
+  const headingLower = stripLower(baseHeading);
+  const lines = body.split("\n");
+  let matchCount = 0;
+  let startIdx = -1;
+  let matchedLevel = 0;
+  for (const [i, stripped] of contentLineEntries(lines)) {
+    const level = headingLevel(stripped);
+    if (level >= 1 && level <= 3) {
+      const headingText = stripLower(stripped.slice(level));
+      if (headingText === headingLower) {
+        matchCount++;
+        if (matchCount === ordinal) {
+          startIdx = i + 1;
+          matchedLevel = level;
+          break;
+        }
+      }
+    }
+  }
+  if (startIdx === -1) return null;
+  const text = collectSectionBody(lines, startIdx, matchedLevel).join("\n").trim();
+  return text || null;
+}
+function extractChecklistSection(body) {
+  if (!body) return null;
+  const checklistHeadings = ["checklist", "check list", "to-do", "todo"];
+  const lines = body.split("\n");
+  let bestPriority = checklistHeadings.length;
+  let bestStart = -1;
+  for (const [i, stripped] of contentLineEntries(lines)) {
+    if (stripped.startsWith("## ") && stripped.length > 3) {
+      const headingText = stripLower(stripped.slice(3));
+      for (let p = 0; p < checklistHeadings.length; p++) {
+        if (headingText.startsWith(checklistHeadings[p])) {
+          if (p < bestPriority) {
+            bestPriority = p;
+            bestStart = i;
+          }
+          break;
+        }
+      }
+    }
+  }
+  if (bestStart === -1) return null;
+  const bodyLines = collectSectionBody(lines, bestStart + 1, 2);
+  let text = bodyLines.join("\n").trim();
+  const maxChars = 2e3;
+  if (text.length > maxChars) {
+    const cut = maxChars - 1;
+    text = text.slice(0, cut).trimEnd() + "\u2026";
+  }
+  return text || null;
+}
+async function listOutputs() {
+  try {
+    const dir = skillOutputsDir();
+    const entries = await fs3.readdir(dir, { withFileTypes: true });
+    const metas = [];
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".meta")) {
+        continue;
+      }
+      try {
+        const content = await fs3.readFile(resolve(dir, entry.name), "utf-8");
+        const meta = JSON.parse(content);
+        metas.push(meta);
+      } catch {
+        continue;
+      }
+    }
+    return metas;
+  } catch {
+    return [];
+  }
+}
+async function hasSessionOutput(sessionId, skillName) {
+  try {
+    if (!sessionId) return false;
+    const name = safeSkillName(skillName);
+    if (!name) return false;
+    const safeSession = safeSessionFragment(sessionId);
+    const metas = await listOutputs();
+    return metas.some((m) => m.skillName === name && m.outputId.startsWith(`${safeSession}-`));
+  } catch {
+    return false;
+  }
+}
+async function sessionOutputBodyBytes(sessionId, skillName) {
+  try {
+    if (!sessionId) return null;
+    const name = safeSkillName(skillName);
+    if (!name) return null;
+    const safeSession = safeSessionFragment(sessionId);
+    const metas = await listOutputs();
+    const matches = metas.filter((m) => m.skillName === name && m.outputId.startsWith(`${safeSession}-`));
+    if (matches.length === 0) return null;
+    matches.sort((a, b) => b.ts - a.ts);
+    return matches[0].bodyBytes;
+  } catch {
+    return null;
+  }
+}
+async function findCrossSessionEntry(skillName, contentSha) {
+  const name = safeSkillName(skillName);
+  if (!name || !contentSha) return null;
+  try {
+    const metas = await listOutputs();
+    for (const meta of metas) {
+      if (meta.skillName !== name || meta.contentSha !== contentSha) {
+        continue;
+      }
+      const dir = skillOutputsDir();
+      const bodyPath = resolve(dir, `${meta.outputId}.txt`);
+      try {
+        const bodyExists = await fs3.access(bodyPath).then(() => true).catch(() => false);
+        if (bodyExists) {
+          return meta;
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+async function storeOutput(sessionId, skillName, body, opts) {
+  try {
+    await ensureSkillsDir();
+    const name = safeSkillName(skillName);
+    if (!name) return null;
+    const sha = contentHash(body);
+    const existing = await findCrossSessionEntry(skillName, sha);
+    if (existing) {
+      return existing;
+    }
+    const outId = outputIdFor(sessionId, skillName, sha);
+    const dir = skillOutputsDir();
+    const ts = Date.now();
+    const bodyBytes = Buffer.byteLength(body, "utf-8");
+    const truncated = bodyBytes > 256 * 1024;
+    const redactedBody = redactSecrets(body);
+    if (redactedBody.count > 0) recordStat("secret_redacted", 0, redactedBody.count, void 0, SKILLS_OUTPUT_SUBDIR);
+    let storedBody = redactedBody.text;
+    if (truncated) {
+      const buf = Buffer.from(redactedBody.text, "utf-8");
+      let truncStart = Math.max(0, buf.length - 262144);
+      if (truncStart < buf.length) {
+        const byte = buf[truncStart];
+        if ((byte & 192) === 128) {
+          let charStart = truncStart - 1;
+          while (charStart >= 0 && (buf[charStart] & 192) === 128) {
+            charStart--;
+          }
+          if (charStart >= 0) {
+            const leadByte = buf[charStart];
+            let charLen = 1;
+            if ((leadByte & 128) === 0) charLen = 1;
+            else if ((leadByte & 224) === 192) charLen = 2;
+            else if ((leadByte & 240) === 224) charLen = 3;
+            else if ((leadByte & 248) === 240) charLen = 4;
+            truncStart = charStart + charLen;
+          }
+        }
+      }
+      const truncBuf = buf.slice(truncStart);
+      storedBody = truncBuf.toString("utf-8");
+    }
+    await atomicWriteText(resolve(dir, `${outId}.txt`), storedBody);
+    const meta = {
+      outputId: outId,
+      skillName: name,
+      contentSha: sha,
+      bodyBytes,
+      ts,
+      truncated,
+      sourcePath: opts?.sourcePath || ""
+    };
+    await atomicWriteText(resolve(dir, `${outId}.meta`), JSON.stringify(meta, null, 2));
+    pruneSkillOutputs();
+    return meta;
+  } catch {
+    return null;
+  }
+}
+async function storeCompact(sessionId, skillName, compactText, sourceSha) {
+  try {
+    await ensureSkillsDir();
+    const name = safeSkillName(skillName);
+    if (!name) return;
+    const safeSession = safeSessionFragment(sessionId);
+    const fileId = `${safeSession}@${sanitizeSkillId(name)}@compact`;
+    const dir = skillOutputsDir();
+    const redacted = redactSecrets(compactText);
+    if (redacted.count > 0) recordStat("secret_redacted", 0, redacted.count, void 0, SKILLS_OUTPUT_SUBDIR);
+    let text = redacted.text;
+    if (sourceSha) {
+      text = `<!-- source_sha: ${sourceSha.slice(0, 12)} -->
+${text}`;
+    }
+    await atomicWriteText(resolve(dir, fileId), text);
+  } catch {
+  }
+}
+function compactSessionSuffix(skillName) {
+  const name = safeSkillName(skillName);
+  return name ? `@${sanitizeSkillId(name)}@compact` : null;
+}
+function matchesCompactSuffix(entryName, isFile, suffix) {
+  return isFile && entryName.endsWith("@compact") && entryName.endsWith(suffix);
+}
+function getCompactAnySessionSync(skillName) {
+  try {
+    const suffix = compactSessionSuffix(skillName);
+    if (!suffix) return null;
+    const dir = skillOutputsDir();
+    const entries = readdirSync2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!matchesCompactSuffix(entry.name, entry.isFile(), suffix)) continue;
+      try {
+        const text = readFileSync2(resolve(dir, entry.name), "utf-8");
+        if (text.trim()) return text;
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function extractSourceShaFromCompact(compactText) {
+  if (!compactText) return null;
+  const match = compactText.match(/<!--\s*source_sha:\s*([a-f0-9]{12})\s*-->/);
+  return match ? match[1] : null;
+}
+function isCompactStale(compactText, skillName, currentBodySha) {
+  if (!compactText) return null;
+  const embeddedSha = extractSourceShaFromCompact(compactText);
+  if (!embeddedSha) return null;
+  const currentSha = currentBodySha.slice(0, 12);
+  return embeddedSha !== currentSha;
+}
+async function readSkillHits(skillName) {
+  try {
+    const name = safeSkillName(skillName);
+    if (!name) return { count: 0, lastTs: 0 };
+    const dir = skillOutputsDir();
+    const hitsFile = resolve(dir, `${sanitizeSkillId(name)}.hits`);
+    const content = await fs3.readFile(hitsFile, "utf-8").catch(() => null);
+    if (content) {
+      const parsed = JSON.parse(content);
+      return parsed;
+    }
+  } catch {
+  }
+  return { count: 0, lastTs: 0 };
+}
+var SKILL_HIT_LOCK_RETRY_MS = 5;
+var SKILL_HIT_LOCK_STALE_MS = 5e3;
+var SKILL_HIT_LOCK_MAX_ATTEMPTS = Math.ceil(SKILL_HIT_LOCK_STALE_MS / SKILL_HIT_LOCK_RETRY_MS);
+var inProcessHitLockQueues = /* @__PURE__ */ new Map();
+function runExclusiveInProcess(key, fn) {
+  const prior = inProcessHitLockQueues.get(key) ?? Promise.resolve();
+  const run = prior.then(fn, fn);
+  inProcessHitLockQueues.set(
+    key,
+    run.then(
+      () => void 0,
+      () => void 0
+    )
+  );
+  return run;
+}
+async function acquireSkillHitLock(lockPath) {
+  for (let attempt = 0; attempt < SKILL_HIT_LOCK_MAX_ATTEMPTS; attempt++) {
+    try {
+      await fs3.mkdir(lockPath);
+      return true;
+    } catch (err) {
+      if (err.code !== "EEXIST") return false;
+      try {
+        const st = await fs3.stat(lockPath);
+        if (Date.now() - st.mtimeMs > SKILL_HIT_LOCK_STALE_MS) {
+          await fs3.rmdir(lockPath).catch(() => {
+          });
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      await new Promise((r) => setTimeout(r, SKILL_HIT_LOCK_RETRY_MS));
+    }
+  }
+  return false;
+}
+async function incrementSkillHit(skillName) {
+  try {
+    const name = safeSkillName(skillName);
+    if (!name) return;
+    await ensureSkillsDir();
+    const dir = skillOutputsDir();
+    const hitsFile = resolve(dir, `${sanitizeSkillId(name)}.hits`);
+    const lockPath = `${hitsFile}.lock`;
+    await runExclusiveInProcess(lockPath, async () => {
+      const locked = await acquireSkillHitLock(lockPath);
+      if (!locked) return;
+      try {
+        const hits = await readSkillHits(name);
+        hits.count++;
+        hits.lastTs = Date.now();
+        await atomicWriteText(hitsFile, JSON.stringify(hits, null, 2));
+      } finally {
+        await fs3.rmdir(lockPath).catch(() => {
+        });
+      }
+    });
+  } catch {
+  }
+}
+function formatAge(ageMs) {
+  const s = Math.floor(ageMs / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h`;
+  const d = Math.floor(h / 24);
+  return `${d}d`;
+}
+async function listSkills(sessionId) {
+  try {
+    const metas = (await listOutputs()).sort((a, b) => b.ts - a.ts);
+    const results = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const meta of metas) {
+      if (sessionId && !meta.outputId.startsWith(`${safeSessionFragment(sessionId)}-`)) {
+        continue;
+      }
+      if (seen.has(meta.skillName)) continue;
+      seen.add(meta.skillName);
+      const dir = skillOutputsDir();
+      const sanitizedName = sanitizeSkillId(meta.skillName);
+      const outputSuffix = `-${sanitizedName}-${meta.contentSha}`;
+      const safeSession = meta.outputId.endsWith(outputSuffix) ? meta.outputId.slice(0, meta.outputId.length - outputSuffix.length) : safeSessionFragment(meta.outputId.split("-")[0]);
+      const compactFileId = `${safeSession}@${sanitizedName}@compact`;
+      let compactLen = 0;
+      let compactText = "";
+      try {
+        const stat2 = await fs3.stat(resolve(dir, compactFileId));
+        compactLen = stat2.size;
+        compactText = await fs3.readFile(resolve(dir, compactFileId), "utf-8").catch(() => "");
+      } catch {
+        compactLen = 0;
+      }
+      const hasMarker = extractCompactFromMarker(
+        await fs3.readFile(resolve(dir, `${meta.outputId}.txt`), "utf-8").catch(() => "")
+      ) !== null;
+      const compactStale = isCompactStale(compactText, meta.skillName, meta.contentSha);
+      const { count: hitCount } = await readSkillHits(meta.skillName);
+      const ageMs = Date.now() - meta.ts;
+      results.push({
+        name: meta.skillName,
+        bodyLen: meta.bodyBytes,
+        compactLen,
+        hasMarker,
+        compactStale,
+        hitCount,
+        ageMs
+      });
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+async function getSkillFilePath(skillName) {
+  try {
+    const name = safeSkillName(skillName);
+    if (!name) return null;
+    const metas = await listOutputs();
+    for (const meta of metas) {
+      if (meta.skillName === name && meta.sourcePath) {
+        return meta.sourcePath;
+      }
+    }
+    return await installedSkillPath(name);
+  } catch {
+    return null;
+  }
+}
+async function resolvePluginSkillPath(pluginName, skillSlug) {
+  const manifestPath = _pluginsManifestPathOverride ?? resolve(claudeConfigDir(), "plugins", "installed_plugins.json");
+  let raw;
+  try {
+    raw = await fs3.readFile(manifestPath, "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const plugins = parsed["plugins"];
+  if (typeof plugins !== "object" || plugins === null) return null;
+  for (const [key, entries] of Object.entries(plugins)) {
+    if (key !== pluginName && !key.startsWith(pluginName + "@")) continue;
+    if (!Array.isArray(entries)) continue;
+    for (const entry of entries) {
+      if (typeof entry !== "object" || entry === null) continue;
+      const installPath = entry["installPath"];
+      if (typeof installPath !== "string" || installPath === "") continue;
+      const diskPath = resolve(installPath, "skills", skillSlug, "SKILL.md");
+      try {
+        await fs3.access(diskPath);
+        return diskPath;
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+async function installedSkillPath(skillName) {
+  const name = safeSkillName(skillName);
+  if (!name) return null;
+  const colonIdx = name.indexOf(":");
+  if (colonIdx > 0 && colonIdx < name.length - 1) {
+    const pluginPath = await resolvePluginSkillPath(name.slice(0, colonIdx), name.slice(colonIdx + 1));
+    if (pluginPath !== null) return pluginPath;
+  }
+  const diskPath = resolve(skillsSourceDir(), name, "SKILL.md");
+  try {
+    await fs3.access(diskPath);
+    return diskPath;
+  } catch {
+    return null;
+  }
+}
+function pruneSkillOutputs(maxCount = DEFAULT_MAX_COUNT, maxAgeMs = DEFAULT_MAX_AGE_MS) {
+  const dir = skillOutputsDir();
+  let removed = 0;
+  try {
+    if (!existsSync2(dir)) return 0;
+    const cutoff = Date.now() - maxAgeMs;
+    const entries = [];
+    for (const file of readdirSync2(dir)) {
+      if (!file.endsWith(".meta")) continue;
+      const outputId = file.slice(0, -".meta".length);
+      let ts;
+      try {
+        const parsed = JSON.parse(readFileSync2(resolve(dir, file), "utf-8"));
+        ts = parsed.ts;
+      } catch {
+        try {
+          ts = statSync2(resolve(dir, file)).mtimeMs;
+        } catch {
+          continue;
+        }
+      }
+      entries.push({ outputId, ts });
+    }
+    const removeEntry = (outputId) => {
+      for (const ext of [".meta", ".txt"]) {
+        try {
+          unlinkSync(resolve(dir, `${outputId}${ext}`));
+        } catch {
+        }
+      }
+      removed++;
+    };
+    const kept = [];
+    for (const entry of entries) {
+      if (entry.ts < cutoff) {
+        removeEntry(entry.outputId);
+      } else {
+        kept.push(entry);
+      }
+    }
+    if (kept.length > maxCount) {
+      kept.sort((a, b) => a.ts - b.ts);
+      for (const entry of kept.slice(0, kept.length - maxCount)) {
+        removeEntry(entry.outputId);
+      }
+    }
+  } catch {
+    return removed;
+  }
+  return removed;
+}
+
+// src/compact.ts
+init_define_import_meta_env();
+import * as fs4 from "node:fs";
+import * as path3 from "node:path";
+var CONTEXT_AUTOCOMPACT_TOKENS = 66e4;
+var CATALOG_TOKENS = 10800;
+var CONTEXT_TIER_WARM = 0.5;
+var CONTEXT_TIER_HOT = 0.7;
+var CONTEXT_TIER_CRITICAL = 0.85;
+var NOISE_EXTS = /* @__PURE__ */ new Set([
+  ".pyc",
+  ".pyo",
+  ".pyd",
+  ".class",
+  ".o",
+  ".obj",
+  ".a",
+  ".lib",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".log",
+  ".jsonl",
+  ".tmp",
+  ".temp",
+  ".swp",
+  ".swo",
+  ".bak",
+  ".pid",
+  ".lock",
+  ".map",
+  ".wasm",
+  ".gz",
+  ".zip",
+  ".tar",
+  ".tgz",
+  ".db",
+  ".sqlite",
+  ".sqlite3",
+  ".db3",
+  ".d.ts",
+  ".snap",
+  ".eot",
+  ".ttf",
+  ".woff",
+  ".woff2",
+  ".ico",
+  ".pdb",
+  ".exe",
+  ".bin"
+]);
+var NOISE_BASENAMES = /* @__PURE__ */ new Set([
+  ".ds_store",
+  "thumbs.db",
+  "desktop.ini",
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "poetry.lock",
+  "uv.lock",
+  "pdm.lock",
+  "cargo.lock",
+  "composer.lock",
+  "gemfile.lock",
+  "coverage.xml",
+  ".coverage",
+  "lcov.info"
+]);
+var NOISE_SEGMENTS = [
+  "/__pycache__/",
+  "/.git/",
+  "/node_modules/",
+  "/.venv/",
+  "/venv/",
+  "/dist/",
+  "/build/",
+  "/.mypy_cache/",
+  "/.pytest_cache/",
+  "/.ruff_cache/",
+  "/appdata/local/temp/",
+  "/appdata/roaming/",
+  "/tmp/",
+  "/.next/",
+  "/.nuxt/",
+  "/.svelte-kit/",
+  "/.turbo/",
+  "/.parcel-cache/",
+  "/.cache/",
+  "/.tox/",
+  "/coverage/",
+  "/.nyc_output/",
+  "/site-packages/",
+  ".egg-info/",
+  "/target/",
+  "/__snapshots__/"
+];
+var HARNESS_MULTIPLIER_DEFAULTS = {
+  claudecode: 2,
+  codex: 1.5,
+  opencode: 2.5,
+  gemini: 3,
+  openclaw: 1,
+  pi: 1,
+  hermes: 1,
+  generic: 1
+};
+function tierForFraction(fill) {
+  if (fill >= CONTEXT_TIER_CRITICAL) return "critical";
+  if (fill >= CONTEXT_TIER_HOT) return "hot";
+  if (fill >= CONTEXT_TIER_WARM) return "warm";
+  return "cool";
+}
+function pressureRawTotal(cache) {
+  const skillTokens = cache.loadedSkillTotalTokens ?? 0;
+  const bashCount = (cache.bashOutputs ?? []).length;
+  const webCount = (cache.webFetches ?? []).length;
+  const files = cache.files ?? [];
+  const readCount = files.length;
+  return skillTokens + CATALOG_TOKENS + bashCount * 500 + webCount * 1e3 + readCount * 200;
+}
+var PROMPT_MEASURE_TAIL_BYTES = 1048576;
+function extractUsageTotal(record) {
+  if (record === null || typeof record !== "object") return null;
+  if (record["type"] !== "assistant") return null;
+  const message = record["message"];
+  if (message === null || typeof message !== "object") return null;
+  const usage = message["usage"];
+  if (usage === null || typeof usage !== "object") return null;
+  const u = usage;
+  const input = u["input_tokens"];
+  const cacheCreation = u["cache_creation_input_tokens"];
+  const cacheRead = u["cache_read_input_tokens"];
+  const output = u["output_tokens"];
+  if (typeof input !== "number" || typeof cacheCreation !== "number" || typeof cacheRead !== "number" || typeof output !== "number") {
+    return null;
+  }
+  return input + cacheCreation + cacheRead + output;
+}
+function measurePromptTokens(transcriptPath) {
+  try {
+    const lines = readTranscriptTail(transcriptPath, PROMPT_MEASURE_TAIL_BYTES);
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i];
+      if (line === void 0) continue;
+      const trimmed = line.trim();
+      if (trimmed === "") continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      const total = extractUsageTotal(parsed);
+      if (total !== null) return total;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getEffectiveAutoTriggerWindow() {
+  const ca = loadConfig().compact_assist;
+  const isConfigDefault = !isAutoTriggerMultiplierExplicit();
+  const multiplier = getAutoTriggerMultiplier(
+    ca.harness === "auto" ? { configExplicitMultiplier: ca.auto_trigger_multiplier, isConfigDefault } : { configExplicitMultiplier: ca.auto_trigger_multiplier, harness: ca.harness, isConfigDefault }
+  );
+  return CONTEXT_AUTOCOMPACT_TOKENS * multiplier;
+}
+function getContextPressure(cache, transcriptPath) {
+  try {
+    const window = getEffectiveAutoTriggerWindow();
+    if (transcriptPath) {
+      const measured = measurePromptTokens(transcriptPath);
+      if (measured !== null) {
+        const fill2 = measured / window;
+        return { fillFraction: fill2, tier: tierForFraction(fill2) };
+      }
+    }
+    if (!cache) {
+      return { fillFraction: 0, tier: "cool" };
+    }
+    const total = pressureRawTotal(cache);
+    const fill = total / window;
+    return {
+      fillFraction: fill,
+      tier: tierForFraction(fill)
+    };
+  } catch {
+    return { fillFraction: 0, tier: "cool" };
+  }
+}
+function getAutoTriggerMultiplier(opts) {
+  const config = opts?.configExplicitMultiplier ?? 2;
+  let isDefault = opts?.isConfigDefault;
+  if (isDefault === void 0) {
+    isDefault = config === 2;
+  }
+  if (!isDefault && opts?.configExplicitMultiplier !== void 0) {
+    return Math.max(1, Math.min(10, opts.configExplicitMultiplier));
+  }
+  const harness = opts?.harness ?? detectHarness();
+  return Math.max(1, Math.min(10, HARNESS_MULTIPLIER_DEFAULTS[harness] ?? 1));
+}
+function isNoisePath(inputPath) {
+  if (!inputPath) {
+    return false;
+  }
+  const p = normalizePathForwardSlash(inputPath, true);
+  for (const segment of NOISE_SEGMENTS) {
+    if (p.includes(segment)) {
+      return true;
+    }
+  }
+  const slashIdx = p.lastIndexOf("/");
+  const basename = slashIdx >= 0 ? p.slice(slashIdx + 1) : p;
+  if (NOISE_BASENAMES.has(basename)) {
+    return true;
+  }
+  if (basename.startsWith(".improve-state-") || basename.startsWith("improve_commit_msg_")) {
+    return true;
+  }
+  const dotIdx = basename.lastIndexOf(".");
+  if (dotIdx >= 0) {
+    const ext = basename.slice(dotIdx);
+    if (NOISE_EXTS.has(ext)) {
+      return true;
+    }
+  }
+  for (const ext of NOISE_EXTS) {
+    if (ext.includes(".") && ext.split(".").length > 2) {
+      if (basename.endsWith(ext)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function findLatestSessionId() {
+  try {
+    const sessionsDir2 = path3.join(tokenGoatHome(), "sessions");
+    if (!fs4.existsSync(sessionsDir2)) {
+      return null;
+    }
+    const files = fs4.readdirSync(sessionsDir2);
+    const jsonFiles = files.filter((f) => f.endsWith(".json") && !f.includes(AGENT_SALT_MARKER));
+    if (jsonFiles.length === 0) {
+      return null;
+    }
+    const firstFile = jsonFiles[0];
+    if (!firstFile) {
+      return null;
+    }
+    let latestFile = firstFile;
+    let latestMtime = fs4.statSync(path3.join(sessionsDir2, firstFile)).mtimeMs;
+    for (const file of jsonFiles) {
+      const mtime = fs4.statSync(path3.join(sessionsDir2, file)).mtimeMs;
+      if (mtime > latestMtime) {
+        latestFile = file;
+        latestMtime = mtime;
+      }
+    }
+    return latestFile.replace(/\.json$/, "");
+  } catch {
+    return null;
+  }
+}
+function eventCount(cache) {
+  const files = cache.files ?? [];
+  const editedCount = files.filter((f) => f.wasEdited).length;
+  const bashCount = (cache.bashOutputs ?? []).length;
+  const webCount = (cache.webFetches ?? []).length;
+  const skillHistory = cache.skillHistory ?? {};
+  return files.length + editedCount + bashCount + webCount + Object.keys(skillHistory).length;
+}
+function writeSessionManifest(projectHash, sessionId, manifestJson) {
+  const safeSessionId = sessionFileStem(sessionId);
+  if (!safeSessionId) return;
+  const sessionsDir2 = path3.join(dataDir(), "projects", projectHash, "sessions");
+  if (!fs4.existsSync(sessionsDir2)) {
+    ensureDirSync(sessionsDir2);
+  }
+  const dest = path3.join(sessionsDir2, `${safeSessionId}.json`);
+  atomicWriteText(dest, JSON.stringify(manifestJson));
+}
+function readAllSessionManifests(projectHash, maxAgeSecs = 3600) {
+  const sessionsDir2 = path3.join(dataDir(), "projects", projectHash, "sessions");
+  if (!fs4.existsSync(sessionsDir2)) {
+    return [];
+  }
+  const now = Date.now() / 1e3;
+  const results = [];
+  try {
+    const files = fs4.readdirSync(sessionsDir2);
+    for (const file of files) {
+      if (!file.endsWith(".json")) {
+        continue;
+      }
+      try {
+        const fullPath = path3.join(sessionsDir2, file);
+        const stat2 = fs4.statSync(fullPath);
+        if (now - stat2.mtimeMs / 1e3 > maxAgeSecs) {
+          try {
+            fs4.unlinkSync(fullPath);
+          } catch {
+          }
+          continue;
+        }
+        const text = fs4.readFileSync(fullPath, "utf8");
+        const data = JSON.parse(text);
+        if (typeof data === "object" && data !== null && "files" in data) {
+          results.push(data);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function _editedFileCount(cache) {
+  return (cache.files ?? []).filter((f) => f.wasEdited).length;
+}
+function _computeActivityMultiplier(ageSecs, editedCount) {
+  const TEN_MIN_SECS = 600;
+  const SIXTY_MIN_SECS = 3600;
+  const EDITS_PER_MIN_DENSITY_THRESHOLD = 0.3;
+  let tier;
+  if (ageSecs < TEN_MIN_SECS) {
+    tier = "young";
+  } else if (ageSecs < SIXTY_MIN_SECS) {
+    tier = "active";
+  } else {
+    tier = "mature";
+  }
+  const baseFactor = {
+    young: 0.6,
+    active: 1,
+    mature: 1.4
+  };
+  let factor = baseFactor[tier];
+  if (ageSecs >= TEN_MIN_SECS) {
+    const editsPerMin = ageSecs > 0 ? editedCount / (ageSecs / 60) : 0;
+    if (editsPerMin < EDITS_PER_MIN_DENSITY_THRESHOLD) {
+      factor = Math.min(factor, 1);
+    }
+  }
+  return factor;
+}
+function loadSessionCache(sessionId) {
+  const disk = readSessionStateFile(sessionId);
+  if (!disk) {
+    return null;
+  }
+  return {
+    files: disk.files,
+    webFetches: disk.webFetches,
+    bashOutputs: disk.bashOutputs,
+    ...disk.created_ts !== void 0 ? { created_ts: disk.created_ts } : {}
+  };
+}
+function computeAdaptiveBudget(cache, ageSecs = 0, opts) {
+  const base = 200;
+  const maxTotal = 800;
+  const minTotal = 200;
+  const editedCount = _editedFileCount(cache);
+  const editedBonus = Math.min(200, editedCount * 50);
+  const files = cache.files ?? [];
+  const symbolFiles = files.filter((f) => {
+    const entry = f;
+    return (entry["symbols_read"] ?? []).length > 0;
+  }).length;
+  const symbolsBonus = Math.min(150, symbolFiles * 30);
+  const bashCount = (cache.bashOutputs ?? []).length;
+  const bashBonus = bashCount > 0 ? Math.min(100, Math.max(20, bashCount * 5)) : 0;
+  const webBonus = (cache.webFetches ?? []).length > 0 ? 15 : 0;
+  const diffBonus = opts?.hasPendingDiff ? 50 : 0;
+  const uncommittedBonus = opts?.hasUncommittedChanges ? 10 : 0;
+  const staleFrac = Math.max(0, Math.min(1, opts?.staleCompactFraction ?? 0));
+  const staleBonus = Math.min(60, Math.round(staleFrac * 60));
+  const rawTotal = base + editedBonus + symbolsBonus + bashBonus + webBonus + diffBonus + uncommittedBonus + staleBonus;
+  const factor = _computeActivityMultiplier(ageSecs, editedCount);
+  const total = Math.round(rawTotal * factor);
+  let capMax = maxTotal;
+  if (opts?.contextPressure) {
+    if (opts.contextPressure.tier === "critical") {
+      capMax = Math.min(capMax, 300);
+    } else if (opts.contextPressure.tier === "hot") {
+      capMax = Math.min(capMax, 500);
+    }
+  }
+  return Math.max(minTotal, Math.min(capMax, total));
+}
+
+export {
+  recordFileRead,
+  recordSymbolRead,
+  recordFileEdit,
+  getSessionFiles,
+  wasFileReadThisSession,
+  wasFileFullyReadThisSession,
+  getCompactedAt,
+  markCompacted,
+  getSessionFileEntry,
+  wasHintShown,
+  markHintShown,
+  recordScheduledPrompt,
+  wasCliReadThisSession,
+  recordCliRead,
+  recordLargeFileHintPending,
+  takePendingLargeFileHint,
+  WEB_FETCH_KEY_SEP,
+  recordWebFetch,
+  getSessionWebFetches,
+  recordBashOutput,
+  getSessionBashOutputs,
+  recordBashRerun,
+  getSessionBashReruns,
+  getBashOutputId,
+  recordGrepQuery,
+  getGrepMatchCount,
+  recordGlobQuery,
+  getGlobMatchCount,
+  setLastTabContext,
+  lastTabContextMatches,
+  hasSeenImage,
+  recordSeenImage,
+  recordOutstandingAgentSpawn,
+  getOutstandingAgentSpawns,
+  removeOutstandingAgentSpawn,
+  recordCurlDownload,
+  getCurlDownloadPath,
+  clearCurlDownload,
+  recordFileLineRange,
+  getFileLineRanges,
+  resetFileLineRanges,
+  GENERIC_SERVED_OUTPUT_KEY,
+  recordFileServedOutput,
+  getFileServedOutputs,
+  markFileTruncated,
+  wasFileTruncatedThisSession,
+  getSessionId,
+  setTranscriptPath,
+  getTranscriptPath,
+  exportSessionState,
+  SESSIONS_SUBDIR,
+  sessionsDir,
+  AGENT_SALT_MARKER,
+  sessionSidecarPath,
+  listSiblingSessionStates,
+  loadSessionState,
+  saveSessionState,
+  CONTEXT_AUTOCOMPACT_TOKENS,
+  getContextPressure,
+  isNoisePath,
+  findLatestSessionId,
+  eventCount,
+  writeSessionManifest,
+  readAllSessionManifests,
+  loadSessionCache,
+  computeAdaptiveBudget,
+  SKILLS_OUTPUT_SUBDIR,
+  skillOutputsDir,
+  contentHash,
+  extractCompactFromMarker,
+  extractNamedSection,
+  extractChecklistSection,
+  listOutputs,
+  hasSessionOutput,
+  sessionOutputBodyBytes,
+  storeOutput,
+  storeCompact,
+  getCompactAnySessionSync,
+  isCompactStale,
+  incrementSkillHit,
+  formatAge,
+  listSkills,
+  getSkillFilePath,
+  installedSkillPath,
+  pruneSkillOutputs
+};