token-goat 2.9.26 → 2.9.28

package/dist/{token-goat-chunk-PAV6NNY7.mjs → token-goat-chunk-JXK2HQXS.mjs}

@@ -3,14 +3,14 @@ const require = __cjsRequire(import.meta.url);
 import {
   findLatestTranscript,
   readFileLines
-} from "./token-goat-chunk-62IHOU6L.mjs";
+} from "./token-goat-chunk-6DQNNFJ6.mjs";
 import {
   copilotCliUserRoot,
   readCopilotMcpTools
-} from "./token-goat-chunk-VVROQBQJ.mjs";
+} from "./token-goat-chunk-MMLMALWK.mjs";
 import {
   canonicalize
-} from "./token-goat-chunk-6E2IDLHF.mjs";
+} from "./token-goat-chunk-L45ZQRT7.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -213,6 +213,11 @@ function readNumber(source, key) {
   const value = source[key];
   return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
+function unusedMcpServers(report) {
+  const calls = report.mcpCalls;
+  return calls === null ? null : report.mcpTools.servers.filter((server) => (calls[server.serverName] ?? 0) === 0);
+}
+var MCP_DISABLE_NOTE = "'copilot mcp enable <name>' restores one, and '--disable-mcp-server <name>' drops one for a single run instead.";
 function buildCopilotWasteReport(eventsPath) {
   const report = {
     sessionPath: eventsPath,
@@ -224,14 +229,14 @@ function buildCopilotWasteReport(eventsPath) {
     hookRecordBytes: 0,
     // Measured off the file rather than off a string of its contents: an event log large enough for this number to matter is exactly the one readFileSync cannot return, since V8 caps a string at about 512 MB.
     totalEventBytes: fs.statSync(eventsPath).size,
-    // Read through the real resolution chain rather than passed in. Copilot's
-    // own COPILOT_CACHE_HOME override is what tests point at a fixture, so the
-    // shipping path is the tested path and there is no seam here that only a
-    // test ever supplies.
-    mcpTools: readCopilotMcpTools()
+    // Read through the real resolution chain rather than passed in. Copilot's own COPILOT_CACHE_HOME override is what tests point at a fixture, so the shipping path is the tested path and there is no seam here that only a test ever supplies.
+    mcpTools: readCopilotMcpTools(),
+    mcpCalls: null
   };
   const classes = /* @__PURE__ */ new Map();
   const seen = /* @__PURE__ */ new Map();
+  const mcpCalls = /* @__PURE__ */ new Map();
+  let toolExecutions = 0;
   for (const line of readFileLines(eventsPath)) {
     const trimmed = line.trim();
     if (trimmed === "") continue;
@@ -266,6 +271,12 @@ function buildCopilotWasteReport(eventsPath) {
       });
       continue;
     }
+    if (type === "tool.execution_start") {
+      toolExecutions += 1;
+      const server = data["mcpServerName"];
+      if (typeof server === "string") mcpCalls.set(server, (mcpCalls.get(server) ?? 0) + 1);
+      continue;
+    }
     if (type !== "user.message") continue;
     const transformed = typeof data["transformedContent"] === "string" ? data["transformedContent"] : "";
     if (transformed === "") continue;
@@ -293,6 +304,7 @@ function buildCopilotWasteReport(eventsPath) {
     }
   }
   report.blocks = [...classes.values()].sort((a, b) => b.bytes - a.bytes);
+  report.mcpCalls = toolExecutions === 0 ? null : Object.fromEntries(mcpCalls);
   return report;
 }
 
@@ -300,5 +312,7 @@ export {
   isCopilotTranscript,
   findLatestCopilotSession,
   findProjectSession,
+  unusedMcpServers,
+  MCP_DISABLE_NOTE,
   buildCopilotWasteReport
 };

package/dist/{token-goat-chunk-6E2IDLHF.mjs → token-goat-chunk-L45ZQRT7.mjs}

@@ -21,7 +21,7 @@ init_define_import_meta_env();
 import { createRequire } from "node:module";
 function resolveVersion() {
   if (true) {
-    return "2.9.26";
+    return "2.9.28";
   }
   const require2 = createRequire(import.meta.url);
   const pkg = require2("../package.json");

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

@@ -1,28 +1,35 @@
 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-6CCQDAYY.mjs";
+import {
+  WEB_FETCH_KEY_SEP,
+  getSessionBashOutputs,
+  getSessionBashReruns,
+  getSessionFiles,
+  getSessionWebFetches
+} from "./token-goat-chunk-GGLEE35R.mjs";
 import {
   getBashOutput
-} from "./token-goat-chunk-43JFN26X.mjs";
+} from "./token-goat-chunk-HXNAC4ZF.mjs";
 import {
+  findProject,
   loadConfig
-} from "./token-goat-chunk-LRIZ7K3F.mjs";
+} from "./token-goat-chunk-CC2PYJM7.mjs";
 import {
+  atomicWriteText,
+  dataDir,
+  ensureDirSync,
   foldPath,
   runGit,
-  toKB
-} from "./token-goat-chunk-6E2IDLHF.mjs";
+  toKB,
+  withFileLock
+} from "./token-goat-chunk-L45ZQRT7.mjs";
 import {
   displaySafePath,
   displaySafeText,
@@ -35,6 +42,174 @@ 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) {
+  const result = {};
+  for (const line of content.split("\n")) {
+    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;
+      }
+    }
+  }
+  return result;
+}
+function loadRaw(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return {};
+    }
+    const content = fs.readFileSync(filePath, "utf-8");
+    return parseTOML(content);
+  } catch {
+    return {};
+  }
+}
+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);
+    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;
+  };
+  if (withFileLock(`${p}.lock`, doSet) === void 0) doSet();
+}
+function unsetEntry(projectHash, key) {
+  validateKey(key);
+  const p = memoryPath(projectHash);
+  const doUnset = () => {
+    const entries = loadRaw(p);
+    if (key in entries) {
+      delete entries[key];
+      save(p, entries);
+    }
+    return true;
+  };
+  if (withFileLock(`${p}.lock`, doUnset) === void 0) doUnset();
+}
+function clearAll(projectHash) {
+  const p = memoryPath(projectHash);
+  const doClear = () => {
+    if (fs.existsSync(p)) {
+      save(p, {});
+    }
+    return true;
+  };
+  if (withFileLock(`${p}.lock`, doClear) === void 0) 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 +290,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 +300,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 +415,11 @@ function summaryBudgetDirective(budgetChars) {
 }
 
 export {
+  loadEntries,
+  setEntry,
+  unsetEntry,
+  clearAll,
+  projectNotesFor,
   renderWebFetchRow,
   manifestPrintedPaths,
   buildManifest,

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

@@ -0,0 +1,139 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  CONTENT_DELIVERED_REASON,
+  classifyToolError,
+  errorPrefix
+} from "./token-goat-chunk-I7CB3X4K.mjs";
+import "./token-goat-chunk-IZXKVT4A.mjs";
+import "./token-goat-chunk-RJH64KQH.mjs";
+import "./token-goat-chunk-MMLMALWK.mjs";
+import "./token-goat-chunk-GGLEE35R.mjs";
+import "./token-goat-chunk-4JMWPWCS.mjs";
+import "./token-goat-chunk-4RN64ZND.mjs";
+import "./token-goat-chunk-MVSWBNMD.mjs";
+import "./token-goat-chunk-M56BWPBN.mjs";
+import "./token-goat-chunk-CC2PYJM7.mjs";
+import "./token-goat-chunk-EEIDFMEM.mjs";
+import "./token-goat-chunk-OSUFN2FV.mjs";
+import "./token-goat-chunk-L45ZQRT7.mjs";
+import {
+  displaySafeText
+} from "./token-goat-chunk-NMTKNYGF.mjs";
+import "./token-goat-chunk-GMOUBOX4.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-7SXPJOSZ.mjs → token-goat-chunk-M56BWPBN.mjs}

@@ -15,7 +15,7 @@ import {
   foldCase,
   foldPath,
   sleepSync
-} from "./token-goat-chunk-6E2IDLHF.mjs";
+} from "./token-goat-chunk-L45ZQRT7.mjs";
 import {
   safeJoin
 } from "./token-goat-chunk-NMTKNYGF.mjs";

package/dist/{token-goat-chunk-G6EYO5CD.mjs → token-goat-chunk-MAMQPC43.mjs}

@@ -1,13 +1,8 @@
 import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
-  classifyContent,
-  guardDivisor,
-  stripAnsiEscapes
-} from "./token-goat-chunk-D2X7XN5M.mjs";
-import {
-  safeSlice
-} from "./token-goat-chunk-6E2IDLHF.mjs";
+  estimateTokensFromLength
+} from "./token-goat-chunk-4JMWPWCS.mjs";
 import {
   displaySafeText
 } from "./token-goat-chunk-NMTKNYGF.mjs";
@@ -25,82 +20,6 @@ function claudeConfigDir(homeDir = os.homedir()) {
   return path.join(homeDir, ".claude");
 }
 
-// src/overflow_guard.ts
-init_define_import_meta_env();
-function estimateTokensFromLength(length, cls = "text") {
-  return Math.max(1, Math.floor(Math.max(0, length) / guardDivisor(cls)) + 1);
-}
-function estimateTokens(text) {
-  const stripped = stripAnsiEscapes(text);
-  return estimateTokensFromLength(stripped.length, classifyContent(stripped));
-}
-function trimToBudget(text, budgetTokens, command) {
-  const markerMarginTokens = 64;
-  const strippedAll = stripAnsiEscapes(text);
-  const contentClass = classifyContent(strippedAll);
-  const totalTokens = estimateTokensFromLength(strippedAll.length, contentClass);
-  if (totalTokens <= budgetTokens) {
-    return text;
-  }
-  const lines = text.split("\n");
-  if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
-  const totalLines = lines.length;
-  const bodyBudget = Math.max(1, budgetTokens - markerMarginTokens);
-  const charBudget = bodyBudget * guardDivisor(contentClass);
-  const kept = [];
-  let used = 0;
-  for (const ln of lines) {
-    const stripped = stripAnsiEscapes(ln);
-    const cost = ln.length + 1;
-    if (kept.length === 0 && cost > charBudget) {
-      const truncated = safeSlice(stripped, charBudget);
-      kept.push(truncated);
-      break;
-    }
-    if (kept.length > 0 && used + cost > charBudget) {
-      break;
-    }
-    kept.push(ln);
-    used += cost;
-  }
-  const shown = kept.length;
-  const hint = getHintFor(command);
-  const marker = `[token-goat: output capped at ~${budgetTokens} tokens to protect context \u2014 showing ${shown} of ${totalLines} lines. ${hint}]`;
-  return kept.join("\n") + "\n" + marker;
-}
-function capJsonRows(items, budgetTokens) {
-  const totalCount = items.length;
-  const charBudget = Math.max(1, budgetTokens * guardDivisor());
-  const kept = [];
-  let used = 0;
-  for (const item of items) {
-    const cost = JSON.stringify(item).length + 2;
-    if (kept.length > 0 && used + cost > charBudget) break;
-    kept.push(item);
-    used += cost;
-  }
-  return { items: kept, truncated: kept.length < totalCount, totalCount };
-}
-function getHintFor(command) {
-  const cmd = (command || "").toLowerCase().trim();
-  if (cmd === "symbol") {
-    return "Request a specific method (file.py::Class.method) or use --json for structured access.";
-  }
-  if (cmd === "heading" || cmd === "section") {
-    return "Request a narrower sub-heading, e.g. 'doc.md::Section#2'.";
-  }
-  if (cmd === "lines") {
-    return "Request a smaller line range, e.g. 'file.py@100-150'.";
-  }
-  if (cmd === "bash-output" || cmd === "web-output") {
-    return "Use --grep PATTERN, --section HEADING, or --tail N to narrow the cached output.";
-  }
-  if (cmd === "semantic") {
-    return "Narrow your query text or pass --limit to reduce the number of matches returned.";
-  }
-  return "Narrow your query or raise overflow_guard max_tokens in config.";
-}
-
 // src/resident_context.ts
 init_define_import_meta_env();
 import * as fs from "node:fs";
@@ -307,10 +226,6 @@ function accumulateResidentLines(lines) {
 
 export {
   claudeConfigDir,
-  estimateTokensFromLength,
-  estimateTokens,
-  trimToBudget,
-  capJsonRows,
   createResidentContextStats,
   accumulateResidentLine,
   summarizeResidentContext,

package/dist/{token-goat-chunk-VVROQBQJ.mjs → token-goat-chunk-MMLMALWK.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-4JMWPWCS.mjs";
 import {
   loadConfig
-} from "./token-goat-chunk-LRIZ7K3F.mjs";
+} from "./token-goat-chunk-CC2PYJM7.mjs";
 import {
   atomicWriteText,
   backupFile,
@@ -21,7 +21,7 @@ import {
   upsertDelimitedBlock,
   withInstallScope,
   writeIfDifferent
-} from "./token-goat-chunk-6E2IDLHF.mjs";
+} from "./token-goat-chunk-L45ZQRT7.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`",
@@ -1339,6 +1340,7 @@ export {
   foldToolName,
   COPILOT_CLI_TOOL_NAME_MAP,
   MATERIALIZE_SHRUNK_IMAGE_JS,
+  COPILOT_CLI_HOOK_SCRIPT,
   buildGuidanceBody,
   skillDescriptionLine,
   buildGuidanceBlock,