token-goat 2.9.30 → 2.9.31

package/dist/{token-goat-chunk-HG45AF2B.mjs → token-goat-chunk-AUQYRMMH.mjs}

@@ -14,34 +14,61 @@ import {
   anchoredMarkerPattern,
   buildGuidanceBlock,
   buildGuidanceBody,
+  bundledCliPath,
+  canonicalProjectRoot,
+  claudeHooksInstalledAnyScope,
+  copilotHooksFilePaths,
+  copilotMcpConfigPath,
+  dropEmptyServers,
   editAt,
+  findStrayClaudeMdBlocks,
   finishHookUninstall,
   groupHasTokenGoat,
+  hasManagedServer,
   hookCommandRewrittenSpan,
+  installCopilotHooksFile,
+  isManagedServer,
+  isResidueServersJson,
   legacyShimForwarder,
+  managedServer,
+  managedServerEntry,
   nativeHookBinary,
   nativeHookCommandLine,
+  noteRootKeyCreation,
+  readServersJson,
+  releaseCopilotHooksFile,
+  serversOf,
+  setTokenGoatServer,
+  shimFallbackTimeoutConst,
   skillDescriptionLine,
-  splitHookCommand
-} from "./token-goat-chunk-OJBNYTJP.mjs";
+  splitHookCommand,
+  syncVisualStudioProjectGuidance,
+  visualStudioManagedEntry
+} from "./token-goat-chunk-7MAOA6X4.mjs";
 import {
   parseJsonOrJsonc,
   stripBom
-} from "./token-goat-chunk-XKI4SEMX.mjs";
+} from "./token-goat-chunk-QQTWJY2O.mjs";
+import {
+  readCopilotHooksOwners
+} from "./token-goat-chunk-G5PJ7AGM.mjs";
 import {
   toolMatcherFor
-} from "./token-goat-chunk-P4QMM4WK.mjs";
+} from "./token-goat-chunk-C75NA7PL.mjs";
 import {
   GEMINI_TOOL_NAME_MAP
-} from "./token-goat-chunk-VPBBTSJR.mjs";
+} from "./token-goat-chunk-76FGDLRO.mjs";
 import {
   loadConfig,
   parse,
   stringify
-} from "./token-goat-chunk-7IN2MKDS.mjs";
+} from "./token-goat-chunk-7EZTZOMC.mjs";
 import {
+  assertProjectScopeTarget,
+  atomicWriteBytes,
   atomicWriteText,
   backupFile,
+  countNoun,
   ensureDirRecordingCreation,
   ensureDirSync,
   extractErrorMessage,
@@ -49,28 +76,41 @@ import {
   hookCommandFor,
   hookPowershellCommand,
   installSingleFilePlugin,
+  projectPathIsConsultable,
   projectScopeRoot,
   recordCreatedBy,
   recordCreatedConfig,
+  recordTurnedOffSetting,
   removeCreatedBackups,
   removeCreatedIfEmpty,
   removeCreatedTree,
+  removeEmptyDirInScope,
+  removeFileInScope,
   stripDelimitedBlock,
   stripOwnHooksFromMap,
   stripStaleGroupHooks,
   takeCreatedConfig,
+  takeTurnedOffSetting,
   uninstallSingleFilePlugin,
   upsertDelimitedBlock,
   withInstallScope,
   writeConfigText,
   writeIfDifferent,
   writeJsonSettings
-} from "./token-goat-chunk-GOLEOXZP.mjs";
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  echoedValue,
+  fencedCommand
+} from "./token-goat-chunk-GGGG7RWB.mjs";
 import {
   foldPath,
   powershellHookLine,
   quoteShellPath
 } from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  displaySafeText,
+  normalizePath
+} from "./token-goat-chunk-FNFBKLRD.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -157,7 +197,7 @@ function geminiSettingsPath() {
 }
 function readGeminiSettings(p, opts = {}) {
   const refuse = (problem, detail) => new GeminiSettingsParseError(
-    (opts.command === "uninstall" ? `Gemini settings file '${p}' is unreadable: it ${problem}. Uninstall left it and its backups untouched; fix the file and run uninstall again.` : `Gemini settings file '${p}' ${problem}. Fix or back up the file before running install.`) + (detail === void 0 ? "" : ` (${detail})`)
+    (opts.command === "uninstall" ? `Gemini settings file ${echoedValue(p)} is unreadable: it ${problem}. Uninstall left it and its backups untouched; fix the file and run uninstall again.` : `Gemini settings file ${echoedValue(p)} ${problem}. Fix or back up the file before running install.`) + (detail === void 0 ? "" : ` (${detail})`)
   );
   let raw;
   try {
@@ -290,7 +330,7 @@ function qwenSettingsPath() {
 }
 function readQwenSettings(p, opts = {}) {
   const refuse = (problem, detail) => new QwenSettingsParseError(
-    (opts.command === "uninstall" ? `Qwen Code settings file '${p}' is unreadable: it ${problem}. Uninstall left it and its backups untouched; fix the file and run uninstall again.` : `Qwen Code settings file '${p}' ${problem}. Fix or back up the file before running install.`) + (detail === void 0 ? "" : ` (${detail})`)
+    (opts.command === "uninstall" ? `Qwen Code settings file ${echoedValue(p)} is unreadable: it ${problem}. Uninstall left it and its backups untouched; fix the file and run uninstall again.` : `Qwen Code settings file ${echoedValue(p)} ${problem}. Fix or back up the file before running install.`) + (detail === void 0 ? "" : ` (${detail})`)
   );
   let raw;
   try {
@@ -431,6 +471,7 @@ ${SHIM_TRY_SERVER}
 ${SHIM_TRY_IN_PROCESS}
 
 ${SHIM_MAX_BUFFER_CONST}
+${shimFallbackTimeoutConst("kimi")}
 
 async function main() {
   const eventName = process.argv[2] || ''
@@ -444,7 +485,7 @@ async function main() {
   // process.argv[3], when present, is the absolute path to the token-goat CLI entry that ran
   // 'token-goat install --kimi' (baked in by hookCommandFor in kimi_install.ts). Same three-step
   // ladder as the Codex shim: in-process hook lib, then the baked entry via process.execPath,
-  // then a PATH-based shell:true invocation for an older cached hook config. The 3000ms
+  // then a PATH-based shell:true invocation for an older cached hook config. The SHIM_FALLBACK_TIMEOUT_MS
   // timeout keeps both spawn fallbacks well inside Kimi's own 30s default hook timeout
   // (docs/en/customization/hooks.md), so token-goat degrades to its own fail-open no-op.
   const entryPath = process.argv[3]
@@ -455,7 +496,7 @@ ${SHIM_SPAWN_LADDER}
           input,
           encoding: 'utf8',
           shell: true,
-          timeout: 3000,
+          timeout: SHIM_FALLBACK_TIMEOUT_MS,
           killSignal: 'SIGKILL',
           maxBuffer: SHIM_MAX_BUFFER_BYTES,
         })
@@ -514,7 +555,7 @@ function kimiSkillPath() {
 }
 function readKimiConfig(p, opts = {}) {
   const refuse = (problem, detail) => new KimiConfigParseError(
-    (opts.command === "uninstall" ? `Kimi Code config file '${p}' is unreadable: it ${problem}. Uninstall left it untouched, along with the hook shim it may still name, the AGENTS.md block, the skill and the file's backups; fix the file and run uninstall again.` : `Kimi Code config file '${p}' ${problem}. Fix or back up the file before running install.`) + (detail === void 0 ? "" : ` (${detail})`)
+    (opts.command === "uninstall" ? `Kimi Code config file ${echoedValue(p)} is unreadable: it ${problem}. Uninstall left it untouched, along with the hook shim it may still name, the AGENTS.md block, the skill and the file's backups; fix the file and run uninstall again.` : `Kimi Code config file ${echoedValue(p)} ${problem}. Fix or back up the file before running install.`) + (detail === void 0 ? "" : ` (${detail})`)
   );
   let raw;
   try {
@@ -586,7 +627,7 @@ function installKimiFiles() {
   for (const { command } of process.platform === "win32" ? desired : []) {
     const span = hookCommandRewrittenSpan(command, "cmd");
     if (span !== void 0) {
-      throw new HookCommandRewriteError(`Kimi Code runs hook commands through cmd.exe, which replaces ${span} with the value of the environment variable of that name whenever one is set, before it reads any quotes, so the hook command token-goat would write (${command}) would not run token-goat. Nothing was written. Move the path that contains "${span}" (the Kimi Code home, token-goat's install directory, or Node's) to one without a %...% pair, then run 'token-goat install --kimi' again.`);
+      throw new HookCommandRewriteError(`Kimi Code runs hook commands through cmd.exe, which replaces ${span} with the value of the environment variable of that name whenever one is set, before it reads any quotes, so the hook command token-goat would write (${command}) would not run token-goat. Nothing was written. Move the path that contains ${echoedValue(span)} (the Kimi Code home, token-goat's install directory, or Node's) to one without a %...% pair, then run \`token-goat install --kimi\` again.`);
     }
   }
   ensureDirSync(path4.dirname(scriptPath));
@@ -771,6 +812,8 @@ async function resolveRelayInProcess(): Promise<RelayInProcessFn | undefined> {
   }
 }
 
+${shimFallbackTimeoutConst("pi")}
+
 function callHookViaSpawn(event: string, payload: Record<string, unknown>): Record<string, unknown> | null {
   try {
     // TOKEN_GOAT_HARNESS_OVERRIDE=pi guarantees detectHarness() resolves to
@@ -789,7 +832,7 @@ function callHookViaSpawn(event: string, payload: Record<string, unknown>): Reco
       ? spawnSync(process.execPath, [entryPath, "hook", event], {
           input: JSON.stringify(payload),
           encoding: "utf8",
-          timeout: 3000,
+          timeout: SHIM_FALLBACK_TIMEOUT_MS,
           killSignal: "SIGKILL",
           windowsHide: true,
           maxBuffer: 32 * 1024 * 1024,
@@ -798,7 +841,7 @@ function callHookViaSpawn(event: string, payload: Record<string, unknown>): Reco
       : spawnSync('token-goat hook ' + event, {
           input: JSON.stringify(payload),
           encoding: "utf8",
-          timeout: 3000,
+          timeout: SHIM_FALLBACK_TIMEOUT_MS,
           killSignal: "SIGKILL",
           shell: true,
           windowsHide: true,
@@ -817,9 +860,8 @@ function callHookViaSpawn(event: string, payload: Record<string, unknown>): Reco
 // Tries the in-process hook call first (resolveRelayInProcess above), which avoids
 // spawning a second node process altogether for every single tool call in this
 // long-lived agent process. Falls back to callHookViaSpawn (the original
-// spawnSync-based path, now with a 3000ms timeout/killSignal so token-goat degrades to
-// its own fail-open null rather than being force-killed by pi's own hook timeout
-// budget, ~5000ms) when the in-process path is unavailable or throws.
+// spawnSync-based path, now bounded by SHIM_FALLBACK_TIMEOUT_MS and a killSignal so token-goat degrades to
+// its own fail-open null rather than hanging pi, which applies no hook timeout of its own) when the in-process path is unavailable or throws.
 async function callHook(event: string, payload: Record<string, unknown>): Promise<Record<string, unknown> | null> {
   // Timed from here, not from process start: this host lives far longer than one call, so the hook library's default clock (process age) would record the host's uptime as this call's duration.
   const start = performance.now();
@@ -1184,6 +1226,8 @@ async function resolveRelayInProcess() {
   }
 }
 
+${shimFallbackTimeoutConst("relay")}
+
 function callHookViaSpawn(event, payload) {
   try {
     // Invoking "token-goat" as a bare command here depends on PATH resolution
@@ -1199,7 +1243,7 @@ function callHookViaSpawn(event, payload) {
       ? spawnSync(process.execPath, [entryPath, "hook", event], {
           input: JSON.stringify(payload),
           encoding: "utf8",
-          timeout: 3000,
+          timeout: SHIM_FALLBACK_TIMEOUT_MS,
           killSignal: "SIGKILL",
           windowsHide: true,
           maxBuffer: 32 * 1024 * 1024,
@@ -1207,7 +1251,7 @@ function callHookViaSpawn(event, payload) {
       : spawnSync("token-goat hook " + event, {
           input: JSON.stringify(payload),
           encoding: "utf8",
-          timeout: 3000,
+          timeout: SHIM_FALLBACK_TIMEOUT_MS,
           killSignal: "SIGKILL",
           shell: true,
           windowsHide: true,
@@ -1225,9 +1269,9 @@ function callHookViaSpawn(event, payload) {
 // Tries the in-process hook call first (resolveRelayInProcess above), which avoids
 // spawning a second node process altogether for every single tool call in this
 // long-lived host process. Falls back to callHookViaSpawn (the original
-// spawnSync-based path, now with a 3000ms timeout/killSignal so token-goat degrades to
+// spawnSync-based path, now bounded by SHIM_FALLBACK_TIMEOUT_MS and a killSignal so token-goat degrades to
 // its own fail-open null rather than being force-killed by the host's own hook timeout
-// budget, ~5000ms) when the in-process path is unavailable or throws.
+// budget, 15000ms for OpenClaw's before_tool_call) when the in-process path is unavailable or throws.
 async function callHook(event, payload) {
   // Timed from here, not from process start: this host lives far longer than one call, so the hook library's default clock (process age) would record the host's uptime as this call's duration.
   const start = performance.now();
@@ -1341,8 +1385,6 @@ function extractUpdatedInput(resp) {
   return hso && typeof hso === "object" ? hso.updatedInput : undefined
 }
 
-${MATERIALIZE_SHRUNK_IMAGE_JS}
-
 export const TokenGoatPlugin = async ({ directory }) => {
   return {
     "tool.execute.before": async (input, output) => {
@@ -1367,14 +1409,6 @@ export const TokenGoatPlugin = async ({ directory }) => {
         for (const [tgKey, val] of Object.entries(updated)) {
           output.args[rev[tgKey] ?? tgKey] = val
         }
-        return
-      }
-
-      // Image shrink has no context channel here -- translate it into a
-      // rewritten filePath pointing at a materialized shrunk copy instead.
-      if (tg === "Read") {
-        const shrunkPath = materializeShrunkImage(extractContext(resp))
-        if (shrunkPath) output.args.filePath = shrunkPath
       }
     },
 
@@ -1692,7 +1726,7 @@ function openclawEntrySidecarPath() {
 }
 function readOpenclawConfig(p, opts = {}) {
   const refuse = (problem, detail) => new OpenclawConfigParseError(
-    (opts.command === "uninstall" ? `OpenClaw config file '${p}' is unreadable: it ${problem}. Uninstall left it untouched, along with the plugin it may still load, the plugin's entry sidecar and the file's backups; fix the file and run uninstall again.` : `OpenClaw config file '${p}' ${problem}. Fix or back up the file before running install.`) + (detail === void 0 ? "" : ` (${detail})`)
+    (opts.command === "uninstall" ? `OpenClaw config file ${echoedValue(p)} is unreadable: it ${problem}. Uninstall left it untouched, along with the plugin it may still load, the plugin's entry sidecar and the file's backups; fix the file and run uninstall again.` : `OpenClaw config file ${echoedValue(p)} ${problem}. Fix or back up the file before running install.`) + (detail === void 0 ? "" : ` (${detail})`)
   );
   let raw;
   try {
@@ -1855,6 +1889,7 @@ ${SHIM_TRY_SERVER}
 ${SHIM_TRY_IN_PROCESS}
 
 ${SHIM_MAX_BUFFER_CONST}
+${shimFallbackTimeoutConst("grok")}
 
 async function main() {
   const eventName = process.argv[2] || ''
@@ -1887,7 +1922,7 @@ ${SHIM_SPAWN_LADDER}
           input,
           encoding: 'utf8',
           shell: true,
-          timeout: 3000,
+          timeout: SHIM_FALLBACK_TIMEOUT_MS,
           killSignal: 'SIGKILL',
           maxBuffer: SHIM_MAX_BUFFER_BYTES,
         })
@@ -2000,7 +2035,7 @@ function installGrokFiles() {
   for (const command of Object.values(config.hooks).flatMap((groups) => (groups ?? []).flatMap((g) => g.hooks.map((h) => h.command)))) {
     const span = hookCommandRewrittenSpan(command, "grok");
     if (span !== void 0) {
-      throw new HookCommandRewriteError(`Grok CLI substitutes ${span} in a hook command with the value of that environment variable when it loads the hook, whatever the quoting, and refuses to run the hook when it is unset, so the hook command token-goat would write (${command}) would not run token-goat. Nothing was written. Move the path that contains "${span}" (the home directory, token-goat's install directory, or Node's) to one without a $ name, then run 'token-goat install --grok' again.`);
+      throw new HookCommandRewriteError(`Grok CLI substitutes ${span} in a hook command with the value of that environment variable when it loads the hook, whatever the quoting, and refuses to run the hook when it is unset, so the hook command token-goat would write (${command}) would not run token-goat. Nothing was written. Move the path that contains ${echoedValue(span)} (the home directory, token-goat's install directory, or Node's) to one without a $ name, then run \`token-goat install --grok\` again.`);
     }
   }
   const forwarderChanged = writeIfDifferent(grokLegacyHookScriptPath(), legacyShimForwarder("{}"));
@@ -2074,7 +2109,7 @@ function shimPath() {
 }
 function readJsonObject(p, label, opts = {}) {
   const refuse = (problem, detail) => new AntigravitySettingsParseError(
-    (opts.command === "uninstall" ? `Antigravity ${label} '${p}' is unreadable: it ${problem}. Uninstall left it and its backups untouched; fix the file and run uninstall again.` : `Antigravity ${label} '${p}' ${problem}. Fix or back up the file before running install.`) + (detail === void 0 ? "" : ` (${detail})`)
+    (opts.command === "uninstall" ? `Antigravity ${label} ${echoedValue(p)} is unreadable: it ${problem}. Uninstall left it and its backups untouched; fix the file and run uninstall again.` : `Antigravity ${label} ${echoedValue(p)} ${problem}. Fix or back up the file before running install.`) + (detail === void 0 ? "" : ` (${detail})`)
   );
   let raw;
   try {
@@ -2193,6 +2228,692 @@ function isAntigravityInstalled() {
   return readShim()?.includes(SHIM_MARKER) === true;
 }
 
+// src/bridges/vscode_install.ts
+init_define_import_meta_env();
+import * as fs10 from "node:fs";
+import * as os9 from "node:os";
+import * as path10 from "node:path";
+var VSCODE_GUIDANCE_BEGIN = "<!-- token-goat-vscode-begin -->";
+var VSCODE_GUIDANCE_END = "<!-- token-goat-vscode-end -->";
+var BEGIN = VSCODE_GUIDANCE_BEGIN;
+var END = VSCODE_GUIDANCE_END;
+function vscodeUserConfigDir() {
+  if (process.platform === "win32") {
+    const appData = process.env["APPDATA"];
+    const base = appData !== void 0 && appData.trim() !== "" ? appData : path10.join(os9.homedir(), "AppData", "Roaming");
+    return path10.join(base, "Code", "User");
+  }
+  if (process.platform === "darwin") {
+    return path10.join(os9.homedir(), "Library", "Application Support", "Code", "User");
+  }
+  const xdg = process.env["XDG_CONFIG_HOME"];
+  return path10.join(xdg !== void 0 && path10.isAbsolute(xdg) ? xdg : path10.join(os9.homedir(), ".config"), "Code", "User");
+}
+function vscodeUserMcpPath() {
+  return path10.join(vscodeUserConfigDir(), "mcp.json");
+}
+function vscodeProjectMcpPath(projectRoot = process.cwd()) {
+  return path10.join(path10.resolve(projectRoot), ".vscode", "mcp.json");
+}
+function vscodeMcpPath(opts = {}) {
+  return opts.project === true ? vscodeProjectMcpPath(opts.projectRoot) : vscodeUserMcpPath();
+}
+function otherScopeMcpPath(opts) {
+  return opts.project === true ? vscodeUserMcpPath() : vscodeProjectMcpPath(opts.projectRoot);
+}
+function vscodeInstructionsPath(opts = {}) {
+  return opts.project === true ? path10.join(path10.resolve(opts.projectRoot ?? process.cwd()), ".github", "copilot-instructions.md") : path10.join(os9.homedir(), ".copilot", "instructions", "token-goat.instructions.md");
+}
+var USER_INSTRUCTIONS_FRONTMATTER = "---\ndescription: 'token-goat: when to use its MCP tools and CLI instead of reading whole files'\napplyTo: '**'\n---\n";
+function vscodeHooksDir(opts = {}) {
+  return opts.project === true ? path10.join(canonicalProjectRoot(path10.resolve(opts.projectRoot ?? process.cwd())), ".github", "hooks") : path10.join(os9.homedir(), ".copilot", "hooks");
+}
+function vscodeScopeFromFlags(flags) {
+  return { project: flags.user !== true };
+}
+function vscodeHooksInstalled(opts = {}) {
+  return readCopilotHooksOwners(vscodeHooksDir(opts)).has("vscode");
+}
+var CLAUDE_HOOKS_SETTING = "chat.useClaudeHooks";
+function vscodeUserSettingsPath() {
+  return path10.join(vscodeUserConfigDir(), "settings.json");
+}
+function vscodeUsesClaudeHooks(settingsPath = vscodeUserSettingsPath()) {
+  return readSettingsObject(settingsPath)?.[CLAUDE_HOOKS_SETTING] === true;
+}
+function vscodeRunsTokenGoatClaudeHooks(settingsPath = vscodeUserSettingsPath()) {
+  return vscodeUsesClaudeHooks(settingsPath) && claudeHooksInstalledAnyScope();
+}
+function readSettingsObject(settingsPath) {
+  try {
+    const prev = parseJsonOrJsonc(stripBom(fs10.readFileSync(settingsPath, "utf8")), { allowTrailingComma: true });
+    return prev === null || typeof prev !== "object" || Array.isArray(prev) ? null : prev;
+  } catch {
+    return null;
+  }
+}
+function disableVscodeClaudeHooks(settingsPath = vscodeUserSettingsPath()) {
+  const prev = readSettingsObject(settingsPath);
+  if (prev?.[CLAUDE_HOOKS_SETTING] !== true) return false;
+  withInstallScope(void 0, () => {
+    writeSettingsKeepingComments(settingsPath, { ...prev, [CLAUDE_HOOKS_SETTING]: false }, { allowTrailingComma: true });
+  });
+  recordTurnedOffSetting(settingsPath, CLAUDE_HOOKS_SETTING);
+  return true;
+}
+function restoreVscodeClaudeHooks(settingsPath = vscodeUserSettingsPath()) {
+  if (!takeTurnedOffSetting(settingsPath, CLAUDE_HOOKS_SETTING)) return false;
+  const current = readSettingsObject(settingsPath);
+  if (current === null || current[CLAUDE_HOOKS_SETTING] !== false) return false;
+  try {
+    withInstallScope(void 0, () => {
+      writeSettingsKeepingComments(settingsPath, { ...current, [CLAUDE_HOOKS_SETTING]: true }, { allowTrailingComma: true });
+    });
+  } catch (e) {
+    recordTurnedOffSetting(settingsPath, CLAUDE_HOOKS_SETTING);
+    throw e;
+  }
+  return true;
+}
+function readConfig(filePath) {
+  return readServersJson(filePath, "VS Code");
+}
+var updateConfig = setTokenGoatServer;
+function otherScopeHasManagedServer(opts) {
+  const otherPath = otherScopeMcpPath(opts);
+  if (opts.project !== true && !projectPathIsConsultable(otherPath, path10.resolve(opts.projectRoot ?? process.cwd()))) return false;
+  return hasManagedServer(otherPath, "VS Code");
+}
+function vscodeDecoderConfigured(opts = {}) {
+  const checkedPaths = [vscodeUserMcpPath()];
+  if (opts.projectRoot !== void 0) {
+    const projectPath = vscodeProjectMcpPath(opts.projectRoot);
+    if (projectPathIsConsultable(projectPath, path10.resolve(opts.projectRoot))) checkedPaths.push(projectPath);
+  }
+  return { configured: checkedPaths.some((candidate) => hasManagedServer(candidate, "VS Code")), checkedPaths };
+}
+function writeGuidance(filePath, userScope) {
+  let created = false;
+  if (userScope && !fs10.existsSync(filePath)) {
+    ensureDirSync(path10.dirname(filePath));
+    atomicWriteText(filePath, USER_INSTRUCTIONS_FRONTMATTER);
+    created = true;
+  }
+  const body = [
+    BEGIN,
+    buildGuidanceBody("VS Code\u2019s supported MCP integration and its built-in file-read tools", { gdrive: loadConfig().gdrive?.enabled ?? false }),
+    "",
+    "**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 the chat is not in Agent mode), say so plainly and ask the user to switch to Agent mode or run `token-goat install --vscode`.",
+    "",
+    "VS Code support: token-goat install --vscode configures a stdio MCP server under the servers root key in your user-profile mcp.json by default (add --project for the workspace .vscode/mcp.json instead), and agent hooks that see VS Code\u2019s built-in tool calls. The hooks can deny a repeated read, add a hint, and shrink an image before view_image loads it; they cannot fold or trim what a built-in read returns, and they leave terminal commands unchanged.",
+    END
+  ].join("\n");
+  return upsertDelimitedBlock(filePath, BEGIN, END, body) || created;
+}
+function assertProjectTargetsAreInTheProject(opts) {
+  if (opts.project !== true) return;
+  const root = path10.resolve(opts.projectRoot ?? process.cwd());
+  for (const target of [vscodeMcpPath(opts), vscodeInstructionsPath(opts), ...copilotHooksFilePaths(vscodeHooksDir(opts))]) {
+    assertProjectScopeTarget(target, root);
+  }
+}
+function installVscode(opts = {}) {
+  return withInstallScope(projectScopeRoot(opts), () => installVscodeScoped(opts));
+}
+function installVscodeScoped(opts) {
+  assertProjectTargetsAreInTheProject(opts);
+  const scope = opts.project === true ? "project" : "user";
+  const mcpPath = vscodeMcpPath(opts);
+  const instructionsPath = vscodeInstructionsPath(opts);
+  let migratedFromUserScope = false;
+  if (scope === "project" && (otherScopeHasManagedServer(opts) || vscodeHooksInstalled())) {
+    migratedFromUserScope = uninstallVscode({ keepBackups: true });
+  } else if (otherScopeHasManagedServer(opts)) {
+    const otherPath = otherScopeMcpPath(opts);
+    throw new Error(
+      `token-goat is already registered in VS Code project scope (${otherPath}). Installing into user scope too would register it twice and duplicate its tool schemas in this workspace. Run \`token-goat uninstall --vscode --project\` first if you want to move it, or drop --vscode from this run.`
+    );
+  }
+  const config = readConfig(mcpPath);
+  const existingServers = config.value["servers"];
+  if (existingServers !== void 0 && (existingServers === null || typeof existingServers !== "object" || Array.isArray(existingServers))) {
+    throw new Error(`malformed VS Code MCP JSON at ${mcpPath}: servers must be an object`);
+  }
+  const servers = existingServers ?? {};
+  const current = servers["token-goat"];
+  if (current !== void 0 && !isManagedServer(current)) {
+    throw new Error(`VS Code MCP JSON at ${mcpPath} already has a non-token-goat-managed server named "token-goat"`);
+  }
+  const next = updateConfig(config.text, managedServer());
+  const mcpExisted = fs10.existsSync(mcpPath);
+  ensureDirSync(path10.dirname(mcpPath));
+  if (config.text !== next) {
+    backupFile(mcpPath);
+    writeConfigText(mcpPath, next);
+    noteRootKeyCreation(mcpPath, config);
+    if (!mcpExisted) recordCreatedConfig(mcpPath);
+  }
+  const guidanceDir = path10.dirname(instructionsPath);
+  const guidanceDirExisted = fs10.existsSync(guidanceDir);
+  const guidanceExisted = fs10.existsSync(instructionsPath);
+  const guidanceChanged = writeGuidance(instructionsPath, scope === "user");
+  if (scope === "project") {
+    if (!guidanceDirExisted && fs10.existsSync(guidanceDir)) recordCreatedConfig(guidanceDir);
+    if (!guidanceExisted && fs10.existsSync(instructionsPath)) recordCreatedConfig(instructionsPath);
+  }
+  if (scope === "project") syncVisualStudioProjectGuidance(instructionsPath);
+  const hooks = installCopilotHooksFile(vscodeHooksDir(opts), "vscode");
+  let disabledClaudeHooks = false;
+  if (scope === "user" && vscodeRunsTokenGoatClaudeHooks()) {
+    disabledClaudeHooks = disableVscodeClaudeHooks();
+  }
+  return {
+    mcpPath,
+    instructionsPath,
+    hooksConfigPath: hooks.configPath,
+    alreadyInstalled: config.text === next && !guidanceChanged && !hooks.changed && !migratedFromUserScope && !disabledClaudeHooks,
+    scope,
+    migratedFromUserScope,
+    disabledClaudeHooks
+  };
+}
+function uninstallVscode(opts = {}) {
+  return withInstallScope(projectScopeRoot(opts), () => uninstallVscodeScoped(opts));
+}
+function uninstallVscodeScoped(opts) {
+  assertProjectTargetsAreInTheProject(opts);
+  const mcpPath = vscodeMcpPath(opts);
+  let removed = false;
+  if (fs10.existsSync(mcpPath)) {
+    const config = readConfig(mcpPath);
+    const servers = config.value["servers"];
+    if (servers !== void 0 && (servers === null || typeof servers !== "object" || Array.isArray(servers))) {
+      throw new Error(`malformed VS Code MCP JSON at ${mcpPath}: servers must be an object`);
+    }
+    if (servers && isManagedServer(servers["token-goat"])) {
+      const next = dropEmptyServers(updateConfig(config.text, void 0), mcpPath);
+      if (/^\s*\{\s*\}\s*$/.test(next) && takeCreatedConfig(mcpPath)) {
+        removeFileInScope(mcpPath);
+        if (opts.project === true) {
+          removeEmptyDirInScope(path10.dirname(mcpPath));
+        }
+      } else {
+        backupFile(mcpPath);
+        writeConfigText(mcpPath, next);
+      }
+      if (opts.keepBackups !== true) removeCreatedBackups(mcpPath);
+      removed = true;
+    }
+  }
+  const instructionsPath = vscodeInstructionsPath(opts);
+  if (stripDelimitedBlock(instructionsPath, BEGIN, END, opts.keepBackups === true)) {
+    removed = true;
+    if (opts.project !== true && fs10.readFileSync(instructionsPath, "utf8").trim() === USER_INSTRUCTIONS_FRONTMATTER.trim()) removeFileInScope(instructionsPath);
+  }
+  if (opts.project === true) syncVisualStudioProjectGuidance(instructionsPath);
+  if (releaseCopilotHooksFile(vscodeHooksDir(opts), "vscode", opts.keepBackups === true)) removed = true;
+  if (opts.project === true) {
+    removeCreatedIfEmpty(instructionsPath);
+    removeCreatedIfEmpty(path10.dirname(instructionsPath));
+  }
+  return removed;
+}
+function cleanupDeprecatedVscodeProjectMcp(projectRoot) {
+  const root = path10.resolve(projectRoot ?? process.cwd());
+  return withInstallScope(root, () => {
+    const projectMcp = path10.join(root, ".vscode", "mcp.json");
+    if (!fs10.existsSync(projectMcp)) return false;
+    const text = fs10.readFileSync(projectMcp, "utf8");
+    if (isResidueServersJson(text) && takeCreatedConfig(projectMcp)) {
+      removeFileInScope(projectMcp);
+      removeEmptyDirInScope(path10.dirname(projectMcp));
+      removeCreatedBackups(projectMcp);
+      return true;
+    }
+    return false;
+  });
+}
+
+// src/cli_doctor_platforms.ts
+init_define_import_meta_env();
+import * as fs13 from "node:fs";
+import * as path13 from "node:path";
+
+// src/bridges/cursor_install.ts
+init_define_import_meta_env();
+import * as fs11 from "node:fs";
+import * as os10 from "node:os";
+import * as path11 from "node:path";
+var MCP_SERVERS_KEY = "mcpServers";
+var TOKEN_GOAT_ENTRY_KEY = "token-goat";
+function cursorUserConfigDir() {
+  return path11.join(os10.homedir(), ".cursor");
+}
+function cursorMcpPath(opts = {}) {
+  if (opts.project === true) {
+    return path11.join(opts.projectRoot ?? process.cwd(), ".cursor", "mcp.json");
+  }
+  return path11.join(cursorUserConfigDir(), "mcp.json");
+}
+function cursorManagedServer() {
+  return { command: process.execPath, args: [bundledCliPath(), "mcp-serve"] };
+}
+function isCursorManagedServer(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const entry = value;
+  const args = entry["args"];
+  return entry["command"] === process.execPath && Array.isArray(args) && args.length === 2 && typeof args[0] === "string" && path11.basename(args[0]).toLowerCase() === "token-goat.mjs" && args[1] === "mcp-serve";
+}
+function installCursor(opts = {}) {
+  return withInstallScope(projectScopeRoot(opts), () => installCursorScoped(opts));
+}
+function installCursorScoped(opts) {
+  const scope = opts.project === true ? "project" : "user";
+  const mcpPath = cursorMcpPath(opts);
+  const config = readServersJson(mcpPath, "Cursor");
+  const current = serversOf(config, mcpPath, "Cursor", MCP_SERVERS_KEY)[TOKEN_GOAT_ENTRY_KEY];
+  if (current !== void 0 && !isCursorManagedServer(current)) {
+    throw new Error(`Cursor mcp.json already has a ${echoedValue(TOKEN_GOAT_ENTRY_KEY)} MCP server entry token-goat did not write, at ${mcpPath}; remove it manually first`);
+  }
+  const desired = cursorManagedServer();
+  const nextText = setTokenGoatServer(config.text, desired, MCP_SERVERS_KEY);
+  const alreadyInstalled = config.text === nextText;
+  if (!alreadyInstalled) {
+    recordCreatedBy([mcpPath], () => {
+      ensureDirSync(path11.dirname(mcpPath));
+      backupFile(mcpPath);
+      writeConfigText(mcpPath, nextText);
+      noteRootKeyCreation(mcpPath, config, MCP_SERVERS_KEY);
+    });
+  }
+  return { mcpPath, alreadyInstalled, scope };
+}
+function uninstallCursor(opts = {}) {
+  return withInstallScope(projectScopeRoot(opts), () => uninstallCursorScoped(opts));
+}
+function uninstallCursorScoped(opts) {
+  const mcpPath = cursorMcpPath(opts);
+  if (!fs11.existsSync(mcpPath)) return false;
+  const config = readServersJson(mcpPath, "Cursor");
+  if (!isCursorManagedServer(serversOf(config, mcpPath, "Cursor", MCP_SERVERS_KEY)[TOKEN_GOAT_ENTRY_KEY])) return false;
+  const next = dropEmptyServers(setTokenGoatServer(config.text, void 0, MCP_SERVERS_KEY), mcpPath, MCP_SERVERS_KEY);
+  if (/^\s*\{\s*\}\s*$/.test(next) && takeCreatedConfig(mcpPath)) {
+    removeFileInScope(mcpPath);
+  } else {
+    backupFile(mcpPath);
+    writeConfigText(mcpPath, next);
+  }
+  removeCreatedBackups(mcpPath);
+  removeCreatedTree([mcpPath]);
+  return true;
+}
+function isCursorInstalled(opts = {}) {
+  return hasManagedServer(cursorMcpPath(opts), "Cursor", MCP_SERVERS_KEY, isCursorManagedServer);
+}
+function cursorManagedEntry(mcpPath) {
+  const entry = managedServerEntry(mcpPath, "Cursor", MCP_SERVERS_KEY, isCursorManagedServer);
+  return entry === null ? null : { command: entry["command"] };
+}
+
+// src/bridges/zed_install.ts
+init_define_import_meta_env();
+import * as fs12 from "node:fs";
+import * as os11 from "node:os";
+import * as path12 from "node:path";
+var CONTEXT_SERVERS_KEY = "context_servers";
+var TOKEN_GOAT_ENTRY_KEY2 = "token-goat";
+var ZED_TIMEOUT_MS = 3e4;
+function zedConfigDir() {
+  if (process.platform === "win32") {
+    const appData = process.env["APPDATA"];
+    const base2 = appData !== void 0 && appData.trim() !== "" ? appData : path12.join(os11.homedir(), "AppData", "Roaming");
+    return path12.join(base2, "Zed");
+  }
+  const xdgConfig = process.env["XDG_CONFIG_HOME"];
+  const base = xdgConfig !== void 0 && xdgConfig.trim() !== "" ? xdgConfig : path12.join(os11.homedir(), ".config");
+  return path12.join(base, "zed");
+}
+function zedSettingsPath() {
+  return path12.join(zedConfigDir(), "settings.json");
+}
+function zedShimPath() {
+  return path12.join(zedConfigDir(), process.platform === "win32" ? "token-goat-mcp.cmd" : "token-goat-mcp.sh");
+}
+function buildShimScript() {
+  const nodePath = process.execPath;
+  const cliPath = bundledCliPath();
+  if (process.platform === "win32") {
+    return `@echo off\r
+"${nodePath}" "${cliPath}" mcp-serve\r
+`;
+  }
+  return `#!/bin/sh
+exec "${nodePath}" "${cliPath}" mcp-serve
+`;
+}
+function zedManagedServer() {
+  return { command: zedShimPath(), timeout: ZED_TIMEOUT_MS };
+}
+function isZedManagedServer(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const entry = value;
+  return entry["command"] === zedShimPath() && typeof entry["timeout"] === "number";
+}
+function installZed() {
+  return recordCreatedBy([zedSettingsPath(), zedShimPath()], installZedFiles);
+}
+function installZedFiles() {
+  const settingsPath = zedSettingsPath();
+  const shimPath2 = zedShimPath();
+  const config = readServersJson(settingsPath, "Zed");
+  const current = serversOf(config, settingsPath, "Zed", CONTEXT_SERVERS_KEY)[TOKEN_GOAT_ENTRY_KEY2];
+  if (current !== void 0 && !isZedManagedServer(current)) {
+    throw new Error(`Zed settings.json already has a ${echoedValue(TOKEN_GOAT_ENTRY_KEY2)} context server entry token-goat did not write, at ${settingsPath}; remove it manually first`);
+  }
+  const priorShim = snapshotShim(shimPath2);
+  const shimChanged = writeIfDifferent(shimPath2, buildShimScript());
+  if (process.platform !== "win32") fs12.chmodSync(shimPath2, 493);
+  const desired = zedManagedServer();
+  const alreadyInstalled = current !== void 0 && !shimChanged;
+  if (!alreadyInstalled) {
+    try {
+      const nextText = setTokenGoatServer(config.text, desired, CONTEXT_SERVERS_KEY);
+      backupFile(settingsPath);
+      writeConfigText(settingsPath, nextText);
+    } catch (err) {
+      try {
+        restoreShim(shimPath2, priorShim, shimChanged);
+      } catch {
+      }
+      throw err;
+    }
+    noteRootKeyCreation(settingsPath, config, CONTEXT_SERVERS_KEY);
+  }
+  return { settingsPath, shimPath: shimPath2, alreadyInstalled };
+}
+function snapshotShim(shimPath2) {
+  let mode;
+  try {
+    mode = fs12.statSync(shimPath2).mode & 511;
+  } catch (err) {
+    if (err.code === "ENOENT") return { existed: false, bytes: void 0, mode: void 0 };
+  }
+  let bytes;
+  try {
+    bytes = fs12.readFileSync(shimPath2);
+  } catch {
+    bytes = void 0;
+  }
+  return { existed: true, bytes, mode };
+}
+function restoreShim(shimPath2, prior, shimChanged) {
+  if (!prior.existed) {
+    fs12.rmSync(shimPath2, { force: true });
+    return;
+  }
+  if (shimChanged && prior.bytes !== void 0) atomicWriteBytes(shimPath2, prior.bytes);
+  if (prior.mode !== void 0 && process.platform !== "win32") fs12.chmodSync(shimPath2, prior.mode);
+}
+function uninstallZed() {
+  const settingsPath = zedSettingsPath();
+  const shimPath2 = zedShimPath();
+  let entryRemoved = false;
+  let shimRemoved;
+  try {
+    if (fs12.existsSync(settingsPath)) {
+      const config = readServersJson(settingsPath, "Zed");
+      if (isZedManagedServer(serversOf(config, settingsPath, "Zed", CONTEXT_SERVERS_KEY)[TOKEN_GOAT_ENTRY_KEY2])) {
+        const next = dropEmptyServers(setTokenGoatServer(config.text, void 0, CONTEXT_SERVERS_KEY), settingsPath, CONTEXT_SERVERS_KEY);
+        if (/^\s*\{\s*\}\s*$/.test(next) && takeCreatedConfig(settingsPath)) {
+          fs12.rmSync(settingsPath, { force: true });
+        } else {
+          backupFile(settingsPath);
+          writeConfigText(settingsPath, next);
+        }
+        removeCreatedBackups(settingsPath);
+        entryRemoved = true;
+      }
+    }
+  } finally {
+    shimRemoved = fs12.existsSync(shimPath2);
+    if (shimRemoved) fs12.rmSync(shimPath2, { force: true });
+    removeCreatedTree([settingsPath, shimPath2]);
+  }
+  return entryRemoved || shimRemoved;
+}
+function isZedInstalled() {
+  return hasManagedServer(zedSettingsPath(), "Zed", CONTEXT_SERVERS_KEY, isZedManagedServer);
+}
+function zedManagedEntry(settingsPath) {
+  const entry = managedServerEntry(settingsPath, "Zed", CONTEXT_SERVERS_KEY, isZedManagedServer);
+  return entry === null ? null : { command: entry["command"] };
+}
+
+// src/cli_doctor_platforms.ts
+function globalMcpConfigPath() {
+  return copilotMcpConfigPath();
+}
+function checkGlobalMcpConfig(configPath = globalMcpConfigPath()) {
+  if (!fs13.existsSync(configPath)) {
+    return { name: "Global MCP configuration", status: "ok", message: `no global Copilot MCP configuration found at ${displaySafeText(configPath)}` };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stripBom(fs13.readFileSync(configPath, "utf8")));
+  } catch {
+    return {
+      name: "Global MCP configuration",
+      status: "warn",
+      message: `could not read global Copilot MCP configuration at ${displaySafeText(configPath)}; unable to audit heavy launchers.`
+    };
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return {
+      name: "Global MCP configuration",
+      status: "warn",
+      message: `global Copilot MCP configuration at ${displaySafeText(configPath)} has an unsupported format; unable to audit heavy launchers.`
+    };
+  }
+  const configuredServers = parsed["mcpServers"];
+  if (typeof configuredServers !== "object" || configuredServers === null || Array.isArray(configuredServers)) {
+    return { name: "Global MCP configuration", status: "ok", message: `no global stdio MCP servers configured at ${displaySafeText(configPath)}` };
+  }
+  let chromeDevTools = 0;
+  let playwright = 0;
+  for (const server of Object.values(configuredServers)) {
+    if (typeof server !== "object" || server === null || Array.isArray(server)) continue;
+    const entry = server;
+    const rawCommand = entry["command"];
+    const command = typeof rawCommand === "string" ? rawCommand : "";
+    const args = entry["args"];
+    if (!/\bnpx(?:\.cmd)?\b/i.test(command) || !Array.isArray(args)) continue;
+    const invocation = args.filter((arg) => typeof arg === "string").join(" ");
+    if (/\bchrome-devtools-mcp\b/i.test(invocation)) chromeDevTools += 1;
+    if (/@playwright[\\/]mcp\b/i.test(invocation)) playwright += 1;
+  }
+  if (chromeDevTools > 0 || playwright > 0) {
+    const launchers = [];
+    if (chromeDevTools > 0) launchers.push(`${chromeDevTools} Chrome DevTools MCP launcher${chromeDevTools === 1 ? "" : "s"}`);
+    if (playwright > 0) launchers.push(`${playwright} Playwright MCP launcher${playwright === 1 ? "" : "s"}`);
+    return {
+      name: "Global MCP configuration",
+      status: "warn",
+      message: `${launchers.join(" and ")} configured at ${displaySafeText(configPath)}. Move heavy launchers to project scope or remove them when not actively needed.`
+    };
+  }
+  return { name: "Global MCP configuration", status: "ok", message: `no known heavy global MCP launchers configured at ${displaySafeText(configPath)}` };
+}
+var VSCODE_USER_SCOPE_MIGRATED_NOTE = "Moved the VS Code integration from user scope to this project. It used to live in ~/.copilot/hooks, where VS Code resolves its working directory to the FIRST folder of a multi-root workspace and nothing else, so read hints, image shrinking and edit interception were silently doing nothing for every other folder. The shared ~/.copilot/hooks files stay in place if `token-goat install --copilot` still needs them.";
+var VSCODE_PROJECT_SCOPE_COVERAGE_NOTE = "This covers this project only. Run `token-goat install --vscode` once in each project you want it in, or `token-goat install --vscode --user` for one install covering every project (single-root workspaces only \u2014 see below).";
+var VSCODE_USER_SCOPE_MULTIROOT_NOTE = "NOTE: a user-scope install works in every project, but VS Code runs it with the first folder of a multi-root workspace as its working directory, so it does nothing for the other folders. Use `token-goat install --vscode` (project scope, the default) in each folder that needs it.";
+function checkVscodeUserScopeHooks(userScope, projectScope) {
+  if (!userScope) return null;
+  return {
+    name: "VS Code hooks scope",
+    status: "warn",
+    message: projectScope ? "token-goat VS Code hooks are installed in BOTH ~/.copilot/hooks and this project's .github/hooks, and VS Code runs every hooks file it finds, so each hook fires twice. The user-scope copy is also pinned to the first folder of a multi-root workspace. Run `token-goat uninstall --vscode --user` to keep only the project install." : "token-goat VS Code hooks are installed in user scope (~/.copilot/hooks). VS Code runs them with the FIRST folder of a multi-root workspace as their working directory, so read hints, image shrinking and edit interception do nothing for any other folder. Run `token-goat install --vscode` in each project to move it to project scope."
+  };
+}
+var VSCODE_DOUBLE_FIRE_NOTE = 'NOTE: VS Code has chat.useClaudeHooks turned on, so it also runs the token-goat hooks in ~/.claude/settings.json and each one fires twice. token-goat left it alone because it is a user-wide VS Code setting, and turning it off also stops every other Claude hook you have in VS Code. If you see hooks run twice, set "chat.useClaudeHooks": false in your VS Code user settings.';
+var VSCODE_CLAUDE_HOOKS_TURNED_OFF_TEXT = "Turned off chat.useClaudeHooks in your VS Code user settings so token-goat hooks do not run twice. That setting covers every Claude hook in VS Code, not only the token-goat ones. To turn it back on, set " + fencedCommand('"chat.useClaudeHooks": true') + " in VS Code settings, or run " + fencedCommand("token-goat uninstall --vscode --user") + " to put it back.";
+var VSCODE_CLAUDE_HOOKS_TURNED_OFF_NOTE = `NOTE: ${VSCODE_CLAUDE_HOOKS_TURNED_OFF_TEXT}`;
+var VSCODE_CLAUDE_HOOKS_RESTORED_NOTE = "Turned chat.useClaudeHooks back on in your VS Code user settings, as it was before token-goat turned it off.";
+function checkVscodeClaudeHooks(useClaudeHooks, claudeHooksInstalled, vscodeHooks) {
+  if (!useClaudeHooks || !claudeHooksInstalled) return null;
+  const vscodeHooksInstalled2 = vscodeHooks.user || vscodeHooks.project;
+  if (vscodeHooks.project && !vscodeHooks.user) {
+    return {
+      name: "VS Code hooks",
+      status: "ok",
+      message: `VS Code has chat.useClaudeHooks on and token-goat hooks are in both ~/.claude/settings.json and this project's .github/hooks, so each hook fires twice in VS Code. token-goat leaves the setting alone for a project-scope install because it is user-wide and also stops every other Claude hook you have in VS Code. If you see hooks run twice, set "chat.useClaudeHooks": false in your VS Code user settings.`
+    };
+  }
+  return {
+    name: "VS Code hooks",
+    status: "warn",
+    message: vscodeHooksInstalled2 ? "VS Code has chat.useClaudeHooks on and token-goat hooks are in both ~/.claude/settings.json and the Copilot hooks file, so each hook fires twice in VS Code. Turn chat.useClaudeHooks off in VS Code settings, or run `token-goat doctor --repair` to do it." : "VS Code has chat.useClaudeHooks on, so it runs the token-goat hooks from ~/.claude/settings.json in Claude Code wire format, which VS Code reads only in part. Run `token-goat install --vscode` and turn chat.useClaudeHooks off in VS Code settings."
+  };
+}
+function checkClaudeHookEvents(gaps) {
+  const name = "Claude Code hook events";
+  if (gaps.user === null && gaps.project === null) return null;
+  const scopes = [
+    { scope: "user", events: gaps.user, run: "token-goat install" },
+    { scope: "project", events: gaps.project, run: "token-goat install --project" }
+  ];
+  const missing = [];
+  const outdated = [];
+  const broken = [];
+  for (const { scope, events, run } of scopes) {
+    if (events === null) continue;
+    if (events.broken.length > 0) broken.push(`${scope} scope wires ${events.broken.join(", ")} to a native hook client binary that no longer exists; run: ${run}`);
+    if (events.missing.length > 0) missing.push(`${scope} scope lacks ${events.missing.join(", ")}; run: ${run}`);
+    if (events.outdated.length > 0) outdated.push(`${scope} scope wires ${events.outdated.join(", ")} to a token-goat hook command this build no longer writes; run: ${run}`);
+  }
+  if (broken.length === 0 && missing.length === 0 && outdated.length === 0) return { name, status: "ok", message: "every event this build handles is wired" };
+  const sentences = [];
+  if (broken.length > 0) sentences.push(`${broken.join(". ")}. Claude Code cannot start those hooks, so each of those events reports a hook error until then`);
+  if (missing.length > 0) sentences.push(`${missing.join(". ")}. Those events never reach token-goat until then`);
+  if (outdated.length > 0) sentences.push(`${outdated.join(". ")}. Those events still reach token-goat through the older command until the install rewrites it`);
+  return { name, status: broken.length > 0 ? "fail" : "warn", message: `${sentences.join(". ")}; restart any running session afterwards.` };
+}
+function dedupeByResolvedPath(paths) {
+  const seen = /* @__PURE__ */ new Set();
+  return paths.filter((p) => {
+    const key = normalizePath(path13.resolve(p)).toLowerCase();
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function checkVisualStudio(mcpPaths, alsoReadPaths = []) {
+  const found = dedupeByResolvedPath(mcpPaths).flatMap((mcpPath) => {
+    const entry = visualStudioManagedEntry(mcpPath);
+    return entry === null ? [] : [{ mcpPath, ...entry }];
+  });
+  if (found.length === 0) return null;
+  const stale = found.find((e) => !fs13.existsSync(e.command) || !fs13.existsSync(e.bundlePath));
+  if (stale !== void 0) {
+    return {
+      name: "Visual Studio",
+      status: "warn",
+      message: `the token-goat MCP entry in ${displaySafeText(stale.mcpPath)} points at ${displaySafeText(stale.command)} ${displaySafeText(stale.bundlePath)}, which no longer exists; run ${fencedCommand("token-goat uninstall --visualstudio")} and then ${fencedCommand("token-goat install --visualstudio")} again (add -p for the project entry).`
+    };
+  }
+  const registered = dedupeByResolvedPath([...found.map((e) => e.mcpPath), ...alsoReadPaths.filter((p) => visualStudioManagedEntry(p) !== null)]);
+  if (registered.length > 1) {
+    return {
+      name: "Visual Studio",
+      status: "warn",
+      message: `Visual Studio reads ${registered.map(displaySafeText).join(" and ")}, and each registers token-goat, so it lists the token-goat server more than once. Keep one: ${fencedCommand("token-goat uninstall --vscode -p")} drops the .vscode/mcp.json entry, ${fencedCommand("token-goat uninstall --visualstudio")} (add -p for the project entry) drops a Visual Studio one.`
+    };
+  }
+  return {
+    name: "Visual Studio",
+    status: "ok",
+    message: `MCP server registered in ${found.map((e) => displaySafeText(e.mcpPath)).join(", ")}. Visual Studio runs no token-goat hooks: it gets the MCP tools and instructions only, and only once the token-goat tools are ticked in the chat Tools picker.`
+  };
+}
+function checkZed(settingsPath) {
+  const entry = zedManagedEntry(settingsPath);
+  if (entry === null) return null;
+  const shimPath2 = entry.command;
+  if (!fs13.existsSync(shimPath2)) {
+    return {
+      name: "Zed",
+      status: "warn",
+      message: `the token-goat MCP entry in ${displaySafeText(settingsPath)} points at ${displaySafeText(shimPath2)}, which no longer exists; run \`token-goat uninstall --zed\` and then \`token-goat install --zed\` again.`
+    };
+  }
+  const script = fs13.readFileSync(shimPath2, "utf8");
+  const referencedPaths = [...script.matchAll(/"([^"]+)"/g)].map((m) => m[1]).filter((p) => typeof p === "string" && p.length > 0);
+  const stalePath = referencedPaths.find((p) => !fs13.existsSync(p));
+  if (stalePath !== void 0) {
+    return {
+      name: "Zed",
+      status: "warn",
+      message: `the token-goat shim at ${displaySafeText(shimPath2)} points at ${displaySafeText(stalePath)}, which no longer exists; run \`token-goat uninstall --zed\` and then \`token-goat install --zed\` again.`
+    };
+  }
+  return {
+    name: "Zed",
+    status: "ok",
+    message: `MCP context server registered in ${displaySafeText(settingsPath)}. Zed runs no token-goat hooks: it gets the MCP tools only, and only once the token-goat server is enabled in Zed's Agent panel.`
+  };
+}
+function checkCursor(mcpPath, claudeHooksInstalled) {
+  const entry = cursorManagedEntry(mcpPath);
+  if (entry === null) return null;
+  return {
+    name: "Cursor",
+    status: "ok",
+    message: claudeHooksInstalled ? `MCP server registered in ${displaySafeText(mcpPath)}. Cursor also imports the token-goat hooks already installed in ~/.claude/settings.json by default, so hooks work in Cursor too with no separate hooks.json entry.` : `MCP server registered in ${displaySafeText(mcpPath)}. Cursor writes and runs no token-goat hooks here: it imports Claude Code hooks from ~/.claude/settings.json by default, but none are installed there yet -- run \`token-goat install\` to get hooks in Cursor too.`
+  };
+}
+function checkStrayClaudeMdBlocks(searchRoot) {
+  const strays = findStrayClaudeMdBlocks(searchRoot);
+  if (strays.length === 0) {
+    return { name: "CLAUDE.md block", status: "ok", message: "no stray copies outside CLAUDE.md" };
+  }
+  return {
+    name: "CLAUDE.md block",
+    status: "warn",
+    message: `${strays.length} stray cop${strays.length === 1 ? "y" : "ies"} outside CLAUDE.md (never refreshed by install, never removed by uninstall, will go stale): ${strays.join(", ")}`
+  };
+}
+function checkVscodeProjectMcp(projectRoot = process.cwd()) {
+  const mcpPath = path13.join(path13.resolve(projectRoot), ".vscode", "mcp.json");
+  if (!fs13.existsSync(mcpPath)) return null;
+  if (hasManagedServer(mcpPath, "VS Code")) return null;
+  try {
+    const content = fs13.readFileSync(mcpPath, "utf8");
+    if (isResidueServersJson(content)) {
+      return {
+        name: "VS Code project MCP",
+        status: "warn",
+        message: `empty residue file at ${displaySafeText(mcpPath)} triggers Copilot CLI deprecation warnings; delete it or run \`token-goat uninstall --vscode\``
+      };
+    }
+    return {
+      name: "VS Code project MCP",
+      status: "warn",
+      message: `${displaySafeText(mcpPath)} is deprecated by Copilot CLI v1.0.84+; migrate configured servers to .mcp.json or .github/mcp.json (https://gh.io/copilotcli-mcpmigrate)`
+    };
+  } catch {
+    return null;
+  }
+}
+function checkClaudeHooksGone(wired, activity) {
+  if (wired || activity === null || activity.count === 0 || activity.lastTs === null) return null;
+  if (activity.uninstalledTs !== null && activity.uninstalledTs >= activity.lastTs) return null;
+  const last = new Date(activity.lastTs * 1e3).toISOString().replace("T", " ").slice(0, 16);
+  return {
+    name: "Claude Code hooks",
+    status: "warn",
+    message: `Claude Code ran ${countNoun(activity.count, "token-goat hook")} in the last 7 days, the last at ${last} UTC, but no token-goat hook is wired in ~/.claude/settings.json or this project's .claude/settings.json now, and no uninstall was recorded. The file was probably overwritten or deleted. Run: token-goat install (or token-goat install --project), then restart any running session.`
+  };
+}
+
 export {
   installGemini,
   uninstallGemini,
@@ -2224,5 +2945,41 @@ export {
   isGrokInstalled,
   installAntigravity,
   uninstallAntigravity,
-  isAntigravityInstalled
+  isAntigravityInstalled,
+  vscodeScopeFromFlags,
+  vscodeHooksInstalled,
+  vscodeUsesClaudeHooks,
+  vscodeRunsTokenGoatClaudeHooks,
+  disableVscodeClaudeHooks,
+  restoreVscodeClaudeHooks,
+  otherScopeHasManagedServer,
+  vscodeDecoderConfigured,
+  installVscode,
+  uninstallVscode,
+  cleanupDeprecatedVscodeProjectMcp,
+  cursorMcpPath,
+  installCursor,
+  uninstallCursor,
+  isCursorInstalled,
+  zedSettingsPath,
+  installZed,
+  uninstallZed,
+  isZedInstalled,
+  checkGlobalMcpConfig,
+  VSCODE_USER_SCOPE_MIGRATED_NOTE,
+  VSCODE_PROJECT_SCOPE_COVERAGE_NOTE,
+  VSCODE_USER_SCOPE_MULTIROOT_NOTE,
+  checkVscodeUserScopeHooks,
+  VSCODE_DOUBLE_FIRE_NOTE,
+  VSCODE_CLAUDE_HOOKS_TURNED_OFF_TEXT,
+  VSCODE_CLAUDE_HOOKS_TURNED_OFF_NOTE,
+  VSCODE_CLAUDE_HOOKS_RESTORED_NOTE,
+  checkVscodeClaudeHooks,
+  checkClaudeHookEvents,
+  checkVisualStudio,
+  checkZed,
+  checkCursor,
+  checkStrayClaudeMdBlocks,
+  checkVscodeProjectMcp,
+  checkClaudeHooksGone
 };