token-goat 2.9.29 → 2.9.31

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

@@ -0,0 +1,497 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  projectNotesFor
+} from "./token-goat-chunk-GWFLAUMQ.mjs";
+import {
+  computeAdaptiveBudget,
+  getContextPressure,
+  isNoisePath,
+  loadSessionCache
+} from "./token-goat-chunk-NMD42SFQ.mjs";
+import {
+  listSiblingSessionStates,
+  sessionSidecarPath
+} from "./token-goat-chunk-WBA5SKT4.mjs";
+import {
+  getBashOutput
+} from "./token-goat-chunk-KQBLRPBN.mjs";
+import {
+  blobPath,
+  indexRecallEntry,
+  isBlobStale,
+  loadBlob,
+  storeBlob
+} from "./token-goat-chunk-4ZBFWLXF.mjs";
+import {
+  WEB_FETCH_KEY_SEP,
+  epochReadCounts,
+  getSessionBashOutputs,
+  getSessionBashReruns,
+  getSessionFiles,
+  getSessionWebFetches,
+  mergeEpochBase,
+  wasEditedSinceCompaction
+} from "./token-goat-chunk-GL3ETKSC.mjs";
+import {
+  redactSecrets
+} from "./token-goat-chunk-T5P5ACNQ.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import {
+  shortFingerprint
+} from "./token-goat-chunk-4GBVPH3D.mjs";
+import {
+  registerReset
+} from "./token-goat-chunk-YZAAZU2S.mjs";
+import {
+  ensureDirSync,
+  runGit,
+  toKB
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  foldPath,
+  resolveOnPath,
+  spawnResolvedSync
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  UNTRUSTED_FILE_TAG,
+  displaySafePath,
+  displaySafeText,
+  neutralizeSpokenMarkers
+} from "./token-goat-chunk-FNFBKLRD.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/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 = 2e3;
+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 ?? []])];
+    const fullReadCount = Math.max(prev.fullReadCount ?? 0, f.fullReadCount ?? 0);
+    const lastFullReadAt = Math.max(prev.lastFullReadAt ?? -1, f.lastFullReadAt ?? -1);
+    const epochBase = mergeEpochBase(prev.epochBase, f.epochBase);
+    const lastEditedAt = Math.max(prev.lastEditedAt ?? 0, f.lastEditedAt ?? 0);
+    byPath.set(key, {
+      path: prev.path,
+      readCount: Math.max(prev.readCount, f.readCount),
+      lastReadAt: Math.max(prev.lastReadAt, f.lastReadAt),
+      ...fullReadCount > 0 ? { fullReadCount } : {},
+      ...lastFullReadAt >= 0 ? { lastFullReadAt } : {},
+      wasEdited: prev.wasEdited || f.wasEdited,
+      ...lastEditedAt > 0 ? { lastEditedAt } : {},
+      sizeBytes: f.lastReadAt >= prev.lastReadAt ? f.sizeBytes : prev.sizeBytes,
+      ...prev.wasTruncated || f.wasTruncated ? { wasTruncated: true } : {},
+      ...mergedSymbols.length > 0 ? { symbols_read: mergedSymbols } : {},
+      ...epochBase !== void 0 ? { epochBase } : {}
+    });
+  }
+  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 path = displaySafePath(entry.path);
+      if (seen.has(path)) continue;
+      seen.add(path);
+      printed.push(path);
+    }
+  }
+  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 readIsSuperseded(f) {
+  const { reads, fullReads } = epochReadCounts(f);
+  if (wasEditedSinceCompaction(f)) return fullReads > 0;
+  return fullReads > 1 || reads > 1 && fullReads > 0 && f.lastFullReadAt !== void 0 && f.lastFullReadAt >= f.lastReadAt;
+}
+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 (readIsSuperseded(f)) {
+      const reason = wasEditedSinceCompaction(f) ? "edited after being read" : "re-read " + epochReadCounts(f).reads + "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(timeoutMs = MEM_EPOCH_TIMEOUT_MS) {
+  let result;
+  try {
+    const resolved = resolveOnPath("mem");
+    if (resolved === null) return [];
+    result = spawnResolvedSync(resolved, ["epoch"], {
+      encoding: "utf-8",
+      timeout: timeoutMs,
+      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, rmSync, writeFileSync } from "node:fs";
+import { dirname } 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(dirname(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(readFileSync(target, "utf8"));
+    return Array.isArray(parsed) ? parsed.filter((p) => typeof p === "string" && p !== "") : [];
+  } catch {
+    return [];
+  }
+}
+
+export {
+  WEB_OUTPUT_SUBDIR,
+  storeWebOutput,
+  getWebOutput,
+  getWebOutputRaw,
+  getWebOutputByUrlFromDisk,
+  renderWebFetchRows,
+  manifestPrintedPaths,
+  buildManifest,
+  MANIFEST_PREAMBLE,
+  MANIFEST_RECOVERY_PREAMBLE,
+  BUDGET_ESCALATION_MARKER,
+  summaryBudgetDirective,
+  recordCompactDroppedPaths,
+  readCompactDroppedPaths
+};

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

@@ -0,0 +1,58 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  getDb,
+  pathEqClause
+} from "./token-goat-chunk-GVB2MUST.mjs";
+import {
+  findProject
+} from "./token-goat-chunk-4GBVPH3D.mjs";
+import {
+  canonicalize,
+  foldPath
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  normalizePath
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  globalDbPath
+} from "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/indexed_roots.ts
+init_define_import_meta_env();
+import * as path from "node:path";
+function indexedRootOf(dir) {
+  const project = findProject(dir);
+  if (project !== null) return normalizePath(project.root);
+  try {
+    return normalizePath(canonicalize(path.resolve(dir)));
+  } catch {
+    return null;
+  }
+}
+function recordIndexedRoot(dir, dbPath = globalDbPath()) {
+  try {
+    const root = indexedRootOf(dir);
+    if (root === null) return;
+    getDb(dbPath).prepare("INSERT INTO indexed_roots (root, indexed_ms) VALUES (?, ?) ON CONFLICT(root) DO UPDATE SET indexed_ms = excluded.indexed_ms").run(root, Date.now());
+  } catch {
+  }
+}
+function isIndexedRoot(dir, dbPath = globalDbPath()) {
+  if (dir === void 0) return false;
+  try {
+    const root = indexedRootOf(dir);
+    if (root === null) return false;
+    return getDb(dbPath).prepare(`SELECT 1 FROM indexed_roots WHERE ${pathEqClause("root")} LIMIT 1`).get(foldPath(root)) !== void 0;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  recordIndexedRoot,
+  isIndexedRoot
+};

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

@@ -0,0 +1,87 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  fenceUntrusted,
+  fenceWithMatches
+} from "./token-goat-chunk-4NAPX7BA.mjs";
+import {
+  estimateTokens,
+  trimToBudget
+} from "./token-goat-chunk-BFCWY73P.mjs";
+import {
+  GUARD_UNITS_PER_TOKEN,
+  guardUnits
+} from "./token-goat-chunk-XX6O25RN.mjs";
+import {
+  redactSecrets
+} from "./token-goat-chunk-T5P5ACNQ.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import {
+  UNTRUSTED_FILE_TAG,
+  scanForInjectionPatterns
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/fence_cap.ts
+init_define_import_meta_env();
+function guardThenFence(text, command, tag) {
+  const cfg = loadConfig();
+  if (!cfg.overflow_guard.enabled) return fenceUntrusted(text, tag);
+  const budget = cfg.overflow_guard.max_tokens;
+  let capped = trimToBudget(text, budget, command);
+  let reserve = 0;
+  for (let pass = 0; pass < 8; pass++) {
+    const excess = estimateTokens(fenceThenMarker(capped, text, (body) => fenceWithMatches(body, scanUnrecorded(body), tag))) - budget;
+    if (excess <= 0) break;
+    reserve += excess;
+    capped = trimToBudget(text, budget, command, { reserveTokens: reserve });
+  }
+  return fenceThenMarker(capped, text, (body) => fenceUntrusted(body, tag));
+}
+function fenceThenMarker(capped, text, fence) {
+  if (capped === text) return fence(text);
+  const markerAt = capped.lastIndexOf("\n");
+  return `${fence(capped.slice(0, markerAt))}
+${capped.slice(markerAt + 1)}`;
+}
+function scanUnrecorded(text) {
+  try {
+    return scanForInjectionPatterns(text);
+  } catch {
+    return [];
+  }
+}
+function guardRedactAndFence(text, command, tag) {
+  return guardThenFence(redactSecrets(text).text, command, tag);
+}
+function guardAndFenceFileText(text, command) {
+  return guardRedactAndFence(text, command, UNTRUSTED_FILE_TAG);
+}
+function capListField(obj, key, render) {
+  const full = render(obj);
+  const cfg = loadConfig();
+  if (!cfg.overflow_guard.enabled) return full;
+  const budget = cfg.overflow_guard.max_tokens * GUARD_UNITS_PER_TOKEN;
+  const items = obj[key];
+  if (guardUnits(full) <= budget || items.length <= 1) return full;
+  const cut = (kept) => render({ ...obj, [key]: items.slice(0, kept), truncated: true, totalCount: items.length });
+  let lo = 1;
+  let hi = items.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (guardUnits(cut(mid)) <= budget) lo = mid;
+    else hi = mid - 1;
+  }
+  return cut(lo);
+}
+
+export {
+  guardThenFence,
+  guardRedactAndFence,
+  guardAndFenceFileText,
+  capListField
+};