token-goat 2.9.18 → 2.9.20

package/dist/{token-goat-chunk-7VLWNQDQ.mjs → token-goat-chunk-T46UKRFM.mjs}

@@ -12,7 +12,7 @@ import {
 } from "./token-goat-chunk-AH6QILZM.mjs";
 import {
   pushAll
-} from "./token-goat-chunk-QIDLJGXZ.mjs";
+} from "./token-goat-chunk-6LJNM4ZZ.mjs";
 import {
   DocumentRefusedError,
   MAX_DOCUMENT_WORK_MILLIS

package/dist/{token-goat-chunk-L7VCX33I.mjs → token-goat-chunk-T63VHOL3.mjs}

@@ -15,10 +15,10 @@ import {
   foldCase,
   foldPath,
   sleepSync
-} from "./token-goat-chunk-QIDLJGXZ.mjs";
+} from "./token-goat-chunk-6LJNM4ZZ.mjs";
 import {
   safeJoin
-} from "./token-goat-chunk-ERTXEKB6.mjs";
+} from "./token-goat-chunk-NMTKNYGF.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -1666,6 +1666,10 @@ var LANGUAGE_SPECS = [
   // Oracle PL/SQL sources: package spec and body, standalone procedure/function, trigger, and object type spec and body.
   { id: "sql", extraction: "regex", extensions: [".sql", ".pks", ".pkb", ".pls", ".plsql", ".pck", ".prc", ".fnc", ".trg", ".tps", ".tpb"], label: "SQL", ...DATA, symbolBearing: true, diffable: true, fence: "sql" },
   { id: "ini", extraction: "regex", extensions: [".ini", ".cfg", ".conf"], label: "INI", ...DATA, fence: "ini" },
+  { id: "nginx", extraction: "regex", extensions: [".nginx"], basenames: ["nginx.conf"], label: "Nginx", ...DATA, symbolBearing: true, diffable: true, fence: "nginx" },
+  // `basenames` is matched against a lower-cased basename, so `Caddyfile` is spelled in lower case here; the display spelling is the label's job.
+  { id: "caddy", extraction: "regex", extensions: [".caddy"], basenames: ["caddyfile", "caddy.conf"], label: "Caddyfile", ...DATA, symbolBearing: true, diffable: true, fence: "caddy" },
+  { id: "apache", extraction: "regex", extensions: [".apache", ".apache2"], basenames: ["httpd.conf", "apache2.conf", ".htaccess"], label: "Apache Config", ...DATA, symbolBearing: true, diffable: true, fence: "apache" },
   // `.mk` fragments (config.mk, rules.mk) share a bare Makefile's syntax.
   { id: "makefile", extraction: "regex", extensions: [".mk"], basenames: ["makefile", "gnumakefile", "bsdmakefile"], ...DATA, fence: "makefile", basenameImportsExtension: ".mk" },
   { id: "proto", extraction: "regex", extensions: [".proto"], label: "Protocol Buffers", ...DATA, symbolBearing: true, fence: "protobuf" },
@@ -2044,12 +2048,29 @@ CREATE INDEX IF NOT EXISTS idx_cache_recall_type ON cache_recall(cache_type);
 -- emission event (a hook returning a 'context' HookOutput classified as a discretionary
 -- efficiency nudge, as opposed to a mandatory informational injection -- see hint_stats.ts's
 -- doc comment for the exact category list and what is deliberately excluded). correlator is a
--- best-effort file-path/output-id substring extracted from the hint's own text, used to check
+-- file-path/output-id pointer the hint carries, used to check
 -- whether a later Bash tool call in the same session actually followed the hint's specific
--- pointer (see resolvePendingHintsForEvent) -- NULL when no such pointer could be extracted,
--- in which case the row is inserted already resolved with acted_on=0 (counted as emitted, never
--- eligible for auto-detected credit). calls_remaining is the countdown of subsequent tool-use
--- events still eligible to resolve this row before it is considered timed out.
+-- pointer (see resolvePendingHintsForEvent). Supplied by the hint builder itself via
+-- HookOutput's correlators field wherever one exists, and only fallen back to a regex scrape
+-- of the rendered hint text (hint_stats.ts's extractPathCorrelator, whose doc comment records
+-- what that scrape actually measured) where it does not. A row can name SEVERAL files -- the
+-- sed/awk line-range hint joins one per file into one emission -- stored newline-separated and
+-- matched on any member; see joinCorrelators. NULL when no pointer could be supplied or extracted,
+-- in which case the row is inserted already resolved and observable=0: there is nothing a later
+-- command could do that this row would recognize, so no verdict about it was ever observed.
+-- observable=1 is the normal case. Efficacy counts only observable rows, numerator and denominator
+-- both, because an unobservable row's acted_on is a fabrication in whichever direction the code
+-- picked and averaging fabrications into a measured rate is how 174 of bash_redirect's 698 rows
+-- came to hold its efficacy down to 0.86% when the observed figure was 1.15%. calls_remaining is
+-- the countdown of subsequent tool-use events still eligible to resolve this row before it is
+-- considered timed out. displayed=0 marks a detection that never reached the agent -- auto-
+-- suppressed, or declined by a hint's own net-benefit gate -- recorded so the ledger can answer
+-- how often a hint fired at all, which it previously could not: a suppressed detection left no
+-- trace, so a fully-muted category was indistinguishable from one that had stopped triggering.
+-- Such a row is always observable=0 and bytes_emitted=0: nothing was shown, so nothing was spent
+-- and no verdict was available. It shares hint_emissions' 180-day retention (pruneHintEmissions
+-- in stats.ts deletes on emitted_at alone), deliberately unlike hint_suppression_probes, which is
+-- one upserted row per key rather than a growing log and is therefore never pruned.
 CREATE TABLE IF NOT EXISTS hint_emissions (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
   category TEXT NOT NULL,
@@ -2060,7 +2081,9 @@ CREATE TABLE IF NOT EXISTS hint_emissions (
   resolved INTEGER NOT NULL DEFAULT 0,
   acted_on INTEGER NOT NULL DEFAULT 0,
   calls_remaining INTEGER NOT NULL DEFAULT 0,
-  bytes_emitted INTEGER
+  bytes_emitted INTEGER,
+  observable INTEGER NOT NULL DEFAULT 1,
+  displayed INTEGER NOT NULL DEFAULT 1
 );
 CREATE INDEX IF NOT EXISTS idx_hint_emissions_category ON hint_emissions(category);
 CREATE INDEX IF NOT EXISTS idx_hint_emissions_session_pending ON hint_emissions(session_id, resolved);
@@ -2206,7 +2229,7 @@ CREATE TRIGGER IF NOT EXISTS cache_recall_au AFTER UPDATE ON cache_recall BEGIN
   VALUES (new.row_id, new.label, new.content);
 END;
 `;
-var SCHEMA_VERSION = 14;
+var SCHEMA_VERSION = 16;
 function alterTableIdempotent(conn, sql) {
   try {
     conn.exec(sql);
@@ -2262,7 +2285,14 @@ var MIGRATIONS = {
   // v12 -> v13: adds files.parser_sha, the digest of the extraction logic that produced this file's rows, tracked separately from files.sha for the same reason embed_sha is -- content freshness and parse freshness are different questions, and the content sha alone could only ever answer the first. A pre-existing v12 database's `files` table predates the column, so it needs an explicit ALTER TABLE here; a brand-new database already has it from SCHEMA_SQL's CREATE TABLE above, so the ALTER TABLE would fail with "duplicate column name" there -- swallow exactly that error and rethrow anything else, same pattern as v1 -> v2 / v2 -> v3 / v8 -> v9 / v9 -> v10 above. Deliberately left NULL for every existing row rather than backfilled with the current fingerprint: NULL is the truthful answer (nobody recorded which parser wrote those rows), and it is also the answer that makes the freshness gates reparse them once, which is exactly what a database indexed by an older parser needs. v13 -> v14: changes both FTS5 tables' tokenizer to `unicode61 remove_diacritics 2`, so a search for `Noi` or `Viet` finds `Hà Nội` and `Việt Nam` -- combining marks that `remove_diacritics 1`, FTS5's default, leaves in place. This is the first schema change that `CREATE VIRTUAL TABLE IF NOT EXISTS` cannot express at all rather than merely cannot express on a populated table: against an existing virtual table that statement is a silent no-op, so without MIGRATIONS[13] the new tokenizer would reach only databases created after this release. The step drops both tables, re-runs FTS_SQL to re-create them at the current declaration, and rebuilds each from its content table.
   12: (conn) => alterTableIdempotent(conn, "ALTER TABLE files ADD COLUMN parser_sha TEXT"),
   // v13 -> v14: re-creates both FTS5 tables at the tokenizer FTS_SQL currently declares (see the SCHEMA_VERSION comment above for why no `IF NOT EXISTS` form can do this).
-  13: rebuildFtsAtCurrentTokenizer
+  13: rebuildFtsAtCurrentTokenizer,
+  // v14 -> v15: adds hint_emissions.observable and backfills it from the column that always implied it. A pre-existing v14 database's `hint_emissions` table predates the column, so it needs an explicit ALTER TABLE here; a brand-new database already has it from SCHEMA_SQL's CREATE TABLE above, so the ALTER TABLE would fail with "duplicate column name" there -- swallow exactly that error and rethrow anything else, same pattern as v8 -> v9 / v9 -> v10 / v12 -> v13 above. The backfill is exact rather than a guess: until this version a NULL correlator was the only way a row could be born with nothing to wait for, so `correlator IS NULL` identifies precisely the population the new column names. It runs unconditionally after the ALTER because alterTableIdempotent swallows the duplicate-column case, and re-running the UPDATE on an already-migrated database sets the same rows to the same values.
+  14: (conn) => {
+    alterTableIdempotent(conn, "ALTER TABLE hint_emissions ADD COLUMN observable INTEGER NOT NULL DEFAULT 1");
+    conn.prepare("UPDATE hint_emissions SET observable = 0 WHERE correlator IS NULL").run();
+  },
+  // v15 -> v16: adds hint_emissions.displayed (see the SCHEMA_VERSION comment above for why). A pre-existing v15 database's `hint_emissions` table predates the column, so it needs an explicit ALTER TABLE here; a brand-new database already has it from SCHEMA_SQL's CREATE TABLE above, so the ALTER TABLE would fail with "duplicate column name" there -- swallow exactly that error and rethrow anything else, same pattern as v8 -> v9 / v9 -> v10 / v12 -> v13 / v14 -> v15 above. No backfill, unlike v14 -> v15: until this version a row was only ever written when a hint was actually shown, so the column's own DEFAULT 1 is already the truth for every existing row, and an UPDATE would be a no-op dressed up as a migration step.
+  15: (conn) => alterTableIdempotent(conn, "ALTER TABLE hint_emissions ADD COLUMN displayed INTEGER NOT NULL DEFAULT 1")
 };
 function runMigrations(conn, fromVersion, toVersion) {
   for (let v = fromVersion; v < toVersion; v++) {

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

@@ -0,0 +1,248 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  WEB_FETCH_KEY_SEP,
+  computeAdaptiveBudget,
+  getContextPressure,
+  getSessionBashOutputs,
+  getSessionBashReruns,
+  getSessionFiles,
+  getSessionWebFetches,
+  isNoisePath,
+  listSiblingSessionStates,
+  loadSessionCache
+} from "./token-goat-chunk-KT75DZK4.mjs";
+import {
+  getBashOutput
+} from "./token-goat-chunk-SL454EN5.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-74ADIZZX.mjs";
+import {
+  foldPath,
+  runGit,
+  toKB
+} from "./token-goat-chunk-6LJNM4ZZ.mjs";
+import {
+  displaySafePath,
+  displaySafeText,
+  neutralizeSpokenMarkers
+} from "./token-goat-chunk-NMTKNYGF.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/manifest.ts
+init_define_import_meta_env();
+import { spawnSync } from "node:child_process";
+var MEM_EPOCH_TIMEOUT_MS = 800;
+var MAX_ROWS = 40;
+function appendCappedSection(lines, header, rows, cap) {
+  if (rows.length === 0) return;
+  lines.push("");
+  lines.push(header);
+  for (const row of rows.slice(0, cap)) lines.push(row);
+  if (rows.length > cap) lines.push(`- ...and ${rows.length - cap} more`);
+}
+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) {
+  const [url = key, prompt = ""] = key.split(WEB_FETCH_KEY_SEP);
+  const promptSuffix = prompt ? `, prompt: ${neutralizeSpokenMarkers(JSON.stringify(prompt))}` : "";
+  return `- ${displaySafeText(url)} (cacheId: ${cacheId}${promptSuffix})`;
+}
+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 lines = [];
+  lines.push("## Session context");
+  lines.push(`Files read: ${readFiles.length}`);
+  lines.push(`Files edited: ${editedFiles.length}`);
+  const fileRows = [];
+  const appendFileSection = (header, entries, render) => {
+    const rows = entries.map(render);
+    appendCappedSection(lines, header, rows, MAX_ROWS);
+    for (let i = 0; i < Math.min(rows.length, MAX_ROWS); i++) fileRows.push({ path: displaySafePath(entries[i].path), row: rows[i] });
+  };
+  appendFileSection("### Edited files", editedFiles, (entry) => `- ${displaySafePath(entry.path)}`);
+  appendFileSection("### Surgically read files (symbol/section reads, never read whole)", symbolOnlyFiles, renderSymbolReadRow);
+  appendFileSection("### Read files", readFiles, renderReadRow);
+  appendCappedSection(lines, "### Web URLs fetched", webFetches.map(([key, cacheId]) => renderWebFetchRow(key, cacheId)), MAX_ROWS);
+  lines.push(...buildSafeToDiscardSection(files));
+  lines.push(...buildMemEpochSection());
+  const text = capManifestChars(lines.join("\n"), sessionId, cwd, transcriptPath);
+  const seen = /* @__PURE__ */ new Set();
+  const printed = [];
+  for (const { path, row } of fileRows) {
+    if (seen.has(path) || !(text.includes(row + "\n") || text.endsWith(row))) continue;
+    seen.add(path);
+    printed.push(path);
+  }
+  return { 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 capManifestChars(manifest, sessionId, cwd, transcriptPath) {
+  const cap = loadConfig().compact_assist.max_manifest_chars;
+  if (cap <= 0) return manifest;
+  if (manifest.length <= cap) return manifest;
+  const effectiveCap = cap + adaptiveCharBonus(sessionId, cwd, transcriptPath);
+  if (manifest.length <= effectiveCap) return manifest;
+  const omitted = manifest.length - effectiveCap;
+  return manifest.slice(0, effectiveCap) + `
+...(manifest truncated at ${effectiveCap} chars; ${omitted} chars omitted)`;
+}
+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) {
+      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 lines = [];
+  lines.push("");
+  lines.push("### SAFE_TO_DISCARD (" + total + " items \u2014 provably inert; each is recallable, not gone)");
+  appendCappedSection(lines, "Superseded reruns (" + rerunRows.length + "):", rerunRows, MAX_ROWS);
+  appendCappedSection(lines, "Superseded file reads (" + supersededReadRows.length + "):", supersededReadRows, MAX_ROWS);
+  appendCappedSection(lines, "Other cached bash outputs (" + cachedOutputRows.length + "):", cachedOutputRows, MAX_ROWS);
+  return lines;
+}
+function buildMemEpochSection() {
+  let result;
+  try {
+    result = spawnSync("mem", ["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 [
+    "",
+    "### 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)`
+  ];
+}
+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>\`.`;
+}
+
+export {
+  renderWebFetchRow,
+  manifestPrintedPaths,
+  buildManifest,
+  MANIFEST_PREAMBLE,
+  MANIFEST_RECOVERY_PREAMBLE,
+  BUDGET_ESCALATION_MARKER,
+  summaryBudgetDirective
+};

package/dist/{token-goat-chunk-HIZXQVNU.mjs → token-goat-chunk-VYXGHGUY.mjs}

@@ -5,12 +5,12 @@ import {
   docxTables,
   docxText,
   formatDocxTables
-} from "./token-goat-chunk-UENEL6KX.mjs";
-import "./token-goat-chunk-7VLWNQDQ.mjs";
+} from "./token-goat-chunk-PTW22MRC.mjs";
+import "./token-goat-chunk-T46UKRFM.mjs";
 import "./token-goat-chunk-XTQAOTSO.mjs";
 import "./token-goat-chunk-AH6QILZM.mjs";
-import "./token-goat-chunk-QIDLJGXZ.mjs";
-import "./token-goat-chunk-ERTXEKB6.mjs";
+import "./token-goat-chunk-6LJNM4ZZ.mjs";
+import "./token-goat-chunk-NMTKNYGF.mjs";
 import "./token-goat-chunk-Y4AFKTHK.mjs";
 import "./token-goat-chunk-GMOUBOX4.mjs";
 import "./token-goat-chunk-A37V4PBF.mjs";

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

@@ -0,0 +1,128 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  renderWebFetchRow
+} from "./token-goat-chunk-VSJGPEBB.mjs";
+import {
+  SESSIONS_SUBDIR,
+  extractChecklistSection,
+  getSkillFilePath,
+  listSkills
+} from "./token-goat-chunk-KT75DZK4.mjs";
+import {
+  getBashOutput
+} from "./token-goat-chunk-SL454EN5.mjs";
+import {
+  loadBlob
+} from "./token-goat-chunk-K5XPIUVB.mjs";
+import {
+  resolveProjectRoot
+} from "./token-goat-chunk-74ADIZZX.mjs";
+import {
+  runGit,
+  safeSlice
+} from "./token-goat-chunk-6LJNM4ZZ.mjs";
+import {
+  displaySafePath,
+  displaySafeText,
+  neutralizeSpokenMarkers
+} from "./token-goat-chunk-NMTKNYGF.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/resume.ts
+init_define_import_meta_env();
+import { readFile } from "node:fs/promises";
+var MAX_RESUME_TOKENS = 2e3;
+var MAX_RESUME_CHARS = MAX_RESUME_TOKENS * 4;
+var MAX_RESUME_WEB_FETCHES = 8;
+var SKILL_MAX_COUNT = 3;
+var SKILL_MAX_CHARS_EACH = 400;
+async function buildSkillsSection(sessionId) {
+  const skills = await listSkills(sessionId);
+  if (skills.length === 0) return [];
+  const skillLines = ["## Skills"];
+  for (const skill of skills.slice(0, SKILL_MAX_COUNT)) {
+    let checklist = null;
+    try {
+      const filePath = await getSkillFilePath(skill.name);
+      if (filePath !== null) {
+        const body = await readFile(filePath, "utf-8");
+        checklist = extractChecklistSection(body);
+      }
+    } catch {
+      checklist = null;
+    }
+    if (checklist !== null) {
+      const trimmed = checklist.length > SKILL_MAX_CHARS_EACH ? checklist.slice(0, SKILL_MAX_CHARS_EACH).trimEnd() + "\u2026" : checklist;
+      skillLines.push(`**${displaySafeText(skill.name)}**:`);
+      skillLines.push(neutralizeSpokenMarkers(trimmed));
+    } else {
+      skillLines.push(`**${displaySafeText(skill.name)}** \u2014 \`token-goat skill-body ${displaySafeText(skill.name)} --section DoD\``);
+    }
+  }
+  skillLines.push("");
+  return skillLines;
+}
+async function buildResumePacket(sessionId) {
+  const blob = loadBlob(SESSIONS_SUBDIR, sessionId);
+  if (blob === null || typeof blob !== "object") return null;
+  const raw = blob;
+  const filesArr = Array.isArray(raw["files"]) ? raw["files"] : [];
+  const lines = [`# Resume packet \u2014 session ${displaySafeText(sessionId)}`, ""];
+  try {
+    lines.push(...await buildSkillsSection(sessionId));
+  } catch {
+  }
+  const editedPaths = filesArr.filter((f) => f["wasEdited"] === true).map((f) => typeof f["path"] === "string" ? f["path"] : "").filter(Boolean).slice(0, 10);
+  if (editedPaths.length > 0) {
+    lines.push("## Edited files");
+    for (const p of editedPaths) lines.push(`- ${displaySafePath(p)}`);
+    lines.push("");
+  }
+  const topRead = [...filesArr].filter((f) => f["wasEdited"] !== true).sort((a, b) => (typeof b["readCount"] === "number" ? b["readCount"] : 0) - (typeof a["readCount"] === "number" ? a["readCount"] : 0)).slice(0, 8).map((f) => typeof f["path"] === "string" ? f["path"] : "").filter(Boolean);
+  if (topRead.length > 0) {
+    lines.push("## Top files read");
+    for (const p of topRead) lines.push(`- ${displaySafePath(p)}`);
+    lines.push("");
+  }
+  const bashOutputs = Array.isArray(raw["bashOutputs"]) ? raw["bashOutputs"] : [];
+  const recentBash = bashOutputs.slice(-2);
+  if (recentBash.length > 0) {
+    lines.push("## Recent bash commands");
+    for (const entry of recentBash) {
+      if (Array.isArray(entry) && typeof entry[1] === "string") {
+        const bashEntry = getBashOutput(entry[1]);
+        if (bashEntry !== null) lines.push(`- ${displaySafeText(bashEntry.command)}`);
+      }
+    }
+    lines.push("");
+  }
+  const webFetches = Array.isArray(raw["webFetches"]) ? raw["webFetches"] : [];
+  const webRows = webFetches.slice(-MAX_RESUME_WEB_FETCHES).filter((e) => Array.isArray(e) && typeof e[0] === "string" && typeof e[1] === "string").map(([key, cacheId]) => renderWebFetchRow(key, cacheId));
+  if (webRows.length > 0) {
+    lines.push("## Web pages fetched");
+    lines.push(...webRows);
+    lines.push("");
+  }
+  try {
+    const projectRoot = resolveProjectRoot();
+    const result = runGit(["diff", "--stat"], { cwd: projectRoot });
+    if (result.exitCode === 0 && result.stdout.trim().length > 0) {
+      lines.push("## Uncommitted changes (git diff --stat)");
+      lines.push(result.stdout.trim().split("\n").map(displaySafeText).join("\n"));
+      lines.push("");
+    }
+  } catch {
+  }
+  const text = lines.join("\n");
+  if (text.length <= MAX_RESUME_CHARS) return text;
+  return safeSlice(text, MAX_RESUME_CHARS) + "\n... (truncated to cap)\n";
+}
+
+export {
+  MAX_RESUME_TOKENS,
+  MAX_RESUME_CHARS,
+  buildResumePacket
+};