token-goat 2.6.36 → 2.8.1

package/dist/{token-goat-chunk-VYMGEVZS.mjs → token-goat-chunk-XEDQH5DA.mjs}

@@ -1,12 +1,14 @@
 import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
+  copilotCliMcpToolsDir,
+  estimateTokensFromLength,
   isBlobStale,
   isBuildCommand,
   loadBlob,
   sanitizeFtsQuery,
   storeBlob
-} from "./token-goat-chunk-UFOVM7ZN.mjs";
+} from "./token-goat-chunk-2G6RAB4G.mjs";
 import {
   SYMBOL_BODY_CHAR_CAP,
   extractErrorMessage,
@@ -16,11 +18,94 @@ import {
   redactSecrets,
   runGit,
   shortFingerprint
-} from "./token-goat-chunk-V465YKOR.mjs";
+} from "./token-goat-chunk-ELDJRLHZ.mjs";
 import {
   registerReset
 } from "./token-goat-chunk-AO2QD2AG.mjs";
 
+// src/copilot_mcp_tools.ts
+import fs from "node:fs";
+import path from "node:path";
+function wireShapeLength(tools) {
+  const wire = tools.map((tool) => {
+    const out = {};
+    if (typeof tool.name === "string") out["name"] = tool.name;
+    if (typeof tool.description === "string") out["description"] = tool.description;
+    if (tool.inputSchema !== void 0) out["inputSchema"] = tool.inputSchema;
+    return out;
+  });
+  return JSON.stringify(wire).length;
+}
+function readCopilotMcpTools(dir = copilotCliMcpToolsDir()) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return { cacheFound: false, servers: [], unreadable: 0 };
+  }
+  const newest = /* @__PURE__ */ new Map();
+  let unreadable = 0;
+  for (const entry of entries) {
+    if (!entry.toLowerCase().endsWith(".json")) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(fs.readFileSync(path.join(dir, entry), "utf8"));
+    } catch {
+      unreadable += 1;
+      continue;
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+      unreadable += 1;
+      continue;
+    }
+    const record = parsed;
+    const serverName = typeof record.serverName === "string" ? record.serverName.trim() : "";
+    if (serverName === "") {
+      unreadable += 1;
+      continue;
+    }
+    const tools = Array.isArray(record.tools) ? record.tools : [];
+    const updatedAt = typeof record.updatedAt === "string" ? record.updatedAt : "";
+    const definitionBytes = wireShapeLength(tools);
+    const candidate = {
+      serverName,
+      toolCount: tools.length,
+      definitionBytes,
+      estimatedTokens: estimateTokensFromLength(definitionBytes),
+      updatedAt,
+      // `tools` is an unchecked cast off a JSON array, so every element is
+      // treated as untrusted here rather than trusted to match CachedTool.
+      toolNames: tools.map((t) => t?.name).filter((n) => typeof n === "string" && n !== "")
+    };
+    const existing = newest.get(serverName);
+    if (existing === void 0 || candidate.updatedAt > existing.updatedAt) newest.set(serverName, candidate);
+  }
+  const servers = [...newest.values()].sort(
+    (a, b) => b.definitionBytes - a.definitionBytes || a.serverName.localeCompare(b.serverName)
+  );
+  return { cacheFound: true, servers, unreadable };
+}
+
+// src/copilot_mcp_names.ts
+var _cached = null;
+function copilotMcpToolNameMap() {
+  if (_cached) return _cached;
+  const map = /* @__PURE__ */ new Map();
+  try {
+    for (const server of readCopilotMcpTools().servers) {
+      for (const toolName of server.toolNames) {
+        map.set(`${server.serverName}-${toolName}`, `mcp__${server.serverName}__${toolName}`);
+      }
+    }
+  } catch {
+  }
+  _cached = map;
+  return map;
+}
+function canonicalizeCopilotMcpToolName(toolName) {
+  return copilotMcpToolNameMap().get(toolName) ?? toolName;
+}
+
 // src/hooks_cli.ts
 var _LOG = {
   warn: (msg, ...args) => console.warn(`[hooks_cli] ${msg}`, ...args),
@@ -150,6 +235,12 @@ function normalizePayload(payload, harness = "claude") {
     result2["_tg_harness"] = harness;
     return result2;
   }
+  if (harness === "copilot_cli") {
+    const result2 = { ...obj };
+    result2["tool_name"] = canonicalizeCopilotMcpToolName(toolName);
+    result2["_tg_harness"] = harness;
+    return result2;
+  }
   if (harness === "kimi") {
     const result2 = remapToolName(obj, toolName, KIMI_TOOL_NAME_MAP, KIMI_INPUT_KEY_MAP);
     result2["_tg_harness"] = harness;
@@ -373,11 +464,11 @@ function gitStateFingerprintSync(cwd) {
   }
 }
 var DIR_FINGERPRINT_LISTING_CAP_ENTRIES = 1e4;
-function dirStateFingerprintSync(path) {
+function dirStateFingerprintSync(path2) {
   try {
-    const stat = statSync(path);
+    const stat = statSync(path2);
     if (!stat.isDirectory()) return null;
-    const entries = readdirSync(path);
+    const entries = readdirSync(path2);
     if (entries.length <= DIR_FINGERPRINT_LISTING_CAP_ENTRIES) {
       return shortFingerprint(entries.slice().sort().join("\0"));
     }
@@ -387,12 +478,12 @@ function dirStateFingerprintSync(path) {
   }
 }
 var FILE_FINGERPRINT_CONTENT_CAP_BYTES = 2 * 1024 * 1024;
-function fileStateFingerprintSync(path) {
+function fileStateFingerprintSync(path2) {
   try {
-    const stat = statSync(path);
+    const stat = statSync(path2);
     if (!stat.isFile()) return null;
     if (stat.size <= FILE_FINGERPRINT_CONTENT_CAP_BYTES) {
-      return shortFingerprint(readFileSync(path));
+      return shortFingerprint(readFileSync(path2));
     }
     return shortFingerprint(`${stat.mtimeMs}\0${stat.size}`);
   } catch {
@@ -715,9 +806,11 @@ var HOOK_EVENTS = [
   "notification",
   "stop",
   "pre_compact",
+  "post_compact",
   "user_prompt_submit",
   "subagent_stop",
-  "session_start"
+  "session_start",
+  "post_tool_use_failure"
 ];
 
 // src/cli_commands.ts
@@ -855,10 +948,10 @@ function readStdinJson(timeoutMs = DEFAULT_STDIN_TIMEOUT_MS, maxBytes = MAX_STDI
 }
 
 // src/symbol_body_probe.ts
-import * as fs from "fs";
+import * as fs2 from "fs";
 var OVERSIZED_BODY_PROBE_SQL = `SELECT 1 FROM symbols WHERE LENGTH(body) > ${SYMBOL_BODY_CHAR_CAP} LIMIT 1`;
 function checkSymbolBodySize(dbPath) {
-  if (!fs.existsSync(dbPath)) {
+  if (!fs2.existsSync(dbPath)) {
     return { name: "Symbol body size", status: "ok", message: "no database yet" };
   }
   try {
@@ -881,7 +974,210 @@ function checkSymbolBodySize(dbPath) {
   }
 }
 
+// src/resident_context.ts
+import * as fs3 from "node:fs";
+var LARGE_TASK_LIST_BYTES = 2e4;
+var LARGE_SKILL_BODY_BYTES = 2e4;
+var SKILL_BODY_REPEAT_THRESHOLD = 2;
+var RESIDENT_TAIL_MAX_BYTES = 1048576;
+function createResidentContextStats() {
+  return {
+    attachmentsByType: /* @__PURE__ */ new Map(),
+    latestTaskList: null,
+    taskReminderCount: 0,
+    taskReminderBytes: 0,
+    skillBodies: /* @__PURE__ */ new Map(),
+    compactionCount: 0
+  };
+}
+function bump(map, key, bytes) {
+  const entry = map.get(key);
+  if (entry === void 0) map.set(key, { count: 1, bytes });
+  else {
+    entry.count += 1;
+    entry.bytes += bytes;
+  }
+}
+function messageText(message) {
+  if (message === null || typeof message !== "object") return "";
+  const content = message["content"];
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  let out = "";
+  for (const block of content) {
+    if (block === null || typeof block !== "object") continue;
+    const text = block["text"];
+    if (typeof text === "string") out += text;
+  }
+  return out;
+}
+function skillNameFromBody(text) {
+  const dir = /^Base directory for this skill:\s*(.+?)\s*$/m.exec(text);
+  if (dir?.[1] !== void 0) {
+    const segments = dir[1].split(/[\\/]/).filter((s) => s.length > 0);
+    const last = segments[segments.length - 1];
+    if (last !== void 0 && last.length > 0) return last;
+  }
+  const heading = /^#\s+(.+?)\s*$/m.exec(text);
+  if (heading?.[1] !== void 0 && heading[1].length > 0) return heading[1];
+  return null;
+}
+function readTaskList(attachment, bytes) {
+  const snapshot = {
+    bytes,
+    itemCount: typeof attachment["itemCount"] === "number" ? attachment["itemCount"] : 0,
+    completed: 0,
+    inProgress: 0,
+    pending: 0,
+    descriptionBytes: 0,
+    completedDescriptionBytes: 0
+  };
+  const content = attachment["content"];
+  if (!Array.isArray(content)) return snapshot;
+  if (content.length > snapshot.itemCount) snapshot.itemCount = content.length;
+  for (const item of content) {
+    if (item === null || typeof item !== "object") continue;
+    const record = item;
+    const status = typeof record["status"] === "string" ? record["status"] : "";
+    const description = typeof record["description"] === "string" ? record["description"] : "";
+    snapshot.descriptionBytes += description.length;
+    if (status === "completed") {
+      snapshot.completed += 1;
+      snapshot.completedDescriptionBytes += description.length;
+    } else if (status === "in_progress") snapshot.inProgress += 1;
+    else if (status === "pending") snapshot.pending += 1;
+  }
+  return snapshot;
+}
+function collectInvokedSkills(acc, record) {
+  const skills = record["skills"];
+  if (!Array.isArray(skills)) return;
+  for (const entry of skills) {
+    if (entry === null || typeof entry !== "object") continue;
+    const skill = entry;
+    const content = skill["content"];
+    if (typeof content !== "string" || content.length < LARGE_SKILL_BODY_BYTES) continue;
+    const name = skillName(skill);
+    if (name !== null) bump(acc.skillBodies, name, content.length);
+  }
+}
+function skillName(skill) {
+  const name = skill["name"];
+  if (typeof name === "string" && name.trim() !== "") return name.trim();
+  const path2 = skill["path"];
+  if (typeof path2 !== "string") return null;
+  const segments = path2.split(/[\\/]/).filter((part) => part !== "");
+  const last = segments[segments.length - 1];
+  return last === void 0 || last === "" ? null : last;
+}
+function accumulateResidentLine(acc, parsed, bytes) {
+  try {
+    if (parsed === null || typeof parsed !== "object") return;
+    const line = parsed;
+    if (line["type"] === "system" && line["subtype"] === "compact_boundary") acc.compactionCount += 1;
+    const attachment = line["attachment"];
+    if (attachment !== null && typeof attachment === "object") {
+      const record = attachment;
+      const type = typeof record["type"] === "string" ? record["type"] : "unknown";
+      bump(acc.attachmentsByType, type, bytes);
+      if (type === "task_reminder") {
+        acc.taskReminderCount += 1;
+        acc.taskReminderBytes += bytes;
+        acc.latestTaskList = readTaskList(record, bytes);
+      }
+      if (type === "invoked_skills") collectInvokedSkills(acc, record);
+    }
+    if (line["isMeta"] === true && line["type"] === "user") {
+      const text = messageText(line["message"]);
+      if (text.length >= LARGE_SKILL_BODY_BYTES) {
+        const skill = skillNameFromBody(text);
+        if (skill !== null) bump(acc.skillBodies, skill, text.length);
+      }
+    }
+  } catch {
+  }
+}
+function summarizeResidentContext(acc) {
+  const attachmentClasses = [...acc.attachmentsByType.entries()].map(([type, v]) => ({ type, count: v.count, bytes: v.bytes })).sort((a, b) => b.bytes - a.bytes || a.type.localeCompare(b.type));
+  const repeatedSkillBodies = [...acc.skillBodies.entries()].filter(([, v]) => v.count >= SKILL_BODY_REPEAT_THRESHOLD).map(([skill, v]) => ({ skill, count: v.count, bytes: v.bytes })).sort((a, b) => b.bytes - a.bytes || a.skill.localeCompare(b.skill));
+  return {
+    attachmentClasses,
+    totalAttachmentBytes: attachmentClasses.reduce((n, c) => n + c.bytes, 0),
+    latestTaskList: acc.latestTaskList,
+    taskReminderCount: acc.taskReminderCount,
+    taskReminderBytes: acc.taskReminderBytes,
+    repeatedSkillBodies,
+    compactionCount: acc.compactionCount
+  };
+}
+function formatBytes(bytes) {
+  if (bytes >= 1e6) return `${(bytes / 1048576).toFixed(1)} MB`;
+  if (bytes >= 1e3) return `${Math.round(bytes / 1024)} KB`;
+  return `${bytes} B`;
+}
+function formatTokenEstimate(tokens) {
+  return tokens >= 1e3 ? `${Math.round(tokens / 1e3)}K` : String(tokens);
+}
+function taskListPruneHint(snapshot) {
+  if (snapshot === null) return null;
+  if (snapshot.bytes < LARGE_TASK_LIST_BYTES) return null;
+  if (snapshot.completed === 0) return null;
+  const tokens = formatTokenEstimate(estimateTokensFromLength(snapshot.bytes));
+  const prunable = formatBytes(snapshot.completedDescriptionBytes);
+  return `Your task list is ${formatBytes(snapshot.bytes)} (~${tokens} tok est) and is re-injected in full whenever it changes; ${snapshot.completed} of ${snapshot.itemCount} items are already completed and their descriptions alone are ${prunable}. Prune completed items or shorten their descriptions with TaskUpdate. Check ownership first if other agents share this list.`;
+}
+function repeatedSkillBodyHint(injections) {
+  const worst = injections[0];
+  if (worst === void 0) return null;
+  if (worst.count < SKILL_BODY_REPEAT_THRESHOLD || worst.bytes < LARGE_SKILL_BODY_BYTES) return null;
+  const tokens = formatTokenEstimate(estimateTokensFromLength(worst.bytes));
+  return `The \`${worst.skill}\` skill body has been injected ${worst.count} times this session (${formatBytes(worst.bytes)} total, ~${tokens} tok est). Slash expansion and the Skill tool both send the whole body every time, and no hook can intercept either. If it is already loaded, work from it instead of re-invoking; to reread one part, use \`token-goat skill-section ${worst.skill} '<heading>'\`.`;
+}
+function readTranscriptTail(transcriptPath, maxBytes = RESIDENT_TAIL_MAX_BYTES) {
+  let fd = null;
+  try {
+    const stat = fs3.statSync(transcriptPath);
+    if (!stat.isFile() || stat.size === 0) return [];
+    const start = Math.max(0, stat.size - maxBytes);
+    const length = stat.size - start;
+    fd = fs3.openSync(transcriptPath, "r");
+    const buf = Buffer.allocUnsafe(length);
+    const read = fs3.readSync(fd, buf, 0, length, start);
+    const lines = buf.subarray(0, read).toString("utf8").split("\n");
+    if (start > 0) lines.shift();
+    return lines;
+  } catch {
+    return [];
+  } finally {
+    if (fd !== null) {
+      try {
+        fs3.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+function lineMayCarryResidentSignal(line) {
+  return line.includes('"task_reminder"') || line.includes('"compact_boundary"') || line.includes('"invoked_skills"') || line.includes('"isMeta"');
+}
+function accumulateResidentLines(lines) {
+  const acc = createResidentContextStats();
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    accumulateResidentLine(acc, parsed, trimmed.length);
+  }
+  return acc;
+}
+
 export {
+  readCopilotMcpTools,
   GEMINI_TOOL_NAME_MAP,
   normalizePayload,
   isRecallCacheType,
@@ -907,6 +1203,16 @@ export {
   filterCommandManifest,
   formatCommandManifest,
   checkSymbolBodySize,
+  createResidentContextStats,
+  accumulateResidentLine,
+  summarizeResidentContext,
+  formatBytes,
+  formatTokenEstimate,
+  taskListPruneHint,
+  repeatedSkillBodyHint,
+  readTranscriptTail,
+  lineMayCarryResidentSignal,
+  accumulateResidentLines,
   MAX_STDIN_BYTES,
   readStdinJson
 };

package/dist/{token-goat-chunk-LN6OUHTV.mjs → token-goat-chunk-Y2SYNH3S.mjs}

@@ -7,11 +7,11 @@ import {
   expandGlobs,
   leftoverIntegrations,
   run
-} from "./token-goat-chunk-KYFJC37X.mjs";
-import "./token-goat-chunk-IYTVE6KN.mjs";
-import "./token-goat-chunk-VYMGEVZS.mjs";
-import "./token-goat-chunk-UFOVM7ZN.mjs";
-import "./token-goat-chunk-V465YKOR.mjs";
+} from "./token-goat-chunk-VBXBLGTO.mjs";
+import "./token-goat-chunk-RMDQFTQD.mjs";
+import "./token-goat-chunk-XEDQH5DA.mjs";
+import "./token-goat-chunk-2G6RAB4G.mjs";
+import "./token-goat-chunk-ELDJRLHZ.mjs";
 import "./token-goat-chunk-AO2QD2AG.mjs";
 import "./token-goat-chunk-AEX54RUZ.mjs";
 export {

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

@@ -0,0 +1,23 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  buildEvent,
+  relay,
+  relayInProcess
+} from "./token-goat-chunk-AOBZUFNJ.mjs";
+import {
+  MAX_STDIN_BYTES,
+  readStdinJson
+} from "./token-goat-chunk-XEDQH5DA.mjs";
+import "./token-goat-chunk-2G6RAB4G.mjs";
+import "./token-goat-chunk-7JDXDERZ.mjs";
+import "./token-goat-chunk-ELDJRLHZ.mjs";
+import "./token-goat-chunk-AO2QD2AG.mjs";
+import "./token-goat-chunk-AEX54RUZ.mjs";
+export {
+  MAX_STDIN_BYTES,
+  buildEvent,
+  readStdinJson,
+  relay,
+  relayInProcess
+};

package/dist/token-goat-hook.mjs

@@ -2,13 +2,13 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   relayInProcess
-} from "./token-goat-hook-chunk-BDR6C6IE.mjs";
-import "./token-goat-hook-chunk-3ZDBWJDF.mjs";
-import "./token-goat-hook-chunk-5UH54CW6.mjs";
-import "./token-goat-hook-chunk-A77A26A7.mjs";
-import "./token-goat-hook-chunk-Y2WHX2P3.mjs";
-import "./token-goat-hook-chunk-BUOCULAM.mjs";
-import "./token-goat-hook-chunk-RFRLWOQH.mjs";
+} from "./token-goat-chunk-AOBZUFNJ.mjs";
+import "./token-goat-chunk-XEDQH5DA.mjs";
+import "./token-goat-chunk-2G6RAB4G.mjs";
+import "./token-goat-chunk-7JDXDERZ.mjs";
+import "./token-goat-chunk-ELDJRLHZ.mjs";
+import "./token-goat-chunk-AO2QD2AG.mjs";
+import "./token-goat-chunk-AEX54RUZ.mjs";
 export {
   relayInProcess
 };

package/dist/token-goat.core.mjs

@@ -2,13 +2,13 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   run
-} from "./token-goat-chunk-KYFJC37X.mjs";
-import "./token-goat-chunk-IYTVE6KN.mjs";
-import "./token-goat-chunk-VYMGEVZS.mjs";
-import "./token-goat-chunk-UFOVM7ZN.mjs";
+} from "./token-goat-chunk-VBXBLGTO.mjs";
+import "./token-goat-chunk-RMDQFTQD.mjs";
+import "./token-goat-chunk-XEDQH5DA.mjs";
+import "./token-goat-chunk-2G6RAB4G.mjs";
 import {
   installEpipeGuard
-} from "./token-goat-chunk-V465YKOR.mjs";
+} from "./token-goat-chunk-ELDJRLHZ.mjs";
 import "./token-goat-chunk-AO2QD2AG.mjs";
 import "./token-goat-chunk-AEX54RUZ.mjs";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "token-goat",
-  "version": "2.6.36",
+  "version": "2.8.1",
   "description": "Surgical token-reduction companion for Claude Code and other AI coding agents",
   "type": "module",
   "main": "./dist/token-goat.mjs",
@@ -30,7 +30,9 @@
     "typecheck:vscode-extension": "npm --prefix vscode-extension run compile",
     "typecheck:vscode-extension:tests": "npm --prefix vscode-extension run typecheck:tests",
     "dev": "tsx src/main.ts",
-    "prepare": "node scripts/install-git-hooks.mjs"
+    "prepare": "node scripts/install-git-hooks.mjs",
+    "schema:copilot": "node scripts/extract_harness_schema.mjs auto --harness copilot_cli --out schemas/copilot_cli.hooks.json",
+    "schema:copilot:check": "node scripts/extract_harness_schema.mjs auto --harness copilot_cli --out schemas/copilot_cli.hooks.json --check"
   },
   "contributors": [
     {
@@ -56,24 +58,28 @@
   ],
   "license": "PolyForm-Noncommercial-1.0.0",
   "engines": {
-    "node": ">=22.0.0"
+    "node": ">=22.16.0"
   },
   "dependencies": {
-    "better-sqlite3": "^12.11.1",
     "jsonc-parser": "^3.3.1"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "@types/better-sqlite3": "^9.6.0",
     "@types/node": "^26.2.0",
+    "@xenova/transformers": "^2.17.2",
+    "better-sqlite3": "^12.11.1",
     "commander": "^15.0.0",
     "csv-parse": "^7.0.2",
     "esbuild": "^0.28.2",
     "eslint": "^10.8.1",
     "exceljs": "^4.4.0",
+    "fast-xml-parser": "^5.9.3",
     "html-to-text": "^10.0.1",
     "js-yaml": "^5.2.1",
     "lefthook": "^2.1.10",
+    "onnxruntime-node": "^1.27.0",
     "smol-toml": "^1.8.0",
     "tsx": "^4.23.12",
     "typescript": "^6.0.3",
@@ -82,9 +88,6 @@
     "zod": "^4.4.3"
   },
   "optionalDependencies": {
-    "@modelcontextprotocol/sdk": "^1.30.0",
-    "@xenova/transformers": "^2.17.2",
-    "fast-xml-parser": "^5.9.3",
     "fflate": "^0.8.3",
     "pdfjs-dist": "^6.1.200",
     "puppeteer-core": "^25.8.0",
@@ -108,6 +111,7 @@
     "deepmerge-ts": "^8.0.1",
     "uuid": "^14.0.1",
     "sharp": "^0.35.3",
-    "unzipper": "^0.12.5"
+    "unzipper": "^0.12.5",
+    "adm-zip": "^0.6.0"
   }
 }