token-goat 2.6.35 → 2.8.0

package/dist/{token-goat-chunk-UIZVX3HN.mjs → token-goat-chunk-4KZILRZN.mjs}

@@ -10,11 +10,11 @@ import {
   selectFilter,
   shlexSplit,
   wrappedShell
-} from "./token-goat-chunk-DQIT5JIF.mjs";
+} from "./token-goat-chunk-TUPJRK7R.mjs";
 import {
   loadConfig,
   recordStat
-} from "./token-goat-chunk-K7W3P2TJ.mjs";
+} from "./token-goat-chunk-44Y77VHR.mjs";
 import "./token-goat-chunk-AO2QD2AG.mjs";
 import "./token-goat-chunk-AEX54RUZ.mjs";
 

package/dist/token-goat-chunk-5CVKO3DA.mjs

@@ -0,0 +1,185 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  external_exports
+} from "./token-goat-chunk-WN5T5EW5.mjs";
+import "./token-goat-chunk-AEX54RUZ.mjs";
+
+// src/mcp_jsonrpc.ts
+var LATEST_PROTOCOL_VERSION = "2025-11-25";
+var SUPPORTED_PROTOCOL_VERSIONS = [
+  LATEST_PROTOCOL_VERSION,
+  "2025-06-18",
+  "2025-03-26",
+  "2024-11-05",
+  "2024-10-07"
+];
+var JSONRPC_INVALID_REQUEST = -32600;
+var JSONRPC_METHOD_NOT_FOUND = -32601;
+var JSONRPC_INVALID_PARAMS = -32602;
+var DRAFT_07_SCHEMA_ID = "http://json-schema.org/draft-07/schema#";
+var MCP_INVALID_PARAMS_PREFIX = `MCP error ${JSONRPC_INVALID_PARAMS}: `;
+var EMPTY_OBJECT_JSON_SCHEMA = { type: "object", properties: {} };
+function buildJsonSchema(shape) {
+  if (shape === void 0 || Object.keys(shape).length === 0) return { ...EMPTY_OBJECT_JSON_SCHEMA };
+  const schema = external_exports.toJSONSchema(external_exports.object(shape), { io: "input" });
+  return { ...schema, $schema: DRAFT_07_SCHEMA_ID };
+}
+function describeParseError(error) {
+  return error.issues.map((issue) => {
+    if (issue.path.length === 0) return issue.message;
+    const dotted = issue.path.reduce(
+      (acc, seg, i) => i === 0 ? String(seg) : typeof seg === "number" ? `${acc}[${seg}]` : `${acc}.${String(seg)}`,
+      ""
+    );
+    return `${issue.message} at ${dotted}`;
+  }).join("\n");
+}
+function errorText(message) {
+  return { content: [{ type: "text", text: message }], isError: true };
+}
+function isRequest(message) {
+  return "method" in message && "id" in message && message.id !== void 0 && message.id !== null;
+}
+var McpServer = class {
+  info;
+  tools = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  transport;
+  /** Set by the caller to learn when the peer hung up; `mcp-serve` waits on exactly this. */
+  onclose;
+  constructor(info) {
+    this.info = info;
+  }
+  /**
+   * Registers a tool. Schema generation happens here rather than at `tools/list` time, which also
+   * means a malformed shape fails loudly at startup instead of on a client's first listing.
+   */
+  registerTool(name, definition, handler) {
+    if (this.tools.has(name)) throw new Error(`MCP tool registered twice: ${name}`);
+    const shape = definition.inputSchema;
+    this.tools.set(name, {
+      name,
+      description: definition.description,
+      jsonSchema: buildJsonSchema(shape),
+      // An absent shape still needs a validator, so an argumentless tool called with arguments is
+      // not silently handed them.
+      validator: external_exports.object(shape ?? {})
+    });
+    this.handlers.set(name, handler);
+  }
+  /**
+   * Wires this server to a transport and starts it.
+   *
+   * `onmessage` is assigned before `start()` on purpose: a transport may have buffered messages
+   * that arrive the moment it starts (the SDK's in-memory transport queues anything sent before a
+   * handler exists and drains the queue inside `start()`), so a server that started first would
+   * drop the client's `initialize`.
+   */
+  async connect(transport) {
+    this.transport = transport;
+    transport.onmessage = (message) => {
+      void this.handleMessage(message);
+    };
+    transport.onclose = () => {
+      this.transport = void 0;
+      this.onclose?.();
+    };
+    await transport.start();
+  }
+  async close() {
+    const transport = this.transport;
+    this.transport = void 0;
+    await transport?.close();
+  }
+  async send(message) {
+    try {
+      await this.transport?.send(message);
+    } catch {
+    }
+  }
+  async handleMessage(message) {
+    if (!isRequest(message)) return;
+    const { id, method } = message;
+    const params = message.params ?? {};
+    try {
+      switch (method) {
+        case "initialize":
+          await this.send({ jsonrpc: "2.0", id, result: this.initializeResult(params) });
+          return;
+        case "ping":
+          await this.send({ jsonrpc: "2.0", id, result: {} });
+          return;
+        case "tools/list":
+          await this.send({ jsonrpc: "2.0", id, result: { tools: this.listTools() } });
+          return;
+        case "tools/call":
+          await this.send({ jsonrpc: "2.0", id, result: await this.callTool(params) });
+          return;
+        default:
+          await this.sendError(id, JSONRPC_METHOD_NOT_FOUND, `Method not found: ${method}`);
+          return;
+      }
+    } catch (err) {
+      await this.sendError(id, JSONRPC_INVALID_REQUEST, err instanceof Error ? err.message : String(err));
+    }
+  }
+  async sendError(id, code, message) {
+    await this.send({ jsonrpc: "2.0", id, error: { code, message } });
+  }
+  initializeResult(params) {
+    const requested = params["protocolVersion"];
+    const protocolVersion = typeof requested === "string" && SUPPORTED_PROTOCOL_VERSIONS.includes(requested) ? requested : LATEST_PROTOCOL_VERSION;
+    return {
+      protocolVersion,
+      // Tools only, and they never change after startup, so no `listChanged`. This is the one
+      // place we deliberately do not copy the SDK, which declares `listChanged: true` because its
+      // McpServer is *able* to send that notification. Token-goat registers every tool before it
+      // connects and never adds or removes one, so we would be promising a notification we can
+      // never have cause to send. No client behaviour turns on it either way -- a subscription
+      // that never fires and an absent subscription are the same thing when the list is fixed --
+      // so the honest declaration wins. Contrast the tool-error text below, which a model reads as
+      // content and is therefore matched to the SDK exactly.
+      capabilities: { tools: {} },
+      serverInfo: { name: this.info.name, version: this.info.version }
+    };
+  }
+  listTools() {
+    return [...this.tools.values()].map((tool) => ({
+      name: tool.name,
+      ...tool.description !== void 0 ? { description: tool.description } : {},
+      inputSchema: tool.jsonSchema,
+      // The SDK emits this for every tool it registers, and it is literally true of ours: we do
+      // not implement task augmentation, so a client that asks for it gets refused. Emitting the
+      // same thing keeps `tools/list` byte-identical to what token-goat sent before, which is what
+      // the differential test in tests/mcp_jsonrpc.test.ts pins.
+      execution: { taskSupport: "forbidden" }
+    }));
+  }
+  async callTool(params) {
+    const name = params["name"];
+    if (typeof name !== "string") return errorText('Invalid params: tools/call requires a string "name"');
+    const tool = this.tools.get(name);
+    const handler = this.handlers.get(name);
+    if (tool === void 0 || handler === void 0) return errorText(`${MCP_INVALID_PARAMS_PREFIX}Tool ${name} not found`);
+    const parsed = tool.validator.safeParse(params["arguments"] ?? {});
+    if (!parsed.success) {
+      return errorText(
+        `${MCP_INVALID_PARAMS_PREFIX}Input validation error: Invalid arguments for tool ${name}: ${describeParseError(parsed.error)}`
+      );
+    }
+    try {
+      return await handler(parsed.data);
+    } catch (err) {
+      return errorText(err instanceof Error ? err.message : String(err));
+    }
+  }
+};
+export {
+  JSONRPC_INVALID_PARAMS,
+  JSONRPC_INVALID_REQUEST,
+  JSONRPC_METHOD_NOT_FOUND,
+  LATEST_PROTOCOL_VERSION,
+  McpServer,
+  SUPPORTED_PROTOCOL_VERSIONS
+};

package/dist/token-goat-chunk-A62K4XW2.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-LVCBDJVE.mjs";
+import {
+  MAX_STDIN_BYTES,
+  readStdinJson
+} from "./token-goat-chunk-AO6MFFTW.mjs";
+import "./token-goat-chunk-2F6TFBZE.mjs";
+import "./token-goat-chunk-TUPJRK7R.mjs";
+import "./token-goat-chunk-44Y77VHR.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-chunk-SIHYQCTM.mjs → token-goat-chunk-AO6MFFTW.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-I2KCEGIP.mjs";
+} from "./token-goat-chunk-2F6TFBZE.mjs";
 import {
   SYMBOL_BODY_CHAR_CAP,
   extractErrorMessage,
@@ -16,11 +18,94 @@ import {
   redactSecrets,
   runGit,
   shortFingerprint
-} from "./token-goat-chunk-K7W3P2TJ.mjs";
+} from "./token-goat-chunk-44Y77VHR.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
@@ -790,6 +883,7 @@ function formatCommandManifest(manifest) {
 
 // src/stdin_json.ts
 var DEFAULT_STDIN_TIMEOUT_MS = 5e3;
+var MAX_STDIN_WALL_MS = 6e4;
 var MAX_STDIN_BYTES = 64 * 1024 * 1024;
 function readStdinJson(timeoutMs = DEFAULT_STDIN_TIMEOUT_MS, maxBytes = MAX_STDIN_BYTES) {
   return new Promise((resolve2, reject) => {
@@ -799,16 +893,27 @@ function readStdinJson(timeoutMs = DEFAULT_STDIN_TIMEOUT_MS, maxBytes = MAX_STDI
     const finish = (fn) => {
       if (settled) return;
       settled = true;
-      clearTimeout(timer);
+      clearTimeout(idleTimer);
+      clearTimeout(wallTimer);
       process.stdin.removeListener("data", onData);
       process.stdin.removeListener("end", onEnd);
       process.stdin.removeListener("error", onError);
       fn();
     };
-    const timer = setTimeout(() => {
+    let idleTimer = setTimeout(() => {
       finish(() => reject(new Error("readStdinJson: timed out waiting for stdin")));
     }, timeoutMs);
+    const wallTimer = setTimeout(() => {
+      finish(() => {
+        process.stdin.destroy();
+        reject(new Error(`readStdinJson: stdin took longer than ${MAX_STDIN_WALL_MS} ms`));
+      });
+    }, MAX_STDIN_WALL_MS);
     const onData = (chunk) => {
+      clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => {
+        finish(() => reject(new Error("readStdinJson: timed out waiting for stdin")));
+      }, timeoutMs);
       totalBytes += chunk.length;
       if (totalBytes > maxBytes) {
         finish(() => {
@@ -843,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 {
@@ -869,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,
@@ -895,6 +1203,16 @@ export {
   filterCommandManifest,
   formatCommandManifest,
   checkSymbolBodySize,
+  createResidentContextStats,
+  accumulateResidentLine,
+  summarizeResidentContext,
+  formatBytes,
+  formatTokenEstimate,
+  taskListPruneHint,
+  repeatedSkillBodyHint,
+  readTranscriptTail,
+  lineMayCarryResidentSignal,
+  accumulateResidentLines,
   MAX_STDIN_BYTES,
   readStdinJson
 };