token-goat 2.9.19 → 2.9.21

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

@@ -0,0 +1,1379 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  estimateTokensFromLength
+} from "./token-goat-chunk-MEKVJZUN.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-M6CDVASA.mjs";
+import {
+  atomicWriteText,
+  backupFile,
+  ensureDirSync,
+  hookCommandFor,
+  hookPowershellCommand,
+  projectScopeRoot,
+  recordCreatedConfig,
+  removeCreatedBackups,
+  removeFileInScope,
+  stripDelimitedBlock,
+  takeCreatedConfig,
+  upsertDelimitedBlock,
+  withInstallScope,
+  writeIfDifferent
+} from "./token-goat-chunk-TGBSMHPM.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/bridges/visualstudio_install.ts
+init_define_import_meta_env();
+import * as fs2 from "node:fs";
+import * as os from "node:os";
+import * as path2 from "node:path";
+
+// src/bridges/guidance_block.ts
+init_define_import_meta_env();
+function buildGuidanceBody(fallbackToolClause, opts = {}) {
+  const gdrive = opts.gdrive !== false;
+  return [
+    "## token-goat",
+    "",
+    "**Gate \u2014 before every file read, answer one question first: is there a token-goat command that returns just what I need?** If yes, run it. A read tool invoked without answering the gate is a violation, not an oversight. The gate is per file: batched or parallel reads do not exempt it.",
+    "",
+    `This gate decides *whether* to reach for a read tool at all. ${fallbackToolClause} only pick the *fallback* once token-goat has been ruled out for this read \u2014 they never authorize skipping the gate.`,
+    "",
+    "Fallback clauses may name your harness's own native read, search, and edit tools, or its shell helpers. Shell binaries and editor programs are commands invoked through the shell tool, never tool identifiers, and must never appear in an agent's tools frontmatter or an allowed-tools list. This paragraph deliberately names no specific tool or binary: instruction-file loaders harvest such names into a tool allowlist and then warn that every one of them is unknown.",
+    "",
+    "Exemptions (gate passes, read directly): the file is under ~200 lines and you need all of it; it was never indexed (new, untracked, or generated this turn); it is a genuinely opaque binary (not an image); the target has no symbol handle (e.g. a literal mid-function).",
+    "",
+    "Failure shapes to catch yourself in, and the command that replaces each:",
+    '- 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"`',
+    '- 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`",
+    '- searching for a *concept* rather than a literal string \u2192 `semantic "description"`',
+    "- re-reading output you already captured \u2192 `bash-output`/`web-output`/`mcp-output` by ID",
+    "- a directory listing or recursive wildcard walk to orient in an unfamiliar repo \u2192 `map --compact`",
+    "- pulling one value or subtree out of a JSON/YAML/XML file (manifest, lockfile, spec, config) \u2192 `json-query file 'a.b.c'` / `yaml-query file 'a.b.c'` / `xml-query file 'a.b.c'`",
+    "- opening an image to check its dimensions, format, or size \u2192 `image-meta file`",
+    "- opening a screenshot, diagram, or scan to read the text in it \u2192 `image-text file`",
+    "- opening a PDF or Office document \u2192 inspect its format first, then read a narrow slice: PDF `pdf-meta`/`pdf-outline` then `pdf-locate` to find the pages and `pdf-extract` only those; Word `docx-outline` then `docx-tables`/`docx-text`; PowerPoint `pptx-outline` then `pptx-slide`/`pptx-notes`; Excel `xlsx-sheets` then `xlsx-columns`/`xlsx-head`/`xlsx-range`/`xlsx-query`",
+    "",
+    'Commands: `answer "<question>"`, `symbol NAME`, `read "file::symbol"`, `brief "file::symbol"`, `section "file::Heading"`, `semantic "description"`, `outline file`/`skeleton file`, `map --compact`, `refs file::symbol --callers`, `changed --symbol`, `config-get file KEY`, `json-query file \'a.b.c\'`/`yaml-query`/`xml-query`, `json-outline file`/`yaml-outline`/`xml-outline`, `bash-output`/`web-output`/`mcp-output`, ' + (gdrive ? "`gdrive-sections <file-id>`, " : "") + "`image-meta file`/`image-text file`, `pdf-meta`/`pdf-outline`/`pdf-locate`/`pdf-extract`, `docx-outline`/`docx-tables`/`docx-text`, `pptx-outline`/`pptx-slide`/`pptx-notes`/`pptx-text`, `xlsx-sheets`/`xlsx-columns`/`xlsx-head`/`xlsx-range`/`xlsx-query`.",
+    "",
+    "Sub-agent briefs must carry this gate verbatim: a sub-agent inherits none of this context and its reads spend the same token budget.",
+    "",
+    "`token-goat stats` \u2014 self-check. Flat counts during code work mean the gate is being skipped."
+  ].join("\n");
+}
+function skillDescriptionLine(gdrive) {
+  return `description: Use before reading whole files or grepping wide. token-goat commands (symbol, read, section, semantic, outline, skeleton, map, refs, changed, config-get, bash-output, web-output${gdrive ? ", gdrive-sections" : ""}) return narrow slices of code and docs at a fraction of the token cost.`;
+}
+function buildGuidanceBlock(h) {
+  return [h.beginMarker, buildGuidanceBody(h.fallbackToolClause, h.gdrive === void 0 ? {} : { gdrive: h.gdrive }), h.endMarker].join("\n");
+}
+
+// src/bridges/mcp_servers_json.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+var jsoncParser;
+function jsonc() {
+  jsoncParser ??= createRequire(import.meta.url)("jsonc-parser");
+  return jsoncParser;
+}
+function bundledCliPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const bundled = path.join(here, "token-goat.mjs");
+  if (fs.existsSync(bundled)) return bundled;
+  return path.resolve(here, "..", "..", "dist", "token-goat.mjs");
+}
+function managedServer() {
+  return {
+    type: "stdio",
+    command: process.execPath,
+    args: [bundledCliPath(), "mcp-serve"]
+  };
+}
+function isManagedServer(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const entry = value;
+  const args = entry["args"];
+  return entry["type"] === "stdio" && Array.isArray(args) && args.length === 2 && typeof args[0] === "string" && path.basename(args[0]).toLowerCase() === "token-goat.mjs" && args[1] === "mcp-serve";
+}
+function readServersJson(filePath, label) {
+  const text = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : "{}\n";
+  const errors = [];
+  const parsed = jsonc().parse(text, errors, { allowTrailingComma: true, disallowComments: false });
+  if (errors.length > 0) {
+    throw new Error(`malformed ${label} MCP JSON at ${filePath}`);
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`malformed ${label} MCP JSON at ${filePath}: expected a JSON object`);
+  }
+  return { text, value: parsed };
+}
+function serversOf(config, filePath, label, rootKey = "servers") {
+  const servers = config.value[rootKey];
+  if (servers === void 0) return {};
+  if (servers === null || typeof servers !== "object" || Array.isArray(servers)) {
+    throw new Error(`malformed ${label} MCP JSON at ${filePath}: ${rootKey} must be an object`);
+  }
+  return servers;
+}
+var FORMAT = { insertSpaces: true, tabSize: 2, eol: "\n" };
+function editAt(text, jsonPath, value) {
+  let out = text;
+  for (const e of [...jsonc().modify(text, jsonPath, value, {})].sort((a, b) => b.offset - a.offset)) {
+    out = out.slice(0, e.offset) + e.content + out.slice(e.offset + e.length);
+    if (e.content.length > 0) out = jsonc().applyEdits(out, jsonc().format(out, { offset: e.offset, length: e.content.length }, FORMAT));
+  }
+  return out;
+}
+function setTokenGoatServer(text, value, rootKey = "servers") {
+  if (value !== void 0 && /^\s*\{\s*\}\s*$/.test(text)) return `${JSON.stringify({ [rootKey]: { "token-goat": value } }, null, 2)}
+`;
+  return editAt(text, [rootKey, "token-goat"], value);
+}
+function holdsOnlyManagedServer(value) {
+  const keys = Object.keys(value);
+  if (keys.length !== 1) return false;
+  const root = keys[0];
+  if (root !== "servers" && root !== "mcpServers") return false;
+  const servers = value[root];
+  if (servers === null || typeof servers !== "object" || Array.isArray(servers)) return false;
+  const names = Object.keys(servers);
+  return names.length === 1 && names[0] === "token-goat" && isManagedServer(servers["token-goat"]);
+}
+function isResidueServersJson(text, rootKey = "servers") {
+  const trimmed = text.trim();
+  if (trimmed === "") return true;
+  const parsed = parseObject(trimmed);
+  if (parsed === null) return false;
+  const keys = Object.keys(parsed);
+  if (keys.length !== 1 || keys[0] !== rootKey) return false;
+  const servers = parsed[rootKey];
+  return servers !== null && typeof servers === "object" && !Array.isArray(servers) && Object.keys(servers).length === 0;
+}
+function dropEmptyServers(text, rootKey = "servers") {
+  const parsed = parseObject(text);
+  if (parsed === null) return text;
+  const servers = parsed[rootKey];
+  if (servers === null || typeof servers !== "object" || Array.isArray(servers) || Object.keys(servers).length > 0) return text;
+  return editAt(text, [rootKey], void 0);
+}
+function parseObject(text) {
+  const parsed = jsonc().parse(text, [], { allowTrailingComma: true, disallowComments: false });
+  return parsed === null || typeof parsed !== "object" || Array.isArray(parsed) ? null : parsed;
+}
+function ensureMcpServersKey(text) {
+  const parsed = parseObject(text);
+  if (parsed === null || "mcpServers" in parsed) return text;
+  return editAt(text, ["mcpServers"], {});
+}
+function dropLoneEmptyMcpServers(text) {
+  const parsed = parseObject(text);
+  if (parsed === null || Object.keys(parsed).length !== 1) return text;
+  const mcpServers = parsed["mcpServers"];
+  if (mcpServers === null || typeof mcpServers !== "object" || Array.isArray(mcpServers) || Object.keys(mcpServers).length > 0) return text;
+  return editAt(text, ["mcpServers"], void 0);
+}
+function hasManagedServer(filePath, label, rootKey = "servers", isManaged = isManagedServer) {
+  if (!fs.existsSync(filePath)) return false;
+  try {
+    const config = readServersJson(filePath, label);
+    return isManaged(serversOf(config, filePath, label, rootKey)["token-goat"]);
+  } catch {
+    return false;
+  }
+}
+
+// src/bridges/visualstudio_install.ts
+var LABEL = "Visual Studio";
+var VISUALSTUDIO_GUIDANCE_BEGIN = "<!-- token-goat-visualstudio-begin -->";
+var VISUALSTUDIO_GUIDANCE_END = "<!-- token-goat-visualstudio-end -->";
+var SIBLING_GATE_MARKERS = [
+  ["<!-- token-goat-vscode-begin -->", "<!-- token-goat-vscode-end -->"],
+  ["<!-- token-goat-begin -->", "<!-- token-goat-end -->"]
+];
+function visualStudioUserMcpPath() {
+  return path2.join(os.homedir(), ".mcp.json");
+}
+function visualStudioProjectMcpPath(projectRoot = process.cwd()) {
+  return path2.join(path2.resolve(projectRoot), ".mcp.json");
+}
+function visualStudioMcpPath(opts = {}) {
+  return opts.project === true ? visualStudioProjectMcpPath(opts.projectRoot) : visualStudioUserMcpPath();
+}
+function otherScopeMcpPath(opts) {
+  return opts.project === true ? visualStudioUserMcpPath() : visualStudioProjectMcpPath(opts.projectRoot);
+}
+function visualStudioInstructionsPath(opts = {}) {
+  return opts.project === true ? path2.join(path2.resolve(opts.projectRoot ?? process.cwd()), ".github", "copilot-instructions.md") : path2.join(os.homedir(), "copilot-instructions.md");
+}
+function visualStudioOtherScopeHasManagedServer(opts = {}) {
+  return hasManagedServer(otherScopeMcpPath(opts), LABEL);
+}
+function isVisualStudioInstalled(opts = {}) {
+  return hasManagedServer(visualStudioMcpPath(opts), LABEL);
+}
+function visualStudioSolutionVscodeMcpPath(projectRoot = process.cwd()) {
+  return path2.join(path2.resolve(projectRoot), ".vscode", "mcp.json");
+}
+function visualStudioManagedRegistrations(projectRoot = process.cwd()) {
+  return [visualStudioUserMcpPath(), visualStudioProjectMcpPath(projectRoot), visualStudioSolutionVscodeMcpPath(projectRoot)].filter((p) => hasManagedServer(p, LABEL));
+}
+function visualStudioDuplicateNote(projectRoot = process.cwd()) {
+  const found = visualStudioManagedRegistrations(projectRoot);
+  if (found.length < 2) return null;
+  const lead = `Note: Visual Studio reads ${found.join(" and ")}, and each registers token-goat, so it will list the token-goat server more than once for this solution.`;
+  if (!found.includes(visualStudioSolutionVscodeMcpPath(projectRoot))) return `${lead} Keep one: run "token-goat uninstall --visualstudio" or "token-goat uninstall --visualstudio -p".`;
+  return `${lead} Keep one: if you do not use VS Code in this folder, run "token-goat uninstall --vscode -p"; otherwise run "token-goat uninstall --visualstudio${found.includes(visualStudioUserMcpPath()) ? "" : " -p"}".`;
+}
+function visualStudioMcpStatus(opts = {}) {
+  const checkedPaths = [visualStudioUserMcpPath()];
+  if (opts.projectRoot !== void 0) checkedPaths.push(visualStudioProjectMcpPath(opts.projectRoot));
+  return { configured: checkedPaths.some((p) => hasManagedServer(p, LABEL)), checkedPaths };
+}
+function visualStudioManagedEntry(filePath) {
+  if (!fs2.existsSync(filePath)) return null;
+  try {
+    const entry = serversOf(readServersJson(filePath, LABEL), filePath, LABEL)["token-goat"];
+    if (!isManagedServer(entry)) return null;
+    const { command, args } = entry;
+    return { command: typeof command === "string" ? command : "", bundlePath: args[0] ?? "" };
+  } catch {
+    return null;
+  }
+}
+var FALLBACK_TOOL_CLAUSE = "Visual Studio\u2019s built-in readfile, code_search, and find_references tools";
+var RETRIEVE_NOTE = "**Compressed payloads:** a message containing a token-goat payload block (recognizable by a `recovery: token-goat retrieve <id>` line) is compressed text, not an answer. Call the MCP tool `retrieve_text` with that id to recover the original text, then answer the question the message asks using the recovered text. Never present the raw payload to the user as the response; if the `retrieve_text` tool is unavailable (the MCP server is not running, or its tools are not ticked in the chat Tools picker), say so plainly and ask the user to turn on the token-goat tools.";
+var SUPPORT_NOTE = "Visual Studio support: token-goat install --visualstudio registers a stdio MCP server under the servers root key of %USERPROFILE%\\.mcp.json (with --project, the .mcp.json in the solution folder). Visual Studio runs no token-goat hooks, so nothing denies a repeated read, adds a hint, shrinks an image, or folds what readfile returns there: the narrow reads come only from calling the token-goat MCP tools, or the token-goat CLI through runcommandinterminal.";
+function buildVisualStudioGuidanceBlock(sharesFileWithGate) {
+  const lead = sharesFileWithGate ? ["## token-goat in Visual Studio", "", `The token-goat gate elsewhere in this file applies in Visual Studio too; there, ${FALLBACK_TOOL_CLAUSE} are the fallback it names.`] : [buildGuidanceBody(FALLBACK_TOOL_CLAUSE, { gdrive: loadConfig().gdrive.enabled })];
+  return [VISUALSTUDIO_GUIDANCE_BEGIN, ...lead, "", RETRIEVE_NOTE, "", SUPPORT_NOTE, VISUALSTUDIO_GUIDANCE_END].join("\n");
+}
+function hasBlock(text, begin, end) {
+  const b = text.indexOf(begin);
+  const e = text.indexOf(end);
+  return b !== -1 && e > b;
+}
+function readText(filePath) {
+  try {
+    return fs2.readFileSync(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+function writeGuidance(filePath) {
+  const text = readText(filePath);
+  const shares = SIBLING_GATE_MARKERS.some(([begin, end]) => hasBlock(text, begin, end));
+  return upsertDelimitedBlock(filePath, VISUALSTUDIO_GUIDANCE_BEGIN, VISUALSTUDIO_GUIDANCE_END, buildVisualStudioGuidanceBlock(shares));
+}
+function syncVisualStudioProjectGuidance(filePath) {
+  if (!hasBlock(readText(filePath), VISUALSTUDIO_GUIDANCE_BEGIN, VISUALSTUDIO_GUIDANCE_END)) return false;
+  return writeGuidance(filePath);
+}
+function installVisualStudio(opts = {}) {
+  return withInstallScope(projectScopeRoot(opts), () => installVisualStudioScoped(opts));
+}
+function installVisualStudioScoped(opts) {
+  const scope = opts.project === true ? "project" : "user";
+  const mcpPath = visualStudioMcpPath(opts);
+  const instructionsPath = visualStudioInstructionsPath(opts);
+  if (visualStudioOtherScopeHasManagedServer(opts)) {
+    const otherScope = scope === "project" ? "user" : "project";
+    throw new Error(
+      `token-goat is already registered in Visual Studio ${otherScope} scope (${otherScopeMcpPath(opts)}). Visual Studio reads both files, so installing into ${scope} scope too would register it twice. Run "token-goat uninstall --visualstudio${otherScope === "project" ? " --project" : ""}" first if you want to move it, or drop --visualstudio from this run.`
+    );
+  }
+  const mcpExisted = fs2.existsSync(mcpPath);
+  const config = readServersJson(mcpPath, LABEL);
+  const ownedAlready = mcpExisted && holdsOnlyManagedServer(config.value);
+  const current = serversOf(config, mcpPath, LABEL)["token-goat"];
+  if (current !== void 0 && !isManagedServer(current)) {
+    throw new Error(`Visual Studio MCP JSON at ${mcpPath} already has a non-token-goat-managed server named "token-goat"`);
+  }
+  const next = ensureMcpServersKey(setTokenGoatServer(config.text, managedServer()));
+  if (config.text !== next) {
+    ensureDirSync(path2.dirname(mcpPath));
+    backupFile(mcpPath);
+    atomicWriteText(mcpPath, next);
+    if (!mcpExisted || ownedAlready) recordCreatedConfig(mcpPath);
+  }
+  const guidanceChanged = writeGuidance(instructionsPath);
+  return { mcpPath, instructionsPath, alreadyInstalled: config.text === next && !guidanceChanged, scope };
+}
+function uninstallVisualStudio(opts = {}) {
+  return withInstallScope(projectScopeRoot(opts), () => uninstallVisualStudioScoped(opts));
+}
+function uninstallVisualStudioScoped(opts) {
+  const mcpPath = visualStudioMcpPath(opts);
+  let removed = false;
+  if (fs2.existsSync(mcpPath)) {
+    const config = readServersJson(mcpPath, LABEL);
+    if (isManagedServer(serversOf(config, mcpPath, LABEL)["token-goat"])) {
+      const next = dropEmptyServers(setTokenGoatServer(config.text, void 0));
+      if (/^\s*\{\s*\}\s*$/.test(dropLoneEmptyMcpServers(next)) && takeCreatedConfig(mcpPath)) removeFileInScope(mcpPath);
+      else {
+        backupFile(mcpPath);
+        atomicWriteText(mcpPath, ensureMcpServersKey(next));
+      }
+      removeCreatedBackups(mcpPath);
+      removed = true;
+    }
+  }
+  const instructionsPath = visualStudioInstructionsPath(opts);
+  if (stripDelimitedBlock(instructionsPath, VISUALSTUDIO_GUIDANCE_BEGIN, VISUALSTUDIO_GUIDANCE_END)) {
+    removed = true;
+    if (readText(instructionsPath).trim() === "") removeFileInScope(instructionsPath);
+  }
+  return removed;
+}
+
+// src/bridges/copilot_cli_install.ts
+init_define_import_meta_env();
+import * as fs3 from "node:fs";
+import * as os2 from "node:os";
+import * as path3 from "node:path";
+
+// src/bridges/copilot_cli.ts
+init_define_import_meta_env();
+
+// src/copilot_tool_names.ts
+init_define_import_meta_env();
+var COPILOT_CLI_TOOL_NAME_MAP = {
+  bash: "Bash",
+  powershell: "Bash",
+  read_bash: "BashOutput",
+  read_powershell: "BashOutput",
+  view: "Read",
+  create: "Write",
+  edit: "Edit",
+  web_fetch: "WebFetch",
+  web_search: "WebSearch",
+  grep: "Grep",
+  glob: "Glob",
+  skill: "Skill",
+  exit_plan_mode: "ExitPlanMode"
+};
+
+// src/tool_name_fold.ts
+init_define_import_meta_env();
+function foldToolName(name) {
+  return typeof name === "string" ? name.toLowerCase().replace(/[_-]/g, "") : "";
+}
+
+// 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.
+const MATERIALIZED_SHRINK_MAX_AGE_MS = 60 * 60 * 1000
+let lastMaterializedShrinkSweepAtMs = 0
+function pruneMaterializedShrinks() {
+  const now = Date.now()
+  if (now - lastMaterializedShrinkSweepAtMs < MATERIALIZED_SHRINK_MAX_AGE_MS) return
+  lastMaterializedShrinkSweepAtMs = now
+  try {
+    const dir = os.tmpdir()
+    for (const file of fs.readdirSync(dir)) {
+      if (!file.startsWith("token-goat-shrink-")) continue
+      const full = path.join(dir, file)
+      try {
+        const st = fs.statSync(full)
+        if (st.isFile() && now - st.mtimeMs > MATERIALIZED_SHRINK_MAX_AGE_MS) fs.unlinkSync(full)
+      } catch {
+        // Best-effort per-file cleanup; one bad stat/unlink must not abort the sweep.
+      }
+    }
+  } catch {
+    // Best-effort; a readdir failure must never break the materialization below.
+  }
+}
+
+// Decode a token-goat image-shrink additionalContext payload ("<summary>\\ndata:image/<fmt>;base64,<data>") into a real file on disk, since the host's pre-tool hook has no context-injection channel to hand the shrunk image to the model directly -- only argument rewriting. The temp filename is derived from pid/time/random alone, never from the source image's own name, so an attacker-chosen filename cannot steer the write; the format suffix comes from the data-URL's media subtype, whose character class ([a-zA-Z0-9.+-]) admits no path separators. Returns undefined (leaving the original path argument untouched, so a failed shrink falls back to the original image) if the context isn't a shrink payload or anything goes wrong writing it.
+function materializeShrunkImage(context) {
+  if (typeof context !== "string") return undefined
+  const idx = context.indexOf("data:image/")
+  if (idx === -1) return undefined
+  const match = /^data:image\\/([a-zA-Z0-9.+-]+);base64,([A-Za-z0-9+/=]+)$/.exec(context.slice(idx).trim())
+  if (!match) return undefined
+  try {
+    pruneMaterializedShrinks()
+    const buf = Buffer.from(match[2], "base64")
+    const name = \`token-goat-shrink-\${process.pid}-\${Date.now()}-\${globalThis.crypto.randomUUID()}.\${match[1]}\`
+    const file = path.join(os.tmpdir(), name)
+    // Owner-only: the copy is of a workspace image and sits in the shared temp dir.
+    fs.writeFileSync(file, buf, { mode: 0o600 })
+    return file
+  } catch {
+    return undefined
+  }
+}`;
+
+// src/bridges/copilot_cli.ts
+var COPILOT_CLI_HOOK_SCRIPT = `#!/usr/bin/env node
+// token-goat Copilot CLI hook shim. Translates Copilot's hook event names and
+// request/response schema to/from token-goat's internal hook protocol.
+'use strict'
+const { spawnSync } = require('node:child_process')
+const fs = require('node:fs')
+const os = require('node:os')
+const path = require('node:path')
+const { pathToFileURL } = require('node:url')
+
+// Copilot event name -> token-goat internal HookEventName (src/types.ts's
+// HOOK_EVENTS). Only these eight have a token-goat handler; every other real
+// Copilot event (sessionEnd, subagentStart, errorOccurred, notification,
+// permissionRequest) is left unimplemented
+// rather than guessed at, and falls through to the default no-op below.
+// postToolUseFailure is the newest of the eight and the only one whose channel
+// costs tokens instead of saving them: it fires instead of postToolUse when a
+// tool result is a failure, and accepts only additionalContext back --
+// modifiedResult and suppressOutput are not honored there, so a failed result
+// still cannot be fenced, compressed or shrunk. It is wired anyway because
+// additionalContext demonstrably reaches the model (see the postToolUseFailure
+// branch in translate() for the bundle offset), and hooks_tool_failure.ts
+// spends that channel only on an exact repeat failure, where staying silent
+// costs a whole wasted retry.
+// 'sessionStart' was previously a permanent no-op on the stated grounds that
+// token-goat has no internal session_start handler. That was simply wrong --
+// hooks_session_start.ts has long emitted the command-routing reminder that
+// every other harness receives -- and the no-op was the reason Copilot CLI
+// sessions alone never got told token-goat exists. It is wired now: verified
+// against Copilot CLI 1.0.77 that a hooks.json sessionStart entry returning
+// {additionalContext} does reach the model. The github/copilot-cli#2142
+// fire-and-forget bug that would have made this dead wiring was fixed in a
+// pre-release months before that version, and its companion multi-extension
+// hook-overwrite bug never applied here: it hit runtime *extension* hooks,
+// while this config-file hooks.json path goes through Copilot's own merge.
+const COPILOT_TO_TG_EVENT = {
+  sessionStart: 'session_start',
+  preToolUse: 'pre_tool_use',
+  postToolUse: 'post_tool_use',
+  preCompact: 'pre_compact',
+  agentStop: 'stop',
+  subagentStop: 'subagent_stop',
+  userPromptSubmitted: 'user_prompt_submit',
+  postToolUseFailure: 'post_tool_use_failure',
+}
+
+// Copilot built-in tool name -> token-goat internal tool name. Confirmed via
+// @github/copilot-sdk type definitions and multiple real GitHub issue payload
+// dumps -- supersedes an earlier docs-based guess (shell/read/write/url) that
+// didn't hold up in practice; 'write' in particular was never a real
+// toolName value, only a Copilot permission-pattern keyword. 'powershell'
+// maps to the same 'Bash' handler as 'bash' since both are shell-command
+// execution from token-goat's perspective (mirrors how hooks_bash.ts's own
+// filters already treat powershell-wrapped commands as part of the Bash
+// pipeline, not a separate tool). 'task', 'ask_user', 'memory', and
+// MCP-server tool invocations (<server-name>-<tool-name>) have no
+// token-goat equivalent and are passed through unmapped (safe no-op for
+// handlers that don't recognize the name).
+// 'read_bash'/'read_powershell' are the background-shell output pollers, and
+// they are the exact shape of Claude Code's BashOutput: Copilot's shell tool
+// is async, so a long-running command is started once and then re-read over
+// and over within one turn, each read returning the accumulated output again.
+// hooks_bashoutput.ts already collapses that into a delta (or a short
+// "unchanged" marker) for Claude Code, and now does the same here. Both the
+// names and the argument key were read out of the shipping 1.0.80 bundle
+// rather than guessed: the builtin tool-name table in
+// prebuilds/win32-x64/runtime.node lists read_bash/stop_bash/list_bash and
+// read_powershell/stop_powershell/list_powershell, and the poller's own input
+// schema in app.js is {shellId, delay} -- so the shell id needs the
+// POLL_ID_ARG_KEY remap below to reach postBashOutputHandler, which reads
+// 'bash_id'. read_shell/stop_shell/list_shells, which an earlier static sweep
+// of the same binary suggested were the real names, are internal Rust
+// identifiers (tool_read_shell_prepare_input, tool_list_shells_descriptor,
+// PreparedStopShellInput, and the serde field names of the shell config
+// struct), never wire tool names, so they are deliberately absent here.
+// stop_bash/list_bash and their powershell twins stay unmapped because
+// token-goat has no KillShell-equivalent handler for them to reach; a mapping
+// would be pure decoration.
+// 'bash'/'powershell' stay exactly as they were. The same sweep suggested the
+// executor had been renamed to write_bash/write_powershell and that this
+// mapping was dead, and that is not what the bundle says: app.js resolves the
+// executor as shellConfig?.shellToolName ?? "bash" (with "powershell" as the
+// Windows default of the same config), and its command lives under 'command'
+// exactly as hooks_bash.ts expects. write_bash/write_powershell are real tool
+// names, but they are a different tool -- their schema is {shellId, input,
+// delay} and the bundle files them under the subtype "write_shell", i.e. send
+// stdin to an already-running shell, not run a command. Mapping them to Bash
+// would label a stdin write as a shell execution, so they are left unmapped.
+// 'task', 'read_agent' and 'memory'-family tools are likewise left alone:
+// task's result is assembled in the native addon and its shape is unknown,
+// read_agent is an incremental poll that postAgentHandler is not written for,
+// and the real tool names behind memory were never confirmed. Each would put
+// a handler that rewrites model-visible output in front of a payload shape
+// nobody has seen, which is worse than leaving the compression on the table.
+// Own properties only, for every map in this shim -- see the event map in main() for why a
+// bare lookup on a plain object literal is not a gate. A tool named 'constructor' resolved to
+// a Function, which JSON.stringify drops, so the forwarded payload carried no tool_name and
+// every hook keyed on one no-opped; '__proto__' forwarded a whole prototype instead. The key
+// is third-party text: Copilot namespaces MCP tools as server:tool and the stripped half is
+// whatever that server called its tool.
+function ownGet(map, key) {
+  return typeof key === 'string' && Object.prototype.hasOwnProperty.call(map, key) ? map[key] : undefined
+}
+
+const TOOL_TO_TG = {
+  bash: 'Bash',
+  powershell: 'Bash',
+  read_bash: 'BashOutput',
+  read_powershell: 'BashOutput',
+  view: 'Read',
+  create: 'Write',
+  edit: 'Edit',
+  web_fetch: 'WebFetch',
+  web_search: 'WebSearch',
+  grep: 'Grep',
+  glob: 'Glob',
+  skill: 'Skill',
+  exit_plan_mode: 'ExitPlanMode',
+}
+
+function foldToolName(name) {
+  return typeof name === 'string' ? name.toLowerCase().replace(/[_-]/g, '') : ''
+}
+
+const FOLDED_TOOL_TO_TG = {}
+for (const [k, v] of Object.entries(TOOL_TO_TG)) {
+  FOLDED_TOOL_TO_TG[foldToolName(k)] = v
+}
+// Also register folded entries for canonical TG tool names directly (e.g. WebSearch -> websearch)
+for (const v of Object.values(TOOL_TO_TG)) {
+  FOLDED_TOOL_TO_TG[foldToolName(v)] = v
+}
+
+function resolveCanonicalToolName(name) {
+  if (!name || typeof name !== 'string') return name
+  const direct = ownGet(TOOL_TO_TG, name)
+  if (direct !== undefined) return direct
+  const stripped = name.indexOf(':') !== -1 ? name.split(':').pop() : name
+  const strippedDirect = ownGet(TOOL_TO_TG, stripped)
+  if (strippedDirect !== undefined) return strippedDirect
+  const folded = foldToolName(name)
+  const foldedStripped = foldToolName(stripped)
+  return ownGet(FOLDED_TOOL_TO_TG, folded) || ownGet(FOLDED_TOOL_TO_TG, foldedStripped) || name
+}
+
+// Confirmed via github/copilot-cli#3349 (open, unresolved as of writing): some
+// real Copilot CLI invocations send toolArgs as a JSON-*encoded string*
+// rather than a parsed object, contradicting the documented schema. Left
+// unhandled, canonical.tool_input would become a raw string and every
+// downstream event.toolInput[key] lookup in token-goat's handlers would
+// silently return undefined -- the deny/dedup mechanism would no-op with no
+// error surfaced. Parse it defensively; on a non-string, absent, or
+// unparsable value, fall back to {} rather than throwing (this shim's
+// convention throughout is fail-open, never crash on a malformed payload).
+function parseMaybeJsonObject(value) {
+  if (value && typeof value === 'object') return value
+  if (typeof value === 'string') {
+    try {
+      const parsed = JSON.parse(value)
+      if (parsed && typeof parsed === 'object') return parsed
+    } catch {
+      // fall through to {}
+    }
+  }
+  return {}
+}
+
+// view/edit/create send the file path under 'path'; every token-goat handler these
+// three tools reach only ever looks for 'file_path' (getFilePath in hooks_common.ts).
+// Keyed by the ORIGINAL Copilot tool name (before TOOL_TO_TG renames it) since that's
+// the name toolArgs' shape is keyed to, not token-goat's internal tool name.
+const FILE_PATH_ARG_KEY = {
+  view: 'path',
+  edit: 'path',
+  create: 'path',
+}
+
+// read_bash/read_powershell send the background shell's id under 'shellId' (confirmed
+// against the poller's input schema in the shipping 1.0.80 app.js: {shellId, delay});
+// postBashOutputHandler reads 'bash_id'. Without this the tool-name mapping above would
+// be inert -- the handler bails on a missing bash_id and every poll would keep costing
+// the full accumulated output. Same keying convention as FILE_PATH_ARG_KEY: the ORIGINAL
+// Copilot tool name, since that is what the argument shape belongs to.
+const POLL_ID_ARG_KEY = {
+  read_bash: 'shellId',
+  read_powershell: 'shellId',
+}
+
+// Copilot spawns a brand-new process for every single hook invocation (no long-lived plugin
+// process the way OpenClaw's is -- OPENCLAW_HOOK_SCRIPT's own \`copilot-\${process.pid}-\${Date.now()}\`
+// fallback is safe there specifically because that process lives for the whole session, so the
+// pid stays constant across calls). If Copilot ever omits \`sessionId\` from a payload, falling
+// back to \`process.pid\` here would mint a DIFFERENT id on every single call for what's really
+// the same session, since process.pid varies per invocation -- breaking token-goat's
+// session-based dedup/state ledger, which never accumulates across calls as a result. Derive a
+// stable id instead from the one thing that's actually constant across calls for the same
+// session: the working directory Copilot reports. That field is \`workingDirectory\`, declared
+// required on BaseHookInput in copilot-sdk/types.d.ts since 1.0.76, so it is present on EVERY
+// hook event. This previously read \`payload.cwd\`, which Copilot has never sent under any name in
+// any version -- the key simply did not exist, so this derived every fallback id from
+// process.cwd() instead and \`canonical.cwd\` below was undefined on every single call. It went
+// unnoticed because process.cwd() happens to be the project directory Copilot spawns the hook in,
+// so the fallback was accidentally right; nothing about that was by design. \`cwd\` is still read
+// as a secondary in case a future version adds it under the shorter name.
+function stableFallbackSessionId(cwd) {
+  const key = typeof cwd === 'string' && cwd ? cwd : process.cwd()
+  const hash = require('node:crypto').createHash('sha256').update(key).digest('hex').slice(0, 16)
+  return 'copilot-' + hash
+}
+
+function remapToolInput(copilotToolName, input) {
+  if (!input || typeof input !== 'object') return input
+  let out = input
+  // Add the canonical key alongside the original rather than renaming it, so nothing that
+  // might read the original 'path'/'shellId' key elsewhere (e.g. a future handler) loses it.
+  const stripped = typeof copilotToolName === 'string' && copilotToolName.indexOf(':') !== -1
+    ? copilotToolName.split(':').pop()
+    : copilotToolName
+  const folded = foldToolName(stripped)
+  const pathKey = ownGet(FILE_PATH_ARG_KEY, copilotToolName) || ownGet(FILE_PATH_ARG_KEY, stripped) || (folded === 'view' || folded === 'edit' || folded === 'create' ? 'path' : undefined)
+  if (pathKey !== undefined && pathKey in out) {
+    out = Object.assign({}, out, { file_path: out[pathKey] })
+  }
+  const idKey = ownGet(POLL_ID_ARG_KEY, copilotToolName) || ownGet(POLL_ID_ARG_KEY, stripped) || (folded === 'readbash' || folded === 'readpowershell' ? 'shellId' : undefined)
+  if (idKey !== undefined && idKey in out) {
+    out = Object.assign({}, out, { bash_id: out[idKey] })
+  }
+  if (Array.isArray(out.view_range) && out.view_range.length >= 1) {
+    const rawStart = Number(out.view_range[0])
+    if (Number.isFinite(rawStart) && rawStart >= 1) {
+      const mapped = { offset: Math.floor(rawStart) }
+      if (out.view_range.length >= 2) {
+        const rawEnd = Number(out.view_range[1])
+        if (Number.isFinite(rawEnd) && rawEnd >= rawStart) {
+          mapped.limit = Math.floor(rawEnd - rawStart + 1)
+        }
+      }
+      out = Object.assign({}, out, mapped)
+    }
+  }
+  if ('old_str' in out && !('old_string' in out)) {
+    out = Object.assign({}, out, { old_string: out.old_str })
+  }
+  if ('new_str' in out && !('new_string' in out)) {
+    out = Object.assign({}, out, { new_string: out.new_str })
+  }
+  return out
+}
+
+// Attempts 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
+// process spawn entirely. Returns undefined (triggering the spawnSync fallback below)
+// when entryPath is absent, the sibling file doesn't exist (an older install predating
+// this file), or anything else goes wrong -- this must never throw.
+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)
+    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
+    return await mod.relayInProcess(tgEvent, canonical)
+  } catch {
+    return undefined
+  }
+}
+
+// VS Code's built-in agent reads this same hooks file (~/.copilot/hooks and .github/hooks are both
+// on its hook-source list) and runs these same entries, but it sends Claude Code's payload shape:
+// hook_event_name, session_id, tool_name, tool_input, tool_response. Copilot CLI's payload never
+// carries hook_event_name and always names its tool in toolName, so that pair tells them apart.
+// The payload goes to token-goat as-is under the vscode harness, which does its own tool-name
+// mapping and writes a response VS Code reads directly, so nothing here translates it.
+function isVscodePayload(payload) {
+  return payload !== null && typeof payload === 'object' && typeof payload.hook_event_name === 'string' && payload.toolName === undefined
+}
+
+async function relayVscode(entryPath, tgEvent, payload) {
+  // VS Code omits session_id when the chat has no session resource yet; key the state on the workspace instead, the same fallback the Copilot path uses.
+  const input = typeof payload.session_id === 'string' && payload.session_id !== ''
+    ? payload
+    : Object.assign({}, payload, { session_id: stableFallbackSessionId(process.cwd()) })
+  let stdout = await tryInProcess(entryPath, tgEvent, input, 'vscode')
+  if (stdout === undefined) {
+    // tgEvent is a value of the closed COPILOT_TO_TG_EVENT map (gated in main) and the harness is a literal, so nothing caller-controlled reaches the shell string below.
+    const spawnOpts = {
+      input: JSON.stringify(input),
+      encoding: 'utf8',
+      windowsHide: true,
+      timeout: 3000,
+      killSignal: 'SIGKILL',
+      maxBuffer: 32 * 1024 * 1024,
+      env: Object.assign({}, process.env, { TOKEN_GOAT_HARNESS_OVERRIDE: 'vscode', TOKEN_GOAT_VSCODE_HOOKS_DIR: __dirname }),
+    }
+    const res = entryPath
+      ? spawnSync(process.execPath, [entryPath, 'hook', tgEvent, '--harness', 'vscode'], spawnOpts)
+      : spawnSync('token-goat hook ' + tgEvent + ' --harness vscode', Object.assign({ shell: true }, spawnOpts))
+    if (res.status !== 0 || !res.stdout) return '{}'
+    stdout = res.stdout
+  }
+  try {
+    const parsed = JSON.parse(stdout)
+    return parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed) ? JSON.stringify(parsed) : '{}'
+  } catch {
+    return '{}'
+  }
+}
+
+async function main() {
+  const copilotEvent = process.argv[2] || ''
+
+  // ownGet, not a bare lookup: the map is a plain object literal, so eight keys it never declares ('constructor', 'toString', '__proto__' and the rest of Object.prototype) come back truthy and sail past the check below. tgEvent is then a Function, and 'token-goat hook ' + tgEvent is concatenated into a shell command string by the fallback at the bottom of this shim. No member of Object.prototype stringifies with a shell metacharacter, so this was a failed spawn rather than a second command -- but argv reaching a shell string through a gate that reads like it stops it is the shape worth closing, not the payload that happened to be harmless. The four shims built on shim_common.ts validate against a closed Set, which has no equivalent hole.
+  const tgEvent = ownGet(COPILOT_TO_TG_EVENT, copilotEvent)
+  if (!tgEvent) {
+    process.stdout.write('{}')
+    return
+  }
+
+  let raw = ''
+  try {
+    raw = require('node:fs').readFileSync(0, 'utf8')
+  } catch {
+    process.stdout.write('{}')
+    return
+  }
+
+  let payload
+  try {
+    payload = JSON.parse(raw)
+  } catch {
+    process.stdout.write('{}')
+    return
+  }
+
+  if (isVscodePayload(payload)) {
+    process.stdout.write(await relayVscode(process.argv[3], tgEvent, payload))
+    return
+  }
+
+  const toolName = payload && payload.toolName
+  const canonical = {
+    session_id:
+      (payload && payload.sessionId) ||
+      stableFallbackSessionId(payload && (payload.workingDirectory || payload.cwd)),
+    cwd: payload && (payload.workingDirectory || payload.cwd),
+  }
+
+  // Subagent correlation and W3C Trace Context propagation from Copilot CLI payloads
+  const agentId = payload && (payload.agent_id || payload.agentId)
+  if (typeof agentId === 'string' && agentId !== '') {
+    canonical.agent_id = agentId
+  }
+  const traceparent = payload && (payload.traceparent || payload.traceParent)
+  if (typeof traceparent === 'string' && traceparent !== '') {
+    canonical.traceparent = traceparent
+  }
+  const tracestate = payload && (payload.tracestate || payload.traceState)
+  if (typeof tracestate === 'string' && tracestate !== '') {
+    canonical.tracestate = tracestate
+  }
+
+  // userPromptSubmitted only: Copilot declares \`prompt\` required on UserPromptSubmittedHookInput.
+  // hooks_session.ts's userPromptSubmitHandler reads it as \`event.raw['prompt']\` and gates every
+  // branch it has on the text, so without this it saw '' on every Copilot prompt and the
+  // embedded-skill dedup hint could never fire. Same shape as the postToolUseFailure \`error\`
+  // drop: a required field the canonical builder simply did not list.
+  if (typeof (payload && payload.prompt) === 'string' && payload.prompt !== '') {
+    canonical.prompt = payload.prompt
+  }
+  let originalToolArgs = {}
+  if (toolName) {
+    originalToolArgs = parseMaybeJsonObject(payload && payload.toolArgs)
+    canonical.tool_name = resolveCanonicalToolName(toolName)
+    canonical.tool_input = remapToolInput(toolName, originalToolArgs)
+  }
+
+  // postToolUse only: confirmed via https://docs.github.com/en/copilot/reference/hooks-reference
+  // that Copilot's toolResult is an object ({resultType, textResultForLlm}), not a bare string
+  // or array. Without this, token-goat's tool_response consumers (hooks_read.ts's
+  // extractReadOutput, hooks_bash.ts's extractBashOutput, etc. -- all of which check for a
+  // string or an object keyed by output/content/text/body) never see any content, so
+  // post-read/post-bash stats stay empty no matter how many tool calls happen. Extract the
+  // LLM-facing text directly rather than forwarding the raw object, since textResultForLlm
+  // isn't one of those recognized object keys.
+  // postToolUseFailure only: Copilot's PostToolUseFailureHookInput (copilot-sdk/types.d.ts:1042)
+  // carries {toolName, toolArgs, error} and no toolResult at all -- the failure text lives in
+  // \`error\`, a plain string. Without forwarding it, hooks_tool_failure.ts's extractFailureText
+  // finds nothing to key on and the repeat-failure brake returns pass on every single call: wired,
+  // green, and doing nothing. Found by driving the installed shim rather than by a test, because
+  // the handler's own tests hand it a raw payload that already has the field.
+  if (typeof (payload && payload.error) === 'string' && payload.error !== '') {
+    canonical.error = payload.error
+  }
+
+  const rawResult = payload && payload.toolResult
+  if (rawResult && typeof rawResult === 'object') {
+    const tr = rawResult
+    // text_result_for_llm: Copilot's docs also describe a "VS Code compatible" snake_case
+    // wire format (tool_result.text_result_for_llm) alongside the camelCase one above; try
+    // both rather than assuming only the camelCase shape ever reaches this shim.
+    const text = typeof tr.textResultForLlm === 'string' ? tr.textResultForLlm : tr.text_result_for_llm
+    if (typeof text === 'string') canonical.tool_response = text
+  }
+
+  // process.argv[3], when present, is the absolute path to the token-goat CLI entry that ran
+  // \`token-goat install --copilot\` (baked in by hookCommandFor in copilot_cli_install.ts).
+  // Invoking it directly via process.execPath sidesteps PATH/cmd.exe resolution for this
+  // inner call too -- confirmed live-production root cause of an *intermittent* (not the
+  // original, already-fixed github/copilot-cli#4001) "(hook errored)" deny-all: even once the
+  // outer command launches via its own baked process.execPath, this inner call still shelled
+  // out to a bare \`token-goat\`, which depends on the npm global bin being on whatever PATH
+  // Copilot spawns this hook subprocess with. Falls back to the old PATH-based shell:true
+  // invocation when argv[3] is absent (an older cached hook config still pointing at a
+  // freshly-reinstalled shim, or a direct dev/test invocation), so this is a pure hardening,
+  // never a behavior break for configs installed before this fix. An args array (not a
+  // template string) is safe here specifically because entryPath and tgEvent never touch a
+  // shell -- no DEP0190 concern, unlike the shell:true fallback below.
+  const entryPath = process.argv[3]
+  // Try the in-process hook lib first (tryInProcess above), which avoids spawning a
+  // second node process altogether. If that's unavailable, invoking the entry directly
+  // via process.execPath sidesteps PATH/cmd.exe resolution for this inner call, per the
+  // note above this function's original single-spawn form documented. A 3000ms
+  // timeout/killSignal on both spawnSync fallbacks keeps them well under Copilot CLI's
+  // own hook timeout budget (~30000ms), so token-goat degrades to its own fail-open
+  // '{}' rather than being force-killed by Copilot first.
+  let stdout = await tryInProcess(entryPath, tgEvent, canonical, 'copilot_cli')
+  if (stdout === undefined) {
+    const res = entryPath
+      ? spawnSync(process.execPath, [entryPath, 'hook', tgEvent], {
+          input: JSON.stringify(canonical),
+          encoding: 'utf8',
+          windowsHide: true,
+          timeout: 3000,
+          killSignal: 'SIGKILL',
+          maxBuffer: 32 * 1024 * 1024,
+          env: Object.assign({}, process.env, { TOKEN_GOAT_HARNESS_OVERRIDE: 'copilot_cli' }),
+        })
+      : spawnSync('token-goat hook ' + tgEvent, {
+          input: JSON.stringify(canonical),
+          encoding: 'utf8',
+          shell: true,
+          windowsHide: true,
+          timeout: 3000,
+          killSignal: 'SIGKILL',
+          maxBuffer: 32 * 1024 * 1024,
+          env: Object.assign({}, process.env, { TOKEN_GOAT_HARNESS_OVERRIDE: 'copilot_cli' }),
+        })
+    if (res.status !== 0 || !res.stdout) {
+      process.stdout.write('{}')
+      return
+    }
+    stdout = res.stdout
+  }
+
+  let resp
+  try {
+    resp = JSON.parse(stdout)
+  } catch {
+    process.stdout.write('{}')
+    return
+  }
+
+  process.stdout.write(JSON.stringify(translate(copilotEvent, resp, toolName, originalToolArgs, payload)))
+}
+
+${MATERIALIZE_SHRUNK_IMAGE_JS}
+
+function translate(copilotEvent, resp, toolName, originalToolArgs, payload) {
+  if (copilotEvent === 'preToolUse') {
+    const hso = resp && resp.hookSpecificOutput
+    const denied = resp && (resp.decision === 'block' || (hso && hso.permissionDecision === 'deny'))
+    if (denied) {
+      const reason =
+        (resp && resp.reason) || (hso && hso.permissionDecisionReason) || 'blocked by token-goat'
+      return { permissionDecision: 'deny', permissionDecisionReason: reason }
+    }
+    const context = extractContext(resp)
+    // A shrink payload is a base64 data URL, not prose. It rides the same additionalContext field every other pre-tool hint does, so the two have to be told apart before either is forwarded: handing the model a data URL would cost far more context than the image it was shrunk from ever did. It is only ever materialized to a temp file the read argument is pointed at.
+    const shrinkPayload = typeof context === 'string' && context.indexOf('data:image/') !== -1
+    const out = {}
+    const updated = hso && hso.updatedInput
+    if (updated && typeof updated === 'object') {
+      out.modifiedArgs = updated
+    } else if (shrinkPayload && (toolName === 'view' || foldToolName(toolName) === 'view')) {
+      // modifiedArgs REPLACES the tool call's args wholesale (ESr in the 1.0.80 bundle, see this module's header docblock), so the full original toolArgs are spread and only Copilot's own path key is swapped.
+      const shrunkPath = materializeShrunkImage(context)
+      if (shrunkPath) out.modifiedArgs = Object.assign({}, originalToolArgs, { path: shrunkPath })
+    }
+    // Every pre-tool hint token-goat emits -- read-dedup nudges, the bash surgical-read advisories, the write-path notices -- used to stop here, on the stated grounds that Copilot's preToolUse output schema has no additionalContext field. It has one, and has had one for every version this bridge was ever checked against: copilot-sdk/types.d.ts declares additionalContext as an optional string on PreToolUseHookOutput in 1.0.80, 1.0.82, 1.0.86, 1.0.87 and 1.0.88 alike, and the 1.0.88 native runtime (prebuilds/win32-x64/runtime.node) carries it in the preToolUse response key list beside the three keys already known to work -- permissionDecision, permissionDecisionReason, modifiedArgs, additionalContext, in that order, immediately before "preToolUse hook timed out; allowing the tool call to proceed". The same binary carries an aggregation limit message naming the field generically ("Ignoring additionalContext returned by a ... hook because aggregating it would exceed the ... byte limit"), which is the mechanism 1.0.88's own release note calls combining contributions within a limit. Forwarded alongside modifiedArgs rather than instead of it: the schema accepts both, and a rewritten argument is no reason to drop the sentence explaining it.
+    if (context && !shrinkPayload) out.additionalContext = context
+    return out
+  }
+
+  if (copilotEvent === 'postToolUse') {
+    // modifiedResult is honored on success: rewriteOutput (compression, fencing, image shrink) reaches LLM.
+    // additionalContext is dropped on Copilot CLI JS path, so the ONLY channel that reaches the model here is
+    // modifiedResult.textResultForLlm, and the body that goes into it is chosen before the fold rather than
+    // instead of it. The two used to be alternatives -- a rewritten output took the first branch and skipped the
+    // fold entirely -- so any response carrying both a compressed body and a hint delivered the body and dropped
+    // the hint on the floor, silently, on the one harness this whole fold exists for. Pick the body (rewritten if
+    // there is one, else the original), then append the hint to whichever it was.
+    const hso = resp && resp.hookSpecificOutput
+    const updatedToolOutput = hso && hso.updatedToolOutput
+    const context = extractContext(resp)
+    const out = {}
+    const rawResult = payload && payload.toolResult
+    // Copilot's own ToolResult type is a union of a bare string and ToolResultObject (copilot-sdk/types.d.ts), so a string is a shape the harness itself admits even though PostToolUseHookInput narrows this field to the object form. Reading it as a body costs one typeof and removes the only route by which body could come back undefined on a well-formed payload: in every version this bridge has been checked against (1.0.80, 1.0.82, 1.0.86, 1.0.87, 1.0.88) ToolResultObject declares textResultForLlm as a required string rather than an optional one, so the object form always carries a body and the hint always has something to be folded into.
+    const originalText =
+      typeof rawResult === 'string'
+        ? rawResult
+        : rawResult && (typeof rawResult.textResultForLlm === 'string' ? rawResult.textResultForLlm : typeof rawResult.text_result_for_llm === 'string' ? rawResult.text_result_for_llm : undefined)
+    const rewritten = typeof updatedToolOutput === 'string'
+    const body = rewritten ? updatedToolOutput : typeof originalText === 'string' ? originalText : undefined
+    // Never claim a modification we did not make: with no rewrite and no hint, the body would be the tool's own
+    // text handed back verbatim, and a pass-through modifiedResult is a lie about authorship on every call.
+    if (typeof body === 'string' && (rewritten || context)) {
+      out.modifiedResult = { resultType: 'success', textResultForLlm: context ? body + '\\n\\n[token-goat: ' + context + ']' : body }
+    }
+    // Still set alongside the fold rather than instead of it: the field is dropped on the JS path read at 1.0.80,
+    // but it is the documented channel and costs nothing if a later release starts honoring it. The fold above is
+    // what the delivery guarantee rests on.
+    if (context) out.additionalContext = context
+    return out
+  }
+
+  if (copilotEvent === 'postToolUseFailure') {
+    // The failed-tool twin of postToolUse, and the only response field it accepts is
+    // additionalContext: the shipped copilot-sdk/types.d.ts says "modifiedResult or suppressOutput
+    // are not honored for failure hooks", so nothing here can fence, compress or shrink the failed
+    // output -- that gap is real and stays open. What is NOT open, and was the reason this event
+    // went unwired for so long, is whether additionalContext reaches the model at all. It does:
+    // app.js 1.0.80 at offset 2043380 either folds it into textResultForLlm (when
+    // appendFailureContextToToolResult is set) or has the native
+    // hookAppendPostToolUseFailureContext push {content, source:'system'} onto
+    // toolResult.newMessages. That is the exact opposite of postToolUse, whose additionalContext
+    // the JS side drops on the floor, so neither event's behaviour generalises to the other.
+    //
+    // Because this channel spends tokens rather than saving them, the handler behind it
+    // (hooks_tool_failure.ts) is silent on a first failure and speaks only on an exact repeat.
+    const context = extractContext(resp)
+    if (context) return { additionalContext: context }
+    return {}
+  }
+
+  if (copilotEvent === 'sessionStart') {
+    // sessionStart has no tool result to modify -- only additionalContext applies, and it's the
+    // one channel that reaches the model before it picks its first read tool, so this is where
+    // the routing reminder has to land.
+    const context = extractContext(resp)
+    if (context) return { additionalContext: context }
+    return {}
+  }
+
+  if (copilotEvent === 'agentStop' || copilotEvent === 'subagentStop') {
+    // Confirmed against the hooks reference doc: the only accepted response
+    // shape for these two events is {decision, reason} -- additionalContext
+    // is not part of their schema and Copilot silently ignores it there.
+    // token-goat's internal 'stop'/'subagent_stop' handlers never return a
+    // real deny today (subagentStopHandler only ever logs and passes), but a
+    // future deny is mapped through here rather than silently dropped.
+    if (resp && resp.decision === 'block') {
+      const reason = (resp && resp.reason) || 'blocked by token-goat'
+      return { decision: 'block', reason: reason }
+    }
+    return { decision: 'allow' }
+  }
+
+  if (copilotEvent === 'userPromptSubmitted') {
+    // Copilot's own hooks reference says command-hook output here "is dropped, including
+    // modifiedPrompt", and this branch used to believe it and return nothing. That is wrong for
+    // additionalContext on 1.0.80, established by experiment rather than by reading: a config-file
+    // command hook (at <cwd>/.github/hooks/, the project scope -- the user scope ~/.copilot/hooks/
+    // was never exercised) returned {"additionalContext":"<marker>"} and the marker turned up
+    // verbatim inside the session's user.message.transformedContent, wrapped in a
+    // <system_reminder> block. What settles that it reached the model rather than only the on-disk
+    // record is the billing: the provider's returned usage charged ~140 input tokens for a turn
+    // whose raw content field is 35 bytes, so the marker's bytes were paid for whichever field
+    // carried them. (The weaker argument first offered for this -- that transformedContent carries
+    // an envelope the content field lacks, 29 B vs 195 B -- was measured on the control turn that
+    // had no marker in it, and proves nothing about the marker.) That the model sees it is the
+    // whole point: hook.start/hook.end records also persist and reach nothing.
+    //
+    // Scope of the finding, stated honestly: demonstrated ONCE on 1.0.80, not shown to be
+    // reliable. Of two turns in that experiment, one delivered the marker and one fired a
+    // userPromptSubmitted hook that produced no output and never ran the script; no explanation
+    // was established and the rate is unknown. A hint that silently fails to arrive costs nothing
+    // and breaks nothing here, which is why the direct return is still the right default.
+    //
+    // modifiedPrompt is NOT claimed to work and is not wanted: rewriting a user's prompt is far
+    // more invasive than anything token-goat does, so only additionalContext is forwarded.
+    //
+    // This is also the write end of any post-compaction channel. Copilot has no postCompact hook.
+    // Whether the summary is recoverable from events.jsonl is NOT settled -- the emit()/
+    // emitEphemeral() distinction does not gate the writer, and the real decision is in native
+    // code; see COPILOT_NO_POST_COMPACT_REASON in ../bridges_status.ts for what was and was not
+    // established. The read end that IS confirmed is preCompact, which fires as a notification, so
+    // a manifest can be built there and drained here without reading the event log at all.
+    const context = extractContext(resp)
+    if (context) return { additionalContext: context }
+    return {}
+  }
+
+  // preCompact is the genuine notification-only case, and the contrast with userPromptSubmitted
+  // above is why this fallthrough is worth a comment at all. The hooks reference marks it
+  // "No -- notification only" for output processing, and unlike the additionalContext claim that
+  // turned out to be false, this one is confirmed in the shipping bundle: both preCompact call
+  // sites in app.js (1.0.79 and re-checked in 1.0.80) await the hook and never assign its result.
+  // There is no field to aim at here, so nothing to reconsider on the next version bump.
+  return {}
+}
+
+function extractContext(resp) {
+  const hso = resp && resp.hookSpecificOutput
+  if (hso && typeof hso.additionalContext === 'string') return hso.additionalContext
+  if (resp && typeof resp.systemMessage === 'string') return resp.systemMessage
+  return undefined
+}
+
+// Hard outer safety net, on top of main()'s own per-step try/catch fallbacks
+// (JSON.parse, readFileSync, spawnSync): a hook error must never itself cause
+// Copilot's fail-closed "(hook errored)" behavior, which denies EVERY tool
+// call unconditionally (the exact live-production failure mode behind
+// github/copilot-cli#4001). Any uncaught exception anywhere in this script --
+// including one a future code path adds that the existing per-step guards
+// don't anticipate -- still guarantees stdout gets valid JSON and the
+// process exits 0. process.exitCode is set explicitly and unconditionally at
+// the very end of every path so nothing upstream (e.g. an unhandled-rejection
+// warning in some Node versions nudging exit-code inference) can flip it.
+main()
+  .catch(() => {
+    try {
+      process.stdout.write('{}')
+    } catch {
+      // stdout itself is broken; nothing more can be done here.
+    }
+  })
+  .finally(() => {
+    process.exitCode = 0
+  })
+`;
+var TOOL_TO_TG_MAPPING = COPILOT_CLI_TOOL_NAME_MAP;
+var FOLDED_MAPPING = {};
+for (const [k, v] of Object.entries(TOOL_TO_TG_MAPPING)) {
+  FOLDED_MAPPING[foldToolName(k)] = v;
+  FOLDED_MAPPING[foldToolName(v)] = v;
+}
+
+// src/bridges/copilot_cli_install.ts
+var COPILOT_CLI_HOOK_EVENTS = [
+  "sessionStart",
+  "preToolUse",
+  "postToolUse",
+  "preCompact",
+  "agentStop",
+  "subagentStop",
+  "userPromptSubmitted",
+  "postToolUseFailure"
+];
+function copilotCliUserRoot() {
+  const override = process.env["COPILOT_HOME"];
+  if (override !== void 0 && override.trim() !== "") return path3.resolve(override);
+  return path3.join(os2.homedir(), ".copilot");
+}
+function copilotCliUserHooksDir() {
+  return path3.join(copilotCliUserRoot(), "hooks");
+}
+function copilotCliProjectHooksDir() {
+  return path3.join(process.cwd(), ".github", "hooks");
+}
+function copilotCliCacheRoot() {
+  const override = process.env["COPILOT_CACHE_HOME"];
+  if (override !== void 0 && override.trim() !== "") return path3.resolve(override);
+  const home = os2.homedir();
+  if (process.platform === "darwin") return path3.join(home, "Library", "Caches", "copilot");
+  if (process.platform === "win32") {
+    const local = process.env["LOCALAPPDATA"];
+    const base2 = local !== void 0 && local.trim() !== "" ? local : path3.join(home, ".cache");
+    return path3.join(base2, "copilot");
+  }
+  const xdg = process.env["XDG_CACHE_HOME"];
+  const base = xdg !== void 0 && xdg.trim() !== "" ? xdg : path3.join(home, ".cache");
+  return path3.join(base, "copilot");
+}
+function copilotCliMcpToolsDir() {
+  return path3.join(copilotCliCacheRoot(), "mcp-tools");
+}
+function copilotCliHooksDir(opts = {}) {
+  return opts.local === true ? copilotCliProjectHooksDir() : copilotCliUserHooksDir();
+}
+function copilotCliConfigPath(opts = {}) {
+  return path3.join(copilotCliHooksDir(opts), HOOKS_CONFIG_FILE);
+}
+function copilotCliScriptPath(opts = {}) {
+  return path3.join(copilotCliHooksDir(opts), HOOKS_SCRIPT_FILE);
+}
+function copilotCliInstructionsPath(opts = {}) {
+  return path3.join(path3.dirname(copilotCliHooksDir(opts)), "copilot-instructions.md");
+}
+var COPILOT_INSTRUCTIONS_BEGIN = "<!-- token-goat-begin -->";
+var COPILOT_INSTRUCTIONS_END = "<!-- token-goat-end -->";
+function buildCopilotInstructionsBlock() {
+  return stripInlineCodeSpans(
+    buildGuidanceBlock({
+      beginMarker: COPILOT_INSTRUCTIONS_BEGIN,
+      endMarker: COPILOT_INSTRUCTIONS_END,
+      fallbackToolClause: "Copilot CLI's native `view`, `grep`, and `glob` tools (with PowerShell commands `Get-Content`/`Select-String` as search fallbacks)",
+      gdrive: loadConfig().gdrive.enabled
+    })
+  );
+}
+function stripInlineCodeSpans(text) {
+  return text.replace(/`([^`]+)`/g, "$1");
+}
+function writeCopilotInstructionsBlock(p) {
+  const changed = upsertDelimitedBlock(p, COPILOT_INSTRUCTIONS_BEGIN, COPILOT_INSTRUCTIONS_END, buildCopilotInstructionsBlock());
+  const visualStudioChanged = syncVisualStudioProjectGuidance(p);
+  return changed || visualStudioChanged;
+}
+function stripCopilotInstructionsBlock(p) {
+  const removed = stripDelimitedBlock(p, COPILOT_INSTRUCTIONS_BEGIN, COPILOT_INSTRUCTIONS_END);
+  if (removed) syncVisualStudioProjectGuidance(p);
+  return removed;
+}
+function hookPowershellCommandFor(scriptPath, event) {
+  return `& ${hookPowershellCommand(scriptPath, event)}`;
+}
+var HOOK_TIMEOUT_SEC = 60;
+var ALLOWED_ENV_VARS = [
+  "TRACEPARENT",
+  "TRACESTATE",
+  "COPILOT_HOME",
+  "COPILOT_CACHE_HOME",
+  "TOKEN_GOAT_LOG"
+];
+function buildConfig(scriptPath) {
+  const hooks = {};
+  for (const event of COPILOT_CLI_HOOK_EVENTS) {
+    hooks[event] = [
+      {
+        type: "command",
+        command: hookCommandFor(scriptPath, event),
+        bash: hookCommandFor(scriptPath, event),
+        powershell: hookPowershellCommandFor(scriptPath, event),
+        timeoutSec: HOOK_TIMEOUT_SEC,
+        allowedEnvVars: [...ALLOWED_ENV_VARS]
+      }
+    ];
+  }
+  return { version: 1, hooks };
+}
+var HOOKS_CONFIG_FILE = "token-goat.json";
+var HOOKS_SCRIPT_FILE = "token-goat-shim.js";
+var HOOKS_OWNERS_FILE = "token-goat.owners";
+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)];
+}
+function readCopilotHooksOwners(hooksDir) {
+  const owners = /* @__PURE__ */ new Set();
+  let text;
+  try {
+    text = fs3.readFileSync(copilotHooksOwnersPath(hooksDir), "utf8");
+  } catch {
+    if (fs3.existsSync(path3.join(hooksDir, HOOKS_CONFIG_FILE))) owners.add("copilot");
+    return owners;
+  }
+  for (const line of text.split(/\r?\n/)) {
+    const name = line.trim();
+    if (name === "copilot" || name === "vscode") owners.add(name);
+  }
+  return owners;
+}
+function installCopilotHooksFile(hooksDir, owner) {
+  const configPath = path3.join(hooksDir, HOOKS_CONFIG_FILE);
+  const scriptPath = path3.join(hooksDir, HOOKS_SCRIPT_FILE);
+  const owners = readCopilotHooksOwners(hooksDir);
+  const scriptChanged = writeIfDifferent(scriptPath, COPILOT_CLI_HOOK_SCRIPT);
+  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 };
+}
+function releaseCopilotHooksFile(hooksDir, owner, keepBackups = false) {
+  const ownersPath = copilotHooksOwnersPath(hooksDir);
+  const hadSidecar = fs3.existsSync(ownersPath);
+  const owners = readCopilotHooksOwners(hooksDir);
+  if (!owners.has(owner) && (hadSidecar || owner !== "copilot")) return false;
+  owners.delete(owner);
+  if (owners.size > 0) {
+    writeIfDifferent(ownersPath, [...owners].sort().join("\n") + "\n");
+    return true;
+  }
+  const configRemoved = removeFileInScope(path3.join(hooksDir, HOOKS_CONFIG_FILE));
+  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 ownersRemoved = removeFileInScope(ownersPath);
+  return configRemoved || scriptRemoved || ownersRemoved;
+}
+function installCopilotCli(opts = {}) {
+  return withInstallScope(projectScopeRoot(opts), () => installCopilotCliScoped(opts));
+}
+function installCopilotCliScoped(opts) {
+  const instructionsPath = copilotCliInstructionsPath(opts);
+  const hooks = installCopilotHooksFile(copilotCliHooksDir(opts), "copilot");
+  const instructionsChanged = writeCopilotInstructionsBlock(instructionsPath);
+  return {
+    configPath: hooks.configPath,
+    scriptPath: hooks.scriptPath,
+    instructionsPath,
+    alreadyInstalled: !hooks.changed && !instructionsChanged
+  };
+}
+function uninstallCopilotCliScope(opts) {
+  return withInstallScope(projectScopeRoot(opts), () => uninstallCopilotCliScopeInner(opts));
+}
+function uninstallCopilotCliScopeInner(opts) {
+  let removedAny = releaseCopilotHooksFile(copilotCliHooksDir(opts), "copilot");
+  if (stripCopilotInstructionsBlock(copilotCliInstructionsPath(opts))) {
+    removedAny = true;
+  }
+  return removedAny;
+}
+function uninstallCopilotCli(opts = {}) {
+  if (opts.local === true) {
+    return uninstallCopilotCliScope({ local: true });
+  }
+  const userRemoved = uninstallCopilotCliScope({ local: false });
+  const localRemoved = uninstallCopilotCliScope({ local: true });
+  return userRemoved || localRemoved;
+}
+function isCopilotCliInstalled(opts = {}) {
+  if (!fs3.existsSync(copilotCliConfigPath(opts)) || !fs3.existsSync(copilotCliScriptPath(opts))) {
+    return false;
+  }
+  if (!readCopilotHooksOwners(copilotCliHooksDir(opts)).has("copilot")) return false;
+  let instructions;
+  try {
+    instructions = fs3.readFileSync(copilotCliInstructionsPath(opts), "utf8");
+  } catch {
+    return false;
+  }
+  return instructions.includes(COPILOT_INSTRUCTIONS_BEGIN) && instructions.includes(COPILOT_INSTRUCTIONS_END);
+}
+
+// src/copilot_mcp_tools.ts
+init_define_import_meta_env();
+import fs4 from "node:fs";
+import path4 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 = fs4.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(fs4.readFileSync(path4.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 };
+}
+
+export {
+  foldToolName,
+  COPILOT_CLI_TOOL_NAME_MAP,
+  MATERIALIZE_SHRUNK_IMAGE_JS,
+  buildGuidanceBody,
+  skillDescriptionLine,
+  buildGuidanceBlock,
+  jsonc,
+  bundledCliPath,
+  managedServer,
+  isManagedServer,
+  readServersJson,
+  serversOf,
+  setTokenGoatServer,
+  isResidueServersJson,
+  dropEmptyServers,
+  hasManagedServer,
+  visualStudioUserMcpPath,
+  visualStudioProjectMcpPath,
+  visualStudioOtherScopeHasManagedServer,
+  isVisualStudioInstalled,
+  visualStudioSolutionVscodeMcpPath,
+  visualStudioDuplicateNote,
+  visualStudioMcpStatus,
+  visualStudioManagedEntry,
+  syncVisualStudioProjectGuidance,
+  installVisualStudio,
+  uninstallVisualStudio,
+  copilotCliUserRoot,
+  copilotCliMcpToolsDir,
+  copilotCliConfigPath,
+  copilotCliScriptPath,
+  HOOKS_SCRIPT_FILE,
+  copilotHooksFilePaths,
+  readCopilotHooksOwners,
+  installCopilotHooksFile,
+  releaseCopilotHooksFile,
+  installCopilotCli,
+  uninstallCopilotCli,
+  isCopilotCliInstalled,
+  readCopilotMcpTools
+};