token-goat 2.9.28 → 2.9.30

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

@@ -0,0 +1,761 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  computeAdaptiveBudget,
+  formatAge,
+  getContextPressure,
+  isNoisePath,
+  listSiblingSessionStates,
+  loadSessionCache,
+  sessionSidecarPath
+} from "./token-goat-chunk-Y776AENC.mjs";
+import {
+  getBashOutput,
+  indexRecallEntry
+} from "./token-goat-chunk-AFLYLHDH.mjs";
+import {
+  WEB_FETCH_KEY_SEP,
+  getSessionBashOutputs,
+  getSessionBashReruns,
+  getSessionFiles,
+  getSessionWebFetches
+} from "./token-goat-chunk-C63JQV5K.mjs";
+import {
+  blobPath,
+  isBlobStale,
+  loadBlob,
+  storeBlob
+} from "./token-goat-chunk-ARDNEC2U.mjs";
+import {
+  redactSecrets
+} from "./token-goat-chunk-4FVIAHSI.mjs";
+import {
+  findProject,
+  loadConfig,
+  shortFingerprint
+} from "./token-goat-chunk-7IN2MKDS.mjs";
+import {
+  registerReset
+} from "./token-goat-chunk-YZAAZU2S.mjs";
+import {
+  LOCK_WAIT_MS_HARDENED,
+  atomicWriteText,
+  ensureDirSync,
+  runGit,
+  toKB,
+  withFileLock,
+  withRetryOnLock
+} from "./token-goat-chunk-GOLEOXZP.mjs";
+import {
+  foldPath,
+  resolveOnPath,
+  sleepSync,
+  spawnResolvedSync
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  UNTRUSTED_FILE_TAG,
+  displaySafePath,
+  displaySafeText,
+  fenceUntrustedFileContent,
+  neutralizeSpokenMarkers
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  dataDir
+} from "./token-goat-chunk-VES7EL7O.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/manifest.ts
+init_define_import_meta_env();
+
+// src/web_cache.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+var WEB_OUTPUT_SUBDIR = "web_outputs";
+var _byId = /* @__PURE__ */ new Map();
+var _rawById = /* @__PURE__ */ new Map();
+var _urlIndex = /* @__PURE__ */ new Map();
+function cacheIdForUrl(url) {
+  return shortFingerprint(url);
+}
+function storeWebOutput(url, content, dedupKey = url, rawContent) {
+  const cacheId = cacheIdForUrl(dedupKey);
+  const redactedContent = redactSecrets(content).text;
+  _byId.set(cacheId, redactedContent);
+  _urlIndex.set(url, cacheId);
+  const redactedRaw = rawContent !== void 0 && rawContent !== content ? redactSecrets(rawContent).text : void 0;
+  if (redactedRaw !== void 0) _rawById.set(cacheId, redactedRaw);
+  else _rawById.delete(cacheId);
+  storeBlob(WEB_OUTPUT_SUBDIR, cacheId, redactedRaw !== void 0 ? { url, content: redactedContent, raw: redactedRaw } : { url, content: redactedContent });
+  const redactedUrl = redactSecrets(url).text;
+  indexRecallEntry("web", cacheId, redactedUrl, `${redactedUrl}
+${redactedContent}`, Date.now());
+  return cacheId;
+}
+function coerceWebBlob(raw) {
+  if (raw === null || typeof raw !== "object") return null;
+  const o = raw;
+  if (typeof o["content"] !== "string") return null;
+  return { url: typeof o["url"] === "string" ? o["url"] : null, content: o["content"], raw: typeof o["raw"] === "string" ? o["raw"] : null };
+}
+function getWebOutput(cacheId) {
+  const hit = _byId.get(cacheId);
+  if (hit !== void 0) return hit;
+  if (isBlobStale(WEB_OUTPUT_SUBDIR, cacheId)) return null;
+  const blob = coerceWebBlob(loadBlob(WEB_OUTPUT_SUBDIR, cacheId));
+  if (blob === null) return null;
+  _byId.set(cacheId, blob.content);
+  if (blob.raw !== null) _rawById.set(cacheId, blob.raw);
+  if (blob.url !== null) _urlIndex.set(blob.url, cacheId);
+  return blob.content;
+}
+function hasWebOutput(cacheId) {
+  if (_byId.has(cacheId)) return true;
+  const p = blobPath(WEB_OUTPUT_SUBDIR, cacheId);
+  if (p === null || isBlobStale(WEB_OUTPUT_SUBDIR, cacheId)) return false;
+  return fs.existsSync(p);
+}
+function getWebOutputRaw(cacheId) {
+  const cleaned = getWebOutput(cacheId);
+  if (cleaned === null) return null;
+  return _rawById.get(cacheId) ?? cleaned;
+}
+function getWebOutputByUrlFromDisk(url, dedupKey = url) {
+  const cacheId = cacheIdForUrl(dedupKey);
+  const content = getWebOutput(cacheId);
+  if (content === null) return null;
+  return { cacheId, content };
+}
+registerReset(() => {
+  _byId = /* @__PURE__ */ new Map();
+  _rawById = /* @__PURE__ */ new Map();
+  _urlIndex = /* @__PURE__ */ new Map();
+}, { perRequest: true });
+
+// src/project_memory.ts
+init_define_import_meta_env();
+import * as fs2 from "node:fs";
+import * as path from "node:path";
+var MAX_ENTRIES = 30;
+var MAX_VALUE_LEN = 300;
+var MAX_TOTAL_CHARS = 4e3;
+var KEY_RE = /^[A-Za-z0-9_-]{1,80}$/;
+var SET_AT_RE = /^#\s*set\s+(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z)$/;
+var ANCHOR_RE = /^#\s*anchor:\s*(\S.*)::([^:@\s]+)@([0-9a-f]{64})$/;
+function anchorLabel(status) {
+  if (status === "changed") return " (changed since note)";
+  if (status === "gone") return " (anchored symbol gone)";
+  return "";
+}
+function anchorLine(anchor) {
+  const line = `# anchor: ${anchor.file}::${anchor.symbol}@${anchor.sha}`;
+  const back = ANCHOR_RE.exec(line);
+  return back !== null && back[1] === anchor.file && back[2] === anchor.symbol ? line : null;
+}
+function noteMap() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function ordinal(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function memoryPath(projectHash) {
+  return path.join(dataDir(), "projects", `${projectHash}_memory.toml`);
+}
+function validateKey(key) {
+  if (!KEY_RE.test(key)) {
+    throw new Error(
+      `Invalid memory key ${JSON.stringify(key)}: use only letters, digits, hyphens, underscores (max 80 chars)`
+    );
+  }
+}
+function parseTOML(content, unparsed = [], setAt = /* @__PURE__ */ new Map(), anchors = /* @__PURE__ */ new Map()) {
+  const result = noteMap();
+  let pendingSetAt;
+  let pendingAnchor;
+  for (const [i, line] of content.split("\n").entries()) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    if (trimmed.startsWith("#")) {
+      const time = SET_AT_RE.exec(trimmed)?.[1];
+      if (time !== void 0 && !Number.isNaN(Date.parse(time))) pendingSetAt = time;
+      const anchor = ANCHOR_RE.exec(trimmed);
+      if (anchor !== null) pendingAnchor = { file: anchor[1], symbol: anchor[2], sha: anchor[3] };
+      continue;
+    }
+    const entrySetAt = pendingSetAt;
+    const entryAnchor = pendingAnchor;
+    pendingSetAt = void 0;
+    pendingAnchor = void 0;
+    const match = trimmed.match(/^([A-Za-z0-9_-]+)\s*=\s*"(.*)"\s*$/s);
+    if (match) {
+      const [, key, value] = match;
+      if (key && value !== void 0) {
+        const unescaped = value.replace(/\\(u202[89]|[\\nrt"])/g, (_, c) => {
+          switch (c) {
+            case "u2028":
+              return "\u2028";
+            case "u2029":
+              return "\u2029";
+            case "\\":
+              return "\\";
+            case "n":
+              return "\n";
+            case "r":
+              return "\r";
+            case '"':
+              return '"';
+            default:
+              return _;
+          }
+        });
+        result[key] = unescaped;
+        if (entrySetAt === void 0) setAt.delete(key);
+        else setAt.set(key, entrySetAt);
+        if (entryAnchor === void 0) anchors.delete(key);
+        else anchors.set(key, entryAnchor);
+      }
+    } else {
+      unparsed.push(i + 1);
+    }
+  }
+  return result;
+}
+function loadRaw(filePath, forUpdate = false, setAt, anchors) {
+  let content = "";
+  try {
+    withRetryOnLock(() => {
+      content = fs2.readFileSync(filePath, "utf-8");
+    });
+  } catch (err) {
+    if (err.code === "ENOENT") return noteMap();
+    throw err;
+  }
+  const unparsed = [];
+  const entries = parseTOML(content, unparsed, setAt, anchors);
+  if (forUpdate && unparsed.length > 0) {
+    const one = unparsed.length === 1;
+    throw new Error(`Not updating ${filePath}: ${one ? "line" : "lines"} ${unparsed.join(", ")} ${one ? "is" : "are"} not in the key = "value" form, and saving would drop ${one ? "it" : "them"}. Fix or remove ${one ? "it" : "them"}, then try again.`);
+  }
+  return entries;
+}
+function save(filePath, entries, setAt = /* @__PURE__ */ new Map(), anchors = /* @__PURE__ */ new Map()) {
+  const lines = [];
+  const sorted = Object.entries(entries).sort(([a], [b]) => ordinal(a, b));
+  for (const [k, v] of sorted) {
+    const escaped = v.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\r/g, "\\r").replace(/\n/g, "\\n").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+    const time = setAt.get(k);
+    if (time !== void 0) lines.push(`# set ${time}`);
+    const anchor = anchors.get(k);
+    const anchored = anchor === void 0 ? null : anchorLine(anchor);
+    if (anchored !== null) lines.push(anchored);
+    lines.push(`${k} = "${escaped}"`);
+  }
+  const content = lines.length > 0 ? lines.join("\n") + "\n" : "";
+  const dir = path.dirname(filePath);
+  ensureDirSync(dir);
+  atomicWriteText(filePath, content);
+}
+function loadEntries(projectHash) {
+  return loadRaw(memoryPath(projectHash));
+}
+function loadDatedEntries(projectHash) {
+  const setAt = /* @__PURE__ */ new Map();
+  const anchors = /* @__PURE__ */ new Map();
+  const entries = loadRaw(memoryPath(projectHash), false, setAt, anchors);
+  const result = noteMap();
+  for (const [key, value] of Object.entries(entries)) {
+    const note = { value };
+    const time = setAt.get(key);
+    if (time !== void 0) note.setAt = time;
+    const anchor = anchors.get(key);
+    if (anchor !== void 0) note.anchor = anchor;
+    result[key] = note;
+  }
+  return result;
+}
+function noteAgeLabel(note, now = Date.now()) {
+  if (note.setAt === void 0) return "";
+  return ` (set ${formatAge(Math.max(0, now - Date.parse(note.setAt)))} ago)`;
+}
+function oneLineNoteValue(value) {
+  return value.replace(/\r\n|[\r\n\u0085\u2028\u2029]/g, "\\n");
+}
+function byRecency(a, aSetAt, b, bSetAt) {
+  const ta = aSetAt === void 0 ? Number.NEGATIVE_INFINITY : Date.parse(aSetAt);
+  const tb = bSetAt === void 0 ? Number.NEGATIVE_INFINITY : Date.parse(bSetAt);
+  return ta !== tb ? ta > tb ? -1 : 1 : ordinal(a, b);
+}
+function setEntry(projectHash, key, value, anchor) {
+  validateKey(key);
+  const p = memoryPath(projectHash);
+  const dir = path.dirname(p);
+  ensureDirSync(dir);
+  const result = { evicted: [] };
+  const doSet = () => {
+    const setAt = /* @__PURE__ */ new Map();
+    const anchors = /* @__PURE__ */ new Map();
+    const entries = loadRaw(p, true, setAt, anchors);
+    const old = Object.hasOwn(entries, key) ? entries[key] : void 0;
+    if (old !== void 0) result.previous = old;
+    const isNewKey = !Object.hasOwn(entries, key);
+    if (isNewKey && Object.keys(entries).length >= MAX_ENTRIES) {
+      const keysToKeep = MAX_ENTRIES - 1;
+      const allKeys = Object.keys(entries).sort((a, b) => byRecency(a, setAt.get(a), b, setAt.get(b)));
+      for (const k of allKeys.slice(keysToKeep)) {
+        result.evicted.push(k);
+        delete entries[k];
+        setAt.delete(k);
+        anchors.delete(k);
+      }
+    }
+    entries[key] = value;
+    setAt.set(key, (/* @__PURE__ */ new Date()).toISOString());
+    if (anchor === void 0) anchors.delete(key);
+    else anchors.set(key, anchor);
+    save(p, entries, setAt, anchors);
+    return true;
+  };
+  underNotesLock(p, doSet);
+  return result;
+}
+function underNotesLock(p, update) {
+  const lockPath = `${p}.lock`;
+  ensureDirSync(path.dirname(p));
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    if (withFileLock(lockPath, update, { waitMs: LOCK_WAIT_MS_HARDENED }) !== void 0) return;
+    if (fs2.existsSync(lockPath)) break;
+    if (attempt < 3) sleepSync(50 * attempt);
+  }
+  throw new Error(`Could not lock ${p} for writing; no note was changed. Another token-goat process may be writing notes: try again.`);
+}
+function unsetEntry(projectHash, key) {
+  validateKey(key);
+  const p = memoryPath(projectHash);
+  let removed = false;
+  const doUnset = () => {
+    const setAt = /* @__PURE__ */ new Map();
+    const anchors = /* @__PURE__ */ new Map();
+    const entries = loadRaw(p, true, setAt, anchors);
+    if (Object.hasOwn(entries, key)) {
+      delete entries[key];
+      save(p, entries, setAt, anchors);
+      removed = true;
+    }
+    return true;
+  };
+  underNotesLock(p, doUnset);
+  return removed;
+}
+function clearAll(projectHash) {
+  const p = memoryPath(projectHash);
+  const doClear = () => {
+    if (fs2.existsSync(p)) {
+      save(p, {});
+    }
+    return true;
+  };
+  underNotesLock(p, doClear);
+}
+function buildInjection(projectHash, root, statusOf) {
+  try {
+    const entries = loadDatedEntries(projectHash);
+    if (Object.keys(entries).length === 0) {
+      return null;
+    }
+    const now = Date.now();
+    const header = '### Project notes (`token-goat note set <key> "<finding>"`)';
+    const render2 = (shown2, skipped) => {
+      const parts = [header];
+      if (shown2.length > 0) parts.push(fenceUntrustedFileContent(shown2.join("\n")));
+      if (skipped > 0) parts.push(`- (+${skipped} more memory entries omitted)`);
+      return parts.join("\n");
+    };
+    const entries_list = Object.entries(entries).sort(([a, na], [b, nb]) => byRecency(a, na.setAt, b, nb.setAt));
+    const shown = [];
+    for (const [key, note] of entries_list.slice(0, MAX_ENTRIES)) {
+      const val = note.value;
+      const display = val.length <= MAX_VALUE_LEN ? val : val.slice(0, MAX_VALUE_LEN) + "\u2026";
+      const flag = root === void 0 || statusOf === void 0 || note.anchor === void 0 ? "" : anchorLabel(statusOf(root, note.anchor));
+      const line = `- **${key}**${noteAgeLabel(note, now)}${flag}: ${oneLineNoteValue(display)}`;
+      if (render2([...shown, line], entries_list.length - shown.length - 1).length > MAX_TOTAL_CHARS) break;
+      shown.push(line);
+    }
+    return render2(shown, entries_list.length - shown.length);
+  } catch {
+    return null;
+  }
+}
+function projectNotesFor(cwd, statusOf) {
+  if (cwd === void 0) return null;
+  try {
+    const project = findProject(cwd);
+    return project === null ? null : buildInjection(project.hash, project.root, statusOf);
+  } catch {
+    return null;
+  }
+}
+
+// src/manifest_fit.ts
+init_define_import_meta_env();
+var RESERVE_SHARE = 0.25;
+function cost(lines) {
+  let n = 0;
+  for (const line of lines) n += line.length + 1;
+  return n;
+}
+var moreLine = (n) => `- ...and ${n} more`;
+function rowsThatFit(s, room) {
+  const rows = s.rows ?? [];
+  const fixed = cost(s.header) + cost(s.footer ?? []);
+  if (rows.length === 0) return fixed <= room ? 0 : null;
+  const limit = Math.min(rows.length, s.maxRows ?? rows.length);
+  const prefix = [0];
+  for (let i = 0; i < limit; i++) prefix.push(prefix[i] + rows[i].length + 1);
+  for (let k = limit; k >= 1; k--) {
+    const tail = k < rows.length ? moreLine(rows.length - k).length + 1 : 0;
+    if (fixed + prefix[k] + tail <= room) return k;
+  }
+  return null;
+}
+function render(s, k) {
+  const rows = s.rows ?? [];
+  const lines = [...s.header, ...rows.slice(0, k), ...s.footer ?? []];
+  if (rows.length > 0 && k < rows.length) lines.push(moreLine(rows.length - k));
+  return lines;
+}
+function fitSections(sections, budget) {
+  const shown = sections.map(() => null);
+  let room = budget + 1;
+  const place = (indices2, limit) => {
+    let spent = 0;
+    for (const i of indices2) {
+      const k = rowsThatFit(sections[i], Math.min(limit, room) - spent);
+      if (k === null) continue;
+      shown[i] = k;
+      spent += cost(render(sections[i], k));
+    }
+    room -= spent;
+  };
+  const indices = sections.map((_, i) => i);
+  place(indices.filter((i) => sections[i].priority === 0 && sections[i].reserved !== true), room);
+  place(indices.filter((i) => sections[i].reserved === true), Math.floor(budget * RESERVE_SHARE));
+  const rest = indices.filter((i) => sections[i].priority !== 0 && sections[i].reserved !== true);
+  rest.sort((a, b) => sections[a].priority - sections[b].priority || a - b);
+  place(rest, room);
+  const lines = [];
+  const omitted = [];
+  sections.forEach((s, i) => {
+    const k = shown[i];
+    if (k === null || k === void 0) omitted.push(s.header.find((l) => l !== "") ?? "");
+    else lines.push(...render(s, k));
+  });
+  return { text: lines.join("\n"), shown: shown.map((k) => k ?? 0), omitted };
+}
+
+// src/manifest.ts
+var MEM_EPOCH_TIMEOUT_MS = 800;
+var MAX_ROWS = 40;
+function renderReadRow(entry) {
+  const kb = Math.max(1, toKB(entry.sizeBytes));
+  const plural = entry.readCount === 1 ? "read" : "reads";
+  const edited = entry.wasEdited ? ", edited" : "";
+  return `- ${displaySafePath(entry.path)} (${kb}kb, ${entry.readCount} ${plural}${edited})`;
+}
+function renderSymbolReadRow(entry) {
+  return `- ${displaySafePath(entry.path)} (symbols: ${(entry.symbols_read ?? []).map(displaySafeText).join(", ")})`;
+}
+function mergeManifestFiles(parent, siblingFiles) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const f of parent) byPath.set(foldPath(f.path), f);
+  for (const f of siblingFiles) {
+    const key = foldPath(f.path);
+    const prev = byPath.get(key);
+    if (prev === void 0) {
+      byPath.set(key, f);
+      continue;
+    }
+    const mergedSymbols = [.../* @__PURE__ */ new Set([...prev.symbols_read ?? [], ...f.symbols_read ?? []])];
+    byPath.set(key, {
+      path: prev.path,
+      readCount: Math.max(prev.readCount, f.readCount),
+      lastReadAt: Math.max(prev.lastReadAt, f.lastReadAt),
+      wasEdited: prev.wasEdited || f.wasEdited,
+      sizeBytes: f.lastReadAt >= prev.lastReadAt ? f.sizeBytes : prev.sizeBytes,
+      ...prev.wasTruncated || f.wasTruncated ? { wasTruncated: true } : {},
+      ...mergedSymbols.length > 0 ? { symbols_read: mergedSymbols } : {}
+    });
+  }
+  return Array.from(byPath.values());
+}
+function renderWebFetchRow(key, cacheId, live = true) {
+  const [url = key, prompt = ""] = key.split(WEB_FETCH_KEY_SEP);
+  if (!live) return `- ${displaySafeText(url)} (cache expired)`;
+  const promptSuffix = prompt ? `, prompt: ${neutralizeSpokenMarkers(JSON.stringify(prompt))}` : "";
+  return `- ${displaySafeText(url)} (cacheId: ${cacheId}${promptSuffix})`;
+}
+function renderWebFetchRows(entries) {
+  const live = entries.map(([, cacheId]) => hasWebOutput(cacheId));
+  if (entries.length > 0 && !live.includes(true)) {
+    const urls = entries.map(([key]) => displaySafeText(key.split(WEB_FETCH_KEY_SEP)[0] ?? key));
+    return [`- ${entries.length} fetched page${entries.length === 1 ? "" : "s"}, cache expired: ${urls.join(", ")}`];
+  }
+  return entries.map(([key, cacheId], n) => renderWebFetchRow(key, cacheId, live[n]));
+}
+function selectManifestFiles(siblings) {
+  const ownFiles = [...getSessionFiles().values()];
+  const siblingFiles = siblings.flatMap((s) => s.files);
+  const files = siblingFiles.length > 0 ? mergeManifestFiles(ownFiles, siblingFiles) : ownFiles;
+  const editedFiles = files.filter((f) => f.wasEdited);
+  const readFiles = files.filter((f) => f.readCount > 0 && !f.wasEdited && !isNoisePath(f.path));
+  const symbolOnlyFiles = files.filter((f) => f.readCount === 0 && !f.wasEdited && (f.symbols_read?.length ?? 0) > 0);
+  return { files, readFiles, editedFiles, symbolOnlyFiles };
+}
+function selectManifestWebFetches(siblings) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const sibling of siblings) for (const [key, cacheId] of sibling.webFetches) merged.set(key, cacheId);
+  for (const [key, cacheId] of getSessionWebFetches()) merged.set(key, cacheId);
+  return [...merged.entries()];
+}
+function manifestPrintedPaths(sessionId, limit, cwd, transcriptPath) {
+  const { printed } = buildManifestParts(sessionId, cwd, transcriptPath);
+  return printed.slice(0, limit);
+}
+function buildManifestParts(sessionId, cwd, transcriptPath) {
+  const siblings = sessionId !== void 0 ? listSiblingSessionStates(sessionId) : [];
+  const { files, readFiles, editedFiles, symbolOnlyFiles } = selectManifestFiles(siblings);
+  const webFetches = selectManifestWebFetches(siblings);
+  const fileSections = [];
+  const fileSection = (header, entries, render2, priority) => {
+    if (entries.length === 0) return [];
+    const section = { header: ["", header], rows: entries.map(render2), priority, maxRows: MAX_ROWS };
+    fileSections.push({ entries, section });
+    return [section];
+  };
+  const notes = projectNotesFor(cwd);
+  const webRows = renderWebFetchRows(webFetches);
+  const sections = [
+    { header: ["## Session context", `Files read: ${readFiles.length}`, `Files edited: ${editedFiles.length}`], priority: 0 },
+    ...fileSection("### Edited files", editedFiles, (entry) => `- ${displaySafePath(entry.path)}`, 1),
+    ...notes === null ? [] : [notesSection(notes)],
+    ...fileSection("### Surgically read files (symbol/section reads, never read whole)", symbolOnlyFiles, renderSymbolReadRow, 3),
+    ...fileSection("### Read files", readFiles, renderReadRow, 4),
+    ...webRows.length === 0 ? [] : [{ header: ["", "### Web URLs fetched"], rows: webRows, priority: 5, maxRows: MAX_ROWS }],
+    ...buildSafeToDiscardSection(files),
+    ...buildMemEpochSection()
+  ];
+  const fit = fitManifest(sections, sessionId, cwd, transcriptPath);
+  const seen = /* @__PURE__ */ new Set();
+  const printed = [];
+  for (const { entries, section } of fileSections) {
+    const count = fit.shown[sections.indexOf(section)] ?? 0;
+    for (const entry of entries.slice(0, count)) {
+      const path2 = displaySafePath(entry.path);
+      if (seen.has(path2)) continue;
+      seen.add(path2);
+      printed.push(path2);
+    }
+  }
+  return { text: fit.text, printed };
+}
+function buildManifest(sessionId, cwd, transcriptPath) {
+  return buildManifestParts(sessionId, cwd, transcriptPath).text;
+}
+function gitDirtySignals(cwd) {
+  const timeoutMs = loadConfig().hints.git_hint_max_ms;
+  let hasPendingDiff = false;
+  try {
+    const diffResult = runGit(["diff", "--no-color", "--stat", "HEAD"], { cwd, timeoutMs });
+    hasPendingDiff = diffResult.exitCode === 0 && diffResult.stdout.trim() !== "";
+  } catch {
+  }
+  let hasUncommittedChanges = false;
+  try {
+    const statusResult = runGit(["status", "--porcelain"], { cwd, timeoutMs });
+    hasUncommittedChanges = statusResult.exitCode === 0 && statusResult.stdout.trim() !== "";
+  } catch {
+  }
+  return { hasPendingDiff, hasUncommittedChanges };
+}
+function adaptiveCharBonus(sessionId, cwd, transcriptPath) {
+  if (!cwd) return 0;
+  const cache = loadSessionCache(sessionId ?? "") ?? {};
+  const ageSecs = cache.created_ts !== void 0 ? Math.max(0, Date.now() / 1e3 - cache.created_ts) : 0;
+  const contextPressure = getContextPressure(cache, transcriptPath);
+  const { hasPendingDiff, hasUncommittedChanges } = gitDirtySignals(cwd);
+  if (!hasPendingDiff && !hasUncommittedChanges) return 0;
+  const baseline = computeAdaptiveBudget(cache, ageSecs, { contextPressure });
+  const withGitSignal = computeAdaptiveBudget(cache, ageSecs, { hasPendingDiff, hasUncommittedChanges, contextPressure });
+  const deltaTokens = Math.max(0, withGitSignal - baseline);
+  return deltaTokens * 3;
+}
+function fitManifest(sections, sessionId, cwd, transcriptPath) {
+  const full = fitSections(sections, Infinity);
+  const cap = loadConfig().compact_assist.max_manifest_chars;
+  if (cap <= 0 || full.text.length <= cap) return full;
+  const effectiveCap = cap + adaptiveCharBonus(sessionId, cwd, transcriptPath);
+  if (full.text.length <= effectiveCap) return full;
+  const fit = fitSections(sections, effectiveCap);
+  const gone = fit.omitted.length > 0 ? `; sections omitted: ${fit.omitted.map((h) => h.replace(/^#+\s*/, "")).join(", ")}` : "";
+  const notice = `
+...(manifest truncated at ${effectiveCap} chars; ${full.text.length - fit.text.length} chars omitted${gone})`;
+  return { text: closeCutFence(fit.text) + notice, shown: fit.shown };
+}
+function closeCutFence(kept) {
+  const open = `<${UNTRUSTED_FILE_TAG}>`;
+  const close = `
+</${UNTRUSTED_FILE_TAG}>`;
+  const lastOpen = kept.lastIndexOf(open);
+  if (lastOpen === -1 || kept.includes(close, lastOpen)) return kept;
+  let body = kept;
+  for (let n = close.length - 1; n > 0; n--) {
+    if (body.endsWith(close.slice(0, n))) {
+      body = body.slice(0, -n);
+      break;
+    }
+  }
+  return body + close;
+}
+function notesSection(notes) {
+  const lines = notes.split("\n");
+  const open = lines.indexOf(`<${UNTRUSTED_FILE_TAG}>`);
+  const close = lines.lastIndexOf(`</${UNTRUSTED_FILE_TAG}>`);
+  if (open === -1 || close < open) return { header: ["", ...lines], priority: 2 };
+  const rows = [];
+  for (const line of lines.slice(open + 1, close)) {
+    if (rows.length > 0 && !line.startsWith("- ")) rows[rows.length - 1] += "\n" + line;
+    else rows.push(line);
+  }
+  return { header: ["", ...lines.slice(0, open + 1)], rows, footer: lines.slice(close), priority: 2, maxRows: MAX_ROWS };
+}
+function buildSafeToDiscardSection(files) {
+  const rerunHashes = getSessionBashReruns();
+  const bashOutputs = getSessionBashOutputs();
+  const rerunHashSet = new Set(rerunHashes);
+  const rerunRows = [];
+  for (const hash of rerunHashes) {
+    const id = bashOutputs.find(([h]) => h === hash)?.[1];
+    if (id === void 0) continue;
+    const entry = getBashOutput(id);
+    if (entry === null) continue;
+    const flatCommand = neutralizeSpokenMarkers(entry.command.replace(/[\t\r\n]+/g, " "));
+    rerunRows.push("- `" + flatCommand + "` \u2014 an older run of this exact command was superseded; recall the surviving copy with `bash-output " + id + " --full`");
+  }
+  const supersededReadRows = [];
+  for (const f of files) {
+    if (f.readCount > 1 || f.wasEdited && f.readCount > 0) {
+      const reason = f.wasEdited ? "edited after being read" : "re-read " + f.readCount + "x";
+      supersededReadRows.push("- " + displaySafePath(f.path) + " (" + reason + " \u2014 only the latest content already in context is current)");
+    }
+  }
+  const cachedOutputRows = [];
+  for (const [hash, id] of bashOutputs) {
+    if (rerunHashSet.has(hash)) continue;
+    const entry = getBashOutput(id);
+    if (entry === null) continue;
+    const flatCommand = neutralizeSpokenMarkers(entry.command.replace(/[\t\r\n]+/g, " "));
+    cachedOutputRows.push("- `" + flatCommand + "` \u2014 recallable via `bash-output " + id + " --full`");
+  }
+  const total = rerunRows.length + supersededReadRows.length + cachedOutputRows.length;
+  if (total === 0) return [];
+  const title = "### SAFE_TO_DISCARD (" + total + " items \u2014 provably inert; each is recallable, not gone)";
+  const groups = [
+    ["Superseded reruns (" + rerunRows.length + "):", rerunRows],
+    ["Superseded file reads (" + supersededReadRows.length + "):", supersededReadRows],
+    ["Other cached bash outputs (" + cachedOutputRows.length + "):", cachedOutputRows]
+  ];
+  const sections = [];
+  for (const [header, rows] of groups) {
+    if (rows.length === 0) continue;
+    sections.push({ header: sections.length === 0 ? ["", title, "", header] : ["", header], rows, priority: 9, reserved: true, maxRows: MAX_ROWS });
+  }
+  return sections;
+}
+function buildMemEpochSection() {
+  let result;
+  try {
+    const resolved = resolveOnPath("mem");
+    if (resolved === null) return [];
+    result = spawnResolvedSync(resolved, ["epoch"], {
+      encoding: "utf-8",
+      timeout: MEM_EPOCH_TIMEOUT_MS,
+      windowsHide: true
+    });
+  } catch {
+    return [];
+  }
+  if (result.error !== void 0 || result.status !== 0) return [];
+  const stdout = typeof result.stdout === "string" ? result.stdout.trim() : "";
+  if (!/^\d+$/.test(stdout)) return [];
+  return [{
+    header: ["", "### mem epoch", `mem epoch: ${stdout} (no live TGMEM block is tracked in this session -- only the epoch counter is folded in; see buildMemEpochSection's doc comment)`],
+    priority: 9,
+    reserved: true
+  }];
+}
+var MANIFEST_PREAMBLE = "When summarizing this session, keep the file paths and symbol names below exactly as written -- they are the handles the next turn needs to resume work. Do not paraphrase them into prose.";
+var MANIFEST_RECOVERY_PREAMBLE = "The conversation was just compacted. Below is what this session touched, recovered from token-goat's own ledger rather than from the summary -- use it to re-establish paths and symbol names the summary may have dropped.";
+var BUDGET_ESCALATION_MARKER = "TG-BUDGET-ESCALATION:";
+function summaryBudgetDirective(budgetChars) {
+  if (budgetChars <= 0) return "";
+  return ` Aim for at most ${budgetChars} characters. Prefer a shorter summary that keeps every path, symbol, command and decision over a longer one that reproduces tool output verbatim: cite the recall id (\`token-goat bash-output <id> --full\`) rather than quoting the output again. If this session genuinely cannot be summarized within that target without losing state the next turn needs, exceed it and open the summary with a single line reading \`${BUDGET_ESCALATION_MARKER} <one-sentence reason>\`.`;
+}
+
+// src/compact_dropped.ts
+init_define_import_meta_env();
+import { readFileSync as readFileSync2, rmSync, writeFileSync } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+var DROPPED_SUFFIX = ".compact-dropped";
+function recordCompactDroppedPaths(stateKey, paths) {
+  const target = sessionSidecarPath(stateKey, DROPPED_SUFFIX);
+  if (target === null) return;
+  try {
+    if (paths === null || paths.length === 0) {
+      rmSync(target, { force: true });
+      return;
+    }
+    ensureDirSync(dirname2(target));
+    writeFileSync(target, JSON.stringify(paths), "utf8");
+  } catch {
+  }
+}
+function readCompactDroppedPaths(stateKey) {
+  const target = sessionSidecarPath(stateKey, DROPPED_SUFFIX);
+  if (target === null) return [];
+  try {
+    const parsed = JSON.parse(readFileSync2(target, "utf8"));
+    return Array.isArray(parsed) ? parsed.filter((p) => typeof p === "string" && p !== "") : [];
+  } catch {
+    return [];
+  }
+}
+
+export {
+  WEB_OUTPUT_SUBDIR,
+  storeWebOutput,
+  getWebOutput,
+  getWebOutputRaw,
+  getWebOutputByUrlFromDisk,
+  MAX_ENTRIES,
+  anchorLabel,
+  anchorLine,
+  loadEntries,
+  loadDatedEntries,
+  noteAgeLabel,
+  oneLineNoteValue,
+  setEntry,
+  unsetEntry,
+  clearAll,
+  projectNotesFor,
+  renderWebFetchRows,
+  manifestPrintedPaths,
+  buildManifest,
+  MANIFEST_PREAMBLE,
+  MANIFEST_RECOVERY_PREAMBLE,
+  BUDGET_ESCALATION_MARKER,
+  summaryBudgetDirective,
+  recordCompactDroppedPaths,
+  readCompactDroppedPaths
+};