token-goat 2.9.26 → 2.9.29

package/dist/{token-goat-chunk-VVROQBQJ.mjs → token-goat-chunk-EUSDXRXU.mjs}

@@ -2,10 +2,10 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   estimateTokensFromLength
-} from "./token-goat-chunk-G6EYO5CD.mjs";
+} from "./token-goat-chunk-52NSDWYY.mjs";
 import {
   loadConfig
-} from "./token-goat-chunk-LRIZ7K3F.mjs";
+} from "./token-goat-chunk-TGOXNAHW.mjs";
 import {
   atomicWriteText,
   backupFile,
@@ -21,7 +21,7 @@ import {
   upsertDelimitedBlock,
   withInstallScope,
   writeIfDifferent
-} from "./token-goat-chunk-6E2IDLHF.mjs";
+} from "./token-goat-chunk-XYWPOSCN.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -51,6 +51,7 @@ function buildGuidanceBody(fallbackToolClause, opts = {}) {
     '- not knowing which command answers a question you can already state in words \u2192 `answer "<question>"`, which resolves the subject in the index, runs the right command, prints `via: <command>`, and refuses rather than guess',
     '- a shell text search with context flags to find a function body \u2192 `read "file::symbol"`',
     '- paging one function with view/view_range \u2192 `read "file::symbol"`',
+    "- a read refused by a `[tg]` deny, retried with a shifted range or a different read tool \u2192 the command the deny names",
     '- reading a symbol plus chasing its callers and containing doc section as separate reads \u2192 `brief "file::symbol"`',
     '- reading one heading of a large doc \u2192 `section "file::Heading"`',
     "- searching for a symbol's callers \u2192 `refs file::symbol --callers`",
@@ -369,6 +370,30 @@ function foldToolName(name) {
   return typeof name === "string" ? name.toLowerCase().replace(/[_-]/g, "") : "";
 }
 
+// src/bridges/shim_try_server.ts
+init_define_import_meta_env();
+var SHIM_TRY_SERVER = `// Attempts the resident hook server (src/hook_server.ts): the sibling hook client sends this
+// call to an already-running token-goat process, so neither Node's module loading nor the hook
+// graph is paid for again. The CommonJS client comes first: this shim is CommonJS, and loading
+// the ES module one starts Node's ESM loader, about 5ms of a call the server answers. The ES
+// module one is for an install built before the CommonJS file existed. It returns undefined
+// whenever nothing was dispatched -- no server yet (it starts one in the background), all busy,
+// replaced by a newer build, turned off, or an install predating the client -- and the caller
+// then runs the call itself.
+async function tryServer(entryPath, eventName, input, harnessWaitMs) {
+  if (!entryPath) return undefined
+  try {
+    const fs = require('node:fs')
+    const cjsPath = path.join(path.dirname(entryPath), 'token-goat-hook-client.cjs')
+    const mjsPath = path.join(path.dirname(entryPath), 'token-goat-hook-client.mjs')
+    const client = fs.existsSync(cjsPath) ? require(cjsPath) : fs.existsSync(mjsPath) ? await import(pathToFileURL(mjsPath).href) : undefined
+    if (client === undefined) return undefined
+    return await client.relayViaServer(eventName, input, harnessWaitMs)
+  } catch {
+    return undefined
+  }
+}`;
+
 // src/bridges/shrink_block.ts
 init_define_import_meta_env();
 var MATERIALIZE_SHRUNK_IMAGE_JS = `// Best-effort sweep of previously materialized shrunk copies in the OS temp dir. The temp file only needs to outlive the single tool call whose path argument was rewritten to it, so anything older than an hour is finished with; the "token-goat-shrink-" prefix check confines the sweep to this mechanism's own files (same defense-in-depth rule as pruneShrinkCache in src/image_shrink.ts). Throttled per process; runs only when a shrink payload actually arrives, so the common no-image path never pays for it.
@@ -665,7 +690,9 @@ function remapToolInput(copilotToolName, input) {
   return out
 }
 
-// Attempts the in-process hook call: import()s dist/token-goat-hook.mjs (a sibling of
+${SHIM_TRY_SERVER}
+
+// Attempts the resident server (tryServer above), then the in-process hook call: import()s dist/token-goat-hook.mjs (a sibling of
 // the baked token-goat entry path, built with zero load-time side effects -- unlike
 // the CLI entry, which runs the full argv-parsing CLI as a side effect of being
 // loaded) and calls its exported relayInProcess() directly, avoiding a second node
@@ -675,14 +702,17 @@ function remapToolInput(copilotToolName, input) {
 async function tryInProcess(entryPath, tgEvent, canonical, harness) {
   if (!entryPath) return undefined
   try {
-    const hookLibPath = path.join(path.dirname(entryPath), 'token-goat-hook.mjs')
-    if (!require('node:fs').existsSync(hookLibPath)) return undefined
-    const mod = await import(pathToFileURL(hookLibPath).href)
+    // Set before either path: the resident server runs the call under this process's environment.
     process.env.TOKEN_GOAT_HARNESS_OVERRIDE = harness
     // Which hooks directory VS Code loaded this shim from is the only thing separating a
     // user-scope copy from a project-scope one -- the two files are byte-identical and so are
     // their payloads. vscode_duplicate.ts needs it to stand the redundant copy down.
     if (harness === 'vscode') process.env.TOKEN_GOAT_VSCODE_HOOKS_DIR = __dirname
+    const served = await tryServer(entryPath, tgEvent, canonical)
+    if (served !== undefined) return served
+    const hookLibPath = path.join(path.dirname(entryPath), 'token-goat-hook.mjs')
+    if (!require('node:fs').existsSync(hookLibPath)) return undefined
+    const mod = await import(pathToFileURL(hookLibPath).href)
     return await mod.relayInProcess(tgEvent, canonical)
   } catch {
     return undefined
@@ -1173,13 +1203,26 @@ function buildConfig(scriptPath) {
   return { version: 1, hooks };
 }
 var HOOKS_CONFIG_FILE = "token-goat.json";
-var HOOKS_SCRIPT_FILE = "token-goat-shim.js";
+var HOOKS_SCRIPT_FILE = "token-goat-shim.cjs";
+var LEGACY_HOOKS_SCRIPT_FILE = "token-goat-shim.js";
 var HOOKS_OWNERS_FILE = "token-goat.owners";
+var HOOKS_SCRIPT_FORWARDER = `#!/usr/bin/env node
+// Forwarder for compatibility with cached hook definitions in running Copilot CLI sessions.
+import('./token-goat-shim.cjs').catch(() => {
+  try { process.stdout.write('{}') } catch {}
+  process.exitCode = 0
+});
+`;
 function copilotHooksOwnersPath(hooksDir) {
   return path3.join(hooksDir, HOOKS_OWNERS_FILE);
 }
 function copilotHooksFilePaths(hooksDir) {
-  return [path3.join(hooksDir, HOOKS_CONFIG_FILE), path3.join(hooksDir, HOOKS_SCRIPT_FILE), copilotHooksOwnersPath(hooksDir)];
+  return [
+    path3.join(hooksDir, HOOKS_CONFIG_FILE),
+    path3.join(hooksDir, HOOKS_SCRIPT_FILE),
+    path3.join(hooksDir, LEGACY_HOOKS_SCRIPT_FILE),
+    copilotHooksOwnersPath(hooksDir)
+  ];
 }
 function readCopilotHooksOwners(hooksDir) {
   const owners = /* @__PURE__ */ new Set();
@@ -1199,14 +1242,16 @@ function readCopilotHooksOwners(hooksDir) {
 function installCopilotHooksFile(hooksDir, owner) {
   const configPath = path3.join(hooksDir, HOOKS_CONFIG_FILE);
   const scriptPath = path3.join(hooksDir, HOOKS_SCRIPT_FILE);
+  const legacyScriptPath = path3.join(hooksDir, LEGACY_HOOKS_SCRIPT_FILE);
   const owners = readCopilotHooksOwners(hooksDir);
   const scriptChanged = writeIfDifferent(scriptPath, COPILOT_CLI_HOOK_SCRIPT);
+  const legacyScriptChanged = writeIfDifferent(legacyScriptPath, HOOKS_SCRIPT_FORWARDER);
   const desiredText = JSON.stringify(buildConfig(scriptPath), null, 2) + "\n";
   const configChanged = writeIfDifferent(configPath, desiredText, true);
   recordCreatedConfig(configPath);
   owners.add(owner);
   const ownersChanged = writeIfDifferent(copilotHooksOwnersPath(hooksDir), [...owners].sort().join("\n") + "\n");
-  return { configPath, scriptPath, changed: scriptChanged || configChanged || ownersChanged };
+  return { configPath, scriptPath, changed: scriptChanged || legacyScriptChanged || configChanged || ownersChanged };
 }
 function releaseCopilotHooksFile(hooksDir, owner, keepBackups = false) {
   const ownersPath = copilotHooksOwnersPath(hooksDir);
@@ -1222,8 +1267,9 @@ function releaseCopilotHooksFile(hooksDir, owner, keepBackups = false) {
   if (!keepBackups) removeCreatedBackups(path3.join(hooksDir, HOOKS_CONFIG_FILE));
   takeCreatedConfig(path3.join(hooksDir, HOOKS_CONFIG_FILE));
   const scriptRemoved = removeFileInScope(path3.join(hooksDir, HOOKS_SCRIPT_FILE));
+  const legacyScriptRemoved = removeFileInScope(path3.join(hooksDir, LEGACY_HOOKS_SCRIPT_FILE));
   const ownersRemoved = removeFileInScope(ownersPath);
-  return configRemoved || scriptRemoved || ownersRemoved;
+  return configRemoved || scriptRemoved || legacyScriptRemoved || ownersRemoved;
 }
 function installCopilotCli(opts = {}) {
   return withInstallScope(projectScopeRoot(opts), () => installCopilotCliScoped(opts));
@@ -1258,7 +1304,8 @@ function uninstallCopilotCli(opts = {}) {
   return userRemoved || localRemoved;
 }
 function isCopilotCliInstalled(opts = {}) {
-  if (!fs3.existsSync(copilotCliConfigPath(opts)) || !fs3.existsSync(copilotCliScriptPath(opts))) {
+  const scriptPresent = fs3.existsSync(copilotCliScriptPath(opts)) || fs3.existsSync(path3.join(copilotCliHooksDir(opts), LEGACY_HOOKS_SCRIPT_FILE));
+  if (!fs3.existsSync(copilotCliConfigPath(opts)) || !scriptPresent) {
     return false;
   }
   if (!readCopilotHooksOwners(copilotCliHooksDir(opts)).has("copilot")) return false;
@@ -1338,7 +1385,9 @@ function readCopilotMcpTools(dir = copilotCliMcpToolsDir()) {
 export {
   foldToolName,
   COPILOT_CLI_TOOL_NAME_MAP,
+  SHIM_TRY_SERVER,
   MATERIALIZE_SHRUNK_IMAGE_JS,
+  COPILOT_CLI_HOOK_SCRIPT,
   buildGuidanceBody,
   skillDescriptionLine,
   buildGuidanceBlock,
@@ -1368,6 +1417,7 @@ export {
   copilotCliConfigPath,
   copilotCliScriptPath,
   HOOKS_SCRIPT_FILE,
+  LEGACY_HOOKS_SCRIPT_FILE,
   copilotHooksFilePaths,
   readCopilotHooksOwners,
   installCopilotHooksFile,

package/dist/{token-goat-chunk-POOI26O6.mjs → token-goat-chunk-FTP4U4QA.mjs}

@@ -20,19 +20,23 @@ import {
   setOcrTimeoutForTesting,
   setTesseractEntryForTesting,
   verifyOcrLangCache
-} from "./token-goat-chunk-5M3NRJD2.mjs";
-import "./token-goat-chunk-D2X7XN5M.mjs";
-import "./token-goat-chunk-7SXPJOSZ.mjs";
+} from "./token-goat-chunk-VZQEWRVH.mjs";
+import "./token-goat-chunk-D4ETHJD6.mjs";
+import "./token-goat-chunk-CIQ2FTY3.mjs";
+import "./token-goat-chunk-7CPMDFGB.mjs";
 import {
   DEFAULT_OCR_LANG,
   isSupportedOcrLang,
   resolveOcrLangs
-} from "./token-goat-chunk-LRIZ7K3F.mjs";
-import "./token-goat-chunk-EEIDFMEM.mjs";
-import "./token-goat-chunk-OSUFN2FV.mjs";
-import "./token-goat-chunk-6E2IDLHF.mjs";
+} from "./token-goat-chunk-TGOXNAHW.mjs";
+import "./token-goat-chunk-XB5KKOCG.mjs";
+import "./token-goat-chunk-YZAAZU2S.mjs";
+import "./token-goat-chunk-IVE6U7KV.mjs";
+import "./token-goat-chunk-XYWPOSCN.mjs";
+import "./token-goat-chunk-TCQANXYC.mjs";
 import "./token-goat-chunk-NMTKNYGF.mjs";
-import "./token-goat-chunk-GMOUBOX4.mjs";
+import "./token-goat-chunk-MELOKFDJ.mjs";
+import "./token-goat-chunk-JTKCQMQA.mjs";
 import "./token-goat-chunk-A37V4PBF.mjs";
 export {
   DEFAULT_OCR_LANG,

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

@@ -0,0 +1,142 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  CONTENT_DELIVERED_REASON,
+  classifyToolError,
+  errorPrefix
+} from "./token-goat-chunk-E4ZOJIZK.mjs";
+import "./token-goat-chunk-E5TK5DNO.mjs";
+import "./token-goat-chunk-ZER6EAXZ.mjs";
+import "./token-goat-chunk-EUSDXRXU.mjs";
+import "./token-goat-chunk-TDUT2CL6.mjs";
+import "./token-goat-chunk-52NSDWYY.mjs";
+import "./token-goat-chunk-2WOUYWLM.mjs";
+import "./token-goat-chunk-CIQ2FTY3.mjs";
+import "./token-goat-chunk-7CPMDFGB.mjs";
+import "./token-goat-chunk-TGOXNAHW.mjs";
+import "./token-goat-chunk-XB5KKOCG.mjs";
+import "./token-goat-chunk-YZAAZU2S.mjs";
+import "./token-goat-chunk-IVE6U7KV.mjs";
+import "./token-goat-chunk-XYWPOSCN.mjs";
+import "./token-goat-chunk-TCQANXYC.mjs";
+import {
+  displaySafeText
+} from "./token-goat-chunk-NMTKNYGF.mjs";
+import "./token-goat-chunk-MELOKFDJ.mjs";
+import "./token-goat-chunk-JTKCQMQA.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/tool_error_census.ts
+init_define_import_meta_env();
+var UNKNOWN_PREFIX_LIMIT = 20;
+var REASONS_PER_ROW = 4;
+var UNKNOWN_MODEL = "(unknown)";
+function tally(map, name) {
+  let row = map.get(name);
+  if (row === void 0) {
+    row = { name, calls: 0, errors: 0, unknown: 0, delivered: 0, expected: {} };
+    map.set(name, row);
+  }
+  return row;
+}
+function byCodeUnit(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function sortTallies(map) {
+  return [...map.values()].sort((a, b) => b.errors - a.errors || b.calls - a.calls || byCodeUnit(a.name, b.name));
+}
+function newToolErrorAccumulator() {
+  const tools = /* @__PURE__ */ new Map();
+  const models = /* @__PURE__ */ new Map();
+  const unknownPrefixes = /* @__PURE__ */ new Map();
+  return {
+    countCall(tool, model) {
+      tally(tools, tool).calls += 1;
+      tally(models, model ?? UNKNOWN_MODEL).calls += 1;
+    },
+    countError(tool, model, errorText, flags) {
+      const verdict = classifyToolError(tool, errorText, flags);
+      const rows = [tally(tools, tool), tally(models, model ?? UNKNOWN_MODEL)];
+      if (verdict.reason === CONTENT_DELIVERED_REASON) {
+        for (const row of rows) row.delivered += 1;
+        return;
+      }
+      for (const row of rows) {
+        row.errors += 1;
+        if (verdict.kind === "unknown") row.unknown += 1;
+        else row.expected[verdict.reason] = (row.expected[verdict.reason] ?? 0) + 1;
+      }
+      if (verdict.kind !== "unknown") return;
+      const prefix = errorPrefix(errorText);
+      const key = `${tool}\0${prefix}`;
+      const hit = unknownPrefixes.get(key);
+      if (hit === void 0) unknownPrefixes.set(key, { tool, prefix, count: 1 });
+      else hit.count += 1;
+    },
+    finish() {
+      const topUnknown = [...unknownPrefixes.values()].sort((a, b) => b.count - a.count || byCodeUnit(a.tool, b.tool) || byCodeUnit(a.prefix, b.prefix)).slice(0, UNKNOWN_PREFIX_LIMIT);
+      return { byTool: sortTallies(tools), byModel: sortTallies(models), unknownPrefixes: topUnknown };
+    }
+  };
+}
+function fmt(n) {
+  return n.toLocaleString("en-US");
+}
+function rate(errors, calls) {
+  return calls === 0 ? "-" : `${(errors / calls * 100).toFixed(1)}%`;
+}
+function reasonsCell(expected) {
+  const ranked = Object.entries(expected).sort((a, b) => b[1] - a[1] || byCodeUnit(a[0], b[0]));
+  const shown = ranked.slice(0, REASONS_PER_ROW).map(([reason, n]) => `${reason} ${fmt(n)}`);
+  const rest = ranked.slice(REASONS_PER_ROW).reduce((sum, [, n]) => sum + n, 0);
+  if (rest > 0) shown.push(`+${fmt(rest)} more`);
+  return shown.join(", ");
+}
+function columnWidth(names, header) {
+  return names.reduce((w, n) => Math.max(w, n.length), header.length);
+}
+function tableLines(rows) {
+  const failing = rows.filter((r) => r.errors > 0);
+  const names = failing.map((r) => displaySafeText(r.name));
+  const width = columnWidth(names, "name");
+  const out = [`${"name".padEnd(width)} ${"calls".padStart(9)} ${"errors".padStart(7)} ${"rate".padStart(6)} ${"unknown".padStart(7)}  expected, by reason`];
+  failing.forEach((r, i) => out.push(`${names[i].padEnd(width)} ${fmt(r.calls).padStart(9)} ${fmt(r.errors).padStart(7)} ${rate(r.errors, r.calls).padStart(6)} ${fmt(r.unknown).padStart(7)}  ${reasonsCell(r.expected)}`.trimEnd()));
+  if (failing.length < rows.length) out.push(`(${fmt(rows.length - failing.length)} more ran without an error)`);
+  return out;
+}
+function deliveredLines(rows) {
+  const delivering = rows.filter((r) => r.delivered > 0).sort((a, b) => b.delivered - a.delivered || byCodeUnit(a.name, b.name));
+  if (delivering.length === 0) return [];
+  const total = delivering.reduce((sum, r) => sum + r.delivered, 0);
+  return [`Content delivered by a token-goat deny, not counted as errors: ${fmt(total)} (${delivering.map((r) => `${displaySafeText(r.name)} ${fmt(r.delivered)}`).join(", ")}).`];
+}
+function formatToolErrorCensus(census, scope) {
+  const calls = census.byTool.reduce((sum, r) => sum + r.calls, 0);
+  const errors = census.byTool.reduce((sum, r) => sum + r.errors, 0);
+  const unknown = census.byTool.reduce((sum, r) => sum + r.unknown, 0);
+  const toolWidth = columnWidth(census.unknownPrefixes.map((p) => displaySafeText(p.tool)), "");
+  const window = scope.windowDays === 0 ? "all time" : `transcripts modified in the last ${fmt(scope.windowDays)} days`;
+  const lines = [
+    `# Tool errors (${fmt(scope.filesScanned)} transcripts, ${window})`,
+    `Calls ${fmt(calls)}, errors ${fmt(errors)} (${rate(errors, calls)}), unknown ${fmt(unknown)}. Expected means a named failure shape in tool_error_class.ts; unknown is everything else.`,
+    ...deliveredLines(census.byTool),
+    "",
+    "## By tool",
+    ...tableLines(census.byTool),
+    "",
+    "## By model",
+    ...tableLines(census.byModel),
+    "",
+    "## Top unknown error prefixes (paths, quoted text and digits masked)",
+    ...census.unknownPrefixes.map((p) => `${fmt(p.count).padStart(7)}  ${displaySafeText(p.tool).padEnd(toolWidth)} ${displaySafeText(p.prefix)}`)
+  ];
+  if (census.unknownPrefixes.length === 0) lines.push("(none)");
+  return lines.join("\n");
+}
+export {
+  UNKNOWN_PREFIX_LIMIT,
+  formatToolErrorCensus,
+  newToolErrorAccumulator
+};

package/dist/{token-goat-chunk-MDV5VWF4.mjs → token-goat-chunk-G7IWXCFF.mjs}

@@ -1,33 +1,47 @@
 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-M6CVNHTW.mjs";
+} from "./token-goat-chunk-H5J3C56Q.mjs";
+import {
+  WEB_FETCH_KEY_SEP,
+  getSessionBashOutputs,
+  getSessionBashReruns,
+  getSessionFiles,
+  getSessionWebFetches
+} from "./token-goat-chunk-TDUT2CL6.mjs";
 import {
   getBashOutput
-} from "./token-goat-chunk-43JFN26X.mjs";
+} from "./token-goat-chunk-O6I2XU4P.mjs";
 import {
+  findProject,
   loadConfig
-} from "./token-goat-chunk-LRIZ7K3F.mjs";
+} from "./token-goat-chunk-TGOXNAHW.mjs";
 import {
-  foldPath,
+  LOCK_WAIT_MS_HARDENED,
+  atomicWriteText,
+  ensureDirSync,
   runGit,
-  toKB
-} from "./token-goat-chunk-6E2IDLHF.mjs";
+  toKB,
+  withFileLock,
+  withRetryOnLock
+} from "./token-goat-chunk-XYWPOSCN.mjs";
+import {
+  foldPath,
+  sleepSync
+} from "./token-goat-chunk-TCQANXYC.mjs";
 import {
   displaySafePath,
   displaySafeText,
   neutralizeSpokenMarkers
 } from "./token-goat-chunk-NMTKNYGF.mjs";
+import {
+  dataDir
+} from "./token-goat-chunk-MELOKFDJ.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -35,6 +49,193 @@ import {
 // src/manifest.ts
 init_define_import_meta_env();
 import { spawnSync } from "node:child_process";
+
+// src/project_memory.ts
+init_define_import_meta_env();
+import * as fs 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}$/;
+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 = []) {
+  const result = {};
+  for (const [i, line] of content.split("\n").entries()) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const match = trimmed.match(/^([A-Za-z0-9_-]+)\s*=\s*"(.*)"\s*$/);
+    if (match) {
+      const [, key, value] = match;
+      if (key && value !== void 0) {
+        const unescaped = value.replace(/\\([\\nrt"])/g, (_, c) => {
+          switch (c) {
+            case "\\":
+              return "\\";
+            case "n":
+              return "\n";
+            case "r":
+              return "\r";
+            case '"':
+              return '"';
+            default:
+              return _;
+          }
+        });
+        result[key] = unescaped;
+      }
+    } else {
+      unparsed.push(i + 1);
+    }
+  }
+  return result;
+}
+function loadRaw(filePath, forUpdate = false) {
+  let content = "";
+  try {
+    withRetryOnLock(() => {
+      content = fs.readFileSync(filePath, "utf-8");
+    });
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw err;
+  }
+  const unparsed = [];
+  const entries = parseTOML(content, unparsed);
+  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) {
+  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");
+    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 setEntry(projectHash, key, value) {
+  validateKey(key);
+  const p = memoryPath(projectHash);
+  const dir = path.dirname(p);
+  ensureDirSync(dir);
+  const doSet = () => {
+    const entries = loadRaw(p, true);
+    const isNewKey = !(key in entries);
+    if (isNewKey && Object.keys(entries).length >= MAX_ENTRIES) {
+      const keysToKeep = MAX_ENTRIES - 1;
+      const allKeys = Object.keys(entries).sort((a, b) => ordinal(a, b));
+      for (const k of allKeys.slice(keysToKeep)) {
+        delete entries[k];
+      }
+    }
+    entries[key] = value;
+    save(p, entries);
+    return true;
+  };
+  underNotesLock(p, doSet);
+}
+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 (fs.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);
+  const doUnset = () => {
+    const entries = loadRaw(p, true);
+    if (key in entries) {
+      delete entries[key];
+      save(p, entries);
+    }
+    return true;
+  };
+  underNotesLock(p, doUnset);
+}
+function clearAll(projectHash) {
+  const p = memoryPath(projectHash);
+  const doClear = () => {
+    if (fs.existsSync(p)) {
+      save(p, {});
+    }
+    return true;
+  };
+  underNotesLock(p, doClear);
+}
+function buildInjection(projectHash) {
+  try {
+    const entries = loadEntries(projectHash);
+    if (Object.keys(entries).length === 0) {
+      return null;
+    }
+    const header = '### Project notes (`token-goat note set <key> "<finding>"`)';
+    const lines = [header];
+    let total = header.length;
+    let skipped = 0;
+    const entries_list = Object.entries(entries).sort(([a], [b]) => ordinal(a, b)).slice(0, MAX_ENTRIES);
+    for (const [key, val] of entries_list) {
+      const display = val.length <= MAX_VALUE_LEN ? val : val.slice(0, MAX_VALUE_LEN) + "\u2026";
+      const line = `- **${key}**: ${display}`;
+      if (total + line.length + 1 > MAX_TOTAL_CHARS) {
+        skipped++;
+        continue;
+      }
+      lines.push(line);
+      total += line.length + 1;
+    }
+    if (skipped > 0) {
+      while (lines.length > 1 && total + `- (+${skipped} more memory entries omitted -- total size limit reached)`.length + 1 > MAX_TOTAL_CHARS) {
+        const popped = lines.pop();
+        total -= popped.length + 1;
+        skipped++;
+      }
+      lines.push(`- (+${skipped} more memory entries omitted -- total size limit reached)`);
+    }
+    return lines.join("\n");
+  } catch {
+    return null;
+  }
+}
+function projectNotesFor(cwd) {
+  if (cwd === void 0) return null;
+  try {
+    const project = findProject(cwd);
+    return project === null ? null : buildInjection(project.hash);
+  } catch {
+    return null;
+  }
+}
+
+// src/manifest.ts
 var MEM_EPOCH_TIMEOUT_MS = 800;
 var MAX_ROWS = 40;
 function appendCappedSection(lines, header, rows, cap) {
@@ -115,6 +316,8 @@ function buildManifestParts(sessionId, cwd, transcriptPath) {
     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)}`);
+  const notes = projectNotesFor(cwd);
+  if (notes !== null) lines.push("", notes);
   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);
@@ -123,10 +326,10 @@ function buildManifestParts(sessionId, cwd, transcriptPath) {
   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);
+  for (const { path: path2, row } of fileRows) {
+    if (seen.has(path2) || !(text.includes(row + "\n") || text.endsWith(row))) continue;
+    seen.add(path2);
+    printed.push(path2);
   }
   return { text, printed };
 }
@@ -238,6 +441,11 @@ function summaryBudgetDirective(budgetChars) {
 }
 
 export {
+  loadEntries,
+  setEntry,
+  unsetEntry,
+  clearAll,
+  projectNotesFor,
   renderWebFetchRow,
   manifestPrintedPaths,
   buildManifest,

package/dist/{token-goat-chunk-C2PG4K5D.mjs → token-goat-chunk-GLXRTTLE.mjs}

@@ -10,16 +10,18 @@ import {
   querySheet,
   rangeSheet,
   xlsxColumns
-} from "./token-goat-chunk-STYRLQIW.mjs";
-import "./token-goat-chunk-L43RKNHA.mjs";
+} from "./token-goat-chunk-PYSUADX4.mjs";
+import "./token-goat-chunk-DNSPXQXQ.mjs";
 import "./token-goat-chunk-3BTK54F3.mjs";
-import "./token-goat-chunk-RIB6XY2V.mjs";
+import "./token-goat-chunk-UXSXQQIY.mjs";
 import "./token-goat-chunk-XTQAOTSO.mjs";
 import "./token-goat-chunk-AH6QILZM.mjs";
-import "./token-goat-chunk-6E2IDLHF.mjs";
+import "./token-goat-chunk-XYWPOSCN.mjs";
+import "./token-goat-chunk-TCQANXYC.mjs";
 import "./token-goat-chunk-NMTKNYGF.mjs";
+import "./token-goat-chunk-MELOKFDJ.mjs";
 import "./token-goat-chunk-Y4AFKTHK.mjs";
-import "./token-goat-chunk-GMOUBOX4.mjs";
+import "./token-goat-chunk-JTKCQMQA.mjs";
 import "./token-goat-chunk-A37V4PBF.mjs";
 export {
   XlsxScanTooLargeError,