token-goat 2.9.29 → 2.9.31

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

@@ -0,0 +1,2985 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  HookCommandRewriteError,
+  LEGACY_SHIM_FILE,
+  MATERIALIZE_SHRUNK_IMAGE_JS,
+  SHIM_FILE,
+  SHIM_MAX_BUFFER_CONST,
+  SHIM_REQUIRES,
+  SHIM_SPAWN_LADDER,
+  SHIM_TRY_IN_PROCESS,
+  SHIM_TRY_SERVER,
+  SHIM_VALID_HOOK_EVENTS,
+  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,
+  syncVisualStudioProjectGuidance,
+  visualStudioManagedEntry
+} from "./token-goat-chunk-7MAOA6X4.mjs";
+import {
+  parseJsonOrJsonc,
+  stripBom
+} from "./token-goat-chunk-QQTWJY2O.mjs";
+import {
+  readCopilotHooksOwners
+} from "./token-goat-chunk-G5PJ7AGM.mjs";
+import {
+  toolMatcherFor
+} from "./token-goat-chunk-C75NA7PL.mjs";
+import {
+  GEMINI_TOOL_NAME_MAP
+} from "./token-goat-chunk-76FGDLRO.mjs";
+import {
+  loadConfig,
+  parse,
+  stringify
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import {
+  assertProjectScopeTarget,
+  atomicWriteBytes,
+  atomicWriteText,
+  backupFile,
+  countNoun,
+  ensureDirRecordingCreation,
+  ensureDirSync,
+  extractErrorMessage,
+  hasCreatedConfig,
+  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-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";
+
+// src/bridges/gemini_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/commented_settings.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path from "node:path";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function applyDiff(text, prev, next, at) {
+  let out = text;
+  for (const key of Object.keys(prev)) {
+    if (!(key in next)) out = editAt(out, [...at, key], void 0);
+  }
+  for (const key of Object.keys(next)) {
+    const before = prev[key];
+    const after = next[key];
+    if (after === void 0) {
+      if (key in prev) out = editAt(out, [...at, key], void 0);
+    } else if (!(key in prev)) out = editAt(out, [...at, key], after);
+    else if (isPlainObject(before) && isPlainObject(after)) out = applyDiff(out, before, after, [...at, key]);
+    else if (JSON.stringify(before) !== JSON.stringify(after)) out = editAt(out, [...at, key], after);
+  }
+  return out;
+}
+function writeSettingsKeepingComments(p, next, opts = {}) {
+  let raw;
+  try {
+    raw = fs.readFileSync(p, "utf8");
+  } catch {
+    raw = void 0;
+  }
+  if (raw === void 0 || !isPlainObject(next)) return writeJsonSettings(p, next);
+  try {
+    JSON.parse(raw);
+    return writeJsonSettings(p, next);
+  } catch {
+  }
+  const body = stripBom(raw);
+  let prev;
+  try {
+    prev = parseJsonOrJsonc(body, opts);
+  } catch {
+    return writeJsonSettings(p, next);
+  }
+  if (!isPlainObject(prev)) return writeJsonSettings(p, next);
+  const edited = applyDiff(body, prev, next, []);
+  ensureDirSync(path.dirname(p));
+  backupFile(p);
+  writeConfigText(p, edited.endsWith("\n") ? edited : `${edited}
+`);
+}
+
+// src/bridges/gemini_install.ts
+var GEMINI_LEGACY_COMMAND_MARKER = "token-goat hook";
+var GEMINI_HOOK_EVENTS = ["BeforeTool", "AfterTool", "PreCompress"];
+var GEMINI_EVENT_ARG = {
+  BeforeTool: "pre_tool_use",
+  AfterTool: "post_tool_use",
+  PreCompress: "pre_compact"
+};
+function registeredInternalTools(eventName) {
+  const matcher = toolMatcherFor(eventName);
+  const names = /* @__PURE__ */ new Set();
+  if (matcher === null) return names;
+  for (const part of matcher.split("|")) {
+    const match = /^\^([A-Za-z]+)\$$/.exec(part);
+    if (match?.[1] !== void 0) names.add(match[1]);
+  }
+  return names;
+}
+var GeminiSettingsParseError = class extends Error {
+};
+function geminiSettingsPath() {
+  return path2.join(os.homedir(), ".gemini", "settings.json");
+}
+function readGeminiSettings(p, opts = {}) {
+  const refuse = (problem, detail) => new GeminiSettingsParseError(
+    (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 {
+    raw = fs2.readFileSync(p, "utf8");
+  } catch (e) {
+    const code = e.code;
+    if (opts.strict === true && code !== "ENOENT" && code !== "ENOTDIR") throw refuse("exists but cannot be read", code ?? extractErrorMessage(e));
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = parseJsonOrJsonc(raw, { allowTrailingComma: false });
+  } catch (e) {
+    if (opts.strict === true) throw refuse("exists but contains invalid JSON", extractErrorMessage(e));
+    return {};
+  }
+  if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+    return parsed;
+  }
+  if (opts.strict === true) throw refuse("does not contain a JSON object at the top level");
+  return {};
+}
+var GEMINI_LEGACY_MARKER_PATTERN = anchoredMarkerPattern(GEMINI_LEGACY_COMMAND_MARKER);
+var GEMINI_COMMAND_PATTERN = /^"[^"]+"\s+"([^"]+)"\s+hook\s+(?:pre_tool_use|post_tool_use|pre_compact)$/;
+var GEMINI_ENTRY_PATH_MARKER_PATTERN = anchoredMarkerPattern("token-goat");
+function isGeminiTokenGoatCommand(command) {
+  if (typeof command !== "string") return false;
+  const match = GEMINI_COMMAND_PATTERN.exec(command);
+  if (match) {
+    const entryPath = match[1] ?? "";
+    return GEMINI_ENTRY_PATH_MARKER_PATTERN.test(entryPath);
+  }
+  return GEMINI_LEGACY_MARKER_PATTERN.test(command);
+}
+function isCurrentGeminiTokenGoatCommand(command, desiredCommand) {
+  if (typeof command !== "string") return false;
+  return command === desiredCommand;
+}
+function geminiHookCommand(eventArg) {
+  const entryPath = process.argv[1];
+  if (!entryPath) return `token-goat hook ${eventArg}`;
+  return `${quoteShellPath(process.execPath)} ${quoteShellPath(entryPath)} hook ${eventArg}`;
+}
+function geminiNamesByInternalTool() {
+  const out = /* @__PURE__ */ new Map();
+  for (const [geminiName, internalTool] of Object.entries(GEMINI_TOOL_NAME_MAP)) {
+    const list = out.get(internalTool);
+    if (list) {
+      list.push(geminiName);
+    } else {
+      out.set(internalTool, [geminiName]);
+    }
+  }
+  return out;
+}
+function desiredMatchersFor(event) {
+  if (event === "PreCompress") return [void 0];
+  const toolSet = registeredInternalTools(GEMINI_EVENT_ARG[event]);
+  const matchers = [];
+  for (const [internalTool, names] of geminiNamesByInternalTool()) {
+    if (!toolSet.has(internalTool)) continue;
+    matchers.push(`^(${names.join("|")})$`);
+  }
+  return matchers;
+}
+function installGemini() {
+  const p = geminiSettingsPath();
+  const settings = readGeminiSettings(p, { strict: true });
+  const hooks = settings.hooks ?? {};
+  let changed = false;
+  for (const event of GEMINI_HOOK_EVENTS) {
+    const command = geminiHookCommand(GEMINI_EVENT_ARG[event]);
+    const groups = Array.isArray(hooks[event]) ? [...hooks[event]] : [];
+    for (const matcher of desiredMatchersFor(event)) {
+      if (groupHasTokenGoat(groups, matcher, (c) => isCurrentGeminiTokenGoatCommand(c, command))) continue;
+      const nextGroups = stripStaleGroupHooks(groups, isGeminiTokenGoatCommand, { matcher });
+      groups.length = 0;
+      groups.push(...nextGroups);
+      const group = matcher === void 0 ? { hooks: [{ type: "command", command }] } : { matcher, hooks: [{ type: "command", command }] };
+      groups.push(group);
+      changed = true;
+    }
+    hooks[event] = groups;
+  }
+  if (!changed) {
+    return { settingsPath: p, alreadyInstalled: true };
+  }
+  settings.hooks = hooks;
+  recordCreatedBy([p], () => writeSettingsKeepingComments(p, settings, { allowTrailingComma: false }));
+  return { settingsPath: p, alreadyInstalled: false };
+}
+function uninstallGemini() {
+  const p = geminiSettingsPath();
+  const settings = readGeminiSettings(p, { strict: true, command: "uninstall" });
+  const removed = settings.hooks !== void 0 && stripOwnHooksFromMap(settings.hooks, isGeminiTokenGoatCommand);
+  const result = finishHookUninstall(p, settings, removed, (file, next) => writeSettingsKeepingComments(file, next, { allowTrailingComma: false }));
+  removeCreatedTree([p]);
+  return result;
+}
+function isGeminiInstalled() {
+  const settings = readGeminiSettings(geminiSettingsPath());
+  const hooks = settings.hooks;
+  if (hooks === void 0) return false;
+  for (const event of GEMINI_HOOK_EVENTS) {
+    const command = geminiHookCommand(GEMINI_EVENT_ARG[event]);
+    for (const matcher of desiredMatchersFor(event)) {
+      if (!groupHasTokenGoat(hooks[event], matcher, (c) => isCurrentGeminiTokenGoatCommand(c, command))) return false;
+    }
+  }
+  return true;
+}
+
+// src/bridges/qwen_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";
+var QWEN_HOOK_EVENTS = ["PreToolUse", "PostToolUse", "PreCompact", "UserPromptSubmit", "SubagentStop"];
+var QWEN_EVENT_ARG = {
+  PreToolUse: "pre_tool_use",
+  PostToolUse: "post_tool_use",
+  PreCompact: "pre_compact",
+  UserPromptSubmit: "user_prompt_submit",
+  SubagentStop: "subagent_stop"
+};
+var QwenSettingsParseError = class extends Error {
+};
+function qwenSettingsPath() {
+  return path3.join(os2.homedir(), ".qwen", "settings.json");
+}
+function readQwenSettings(p, opts = {}) {
+  const refuse = (problem, detail) => new QwenSettingsParseError(
+    (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 {
+    raw = fs3.readFileSync(p, "utf8");
+  } catch (e) {
+    const code = e.code;
+    if (opts.strict === true && code !== "ENOENT" && code !== "ENOTDIR") throw refuse("exists but cannot be read", code ?? extractErrorMessage(e));
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = parseJsonOrJsonc(raw, { allowTrailingComma: false });
+  } catch (e) {
+    if (opts.strict === true) throw refuse("exists but contains invalid JSON", extractErrorMessage(e));
+    return {};
+  }
+  if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+    return parsed;
+  }
+  if (opts.strict === true) throw refuse("does not contain a JSON object at the top level");
+  return {};
+}
+var QWEN_LEGACY_COMMAND_MARKER = "token-goat hook";
+var QWEN_LEGACY_MARKER_PATTERN = anchoredMarkerPattern(QWEN_LEGACY_COMMAND_MARKER);
+var QWEN_COMMAND_PATTERN = /^"[^"]+"\s+"([^"]+)"\s+hook\s+(?:pre_tool_use|post_tool_use|pre_compact|user_prompt_submit|subagent_stop)(?:\s+--harness\s+qwen)?$/;
+var QWEN_ENTRY_PATH_MARKER_PATTERN = anchoredMarkerPattern("token-goat");
+function isQwenTokenGoatCommand(command) {
+  if (typeof command !== "string") return false;
+  const match = QWEN_COMMAND_PATTERN.exec(command);
+  if (match) {
+    const entryPath = match[1] ?? "";
+    return QWEN_ENTRY_PATH_MARKER_PATTERN.test(entryPath);
+  }
+  return QWEN_LEGACY_MARKER_PATTERN.test(command);
+}
+function isCurrentQwenTokenGoatCommand(command, desiredCommand) {
+  if (typeof command !== "string") return false;
+  return command === desiredCommand;
+}
+function qwenHookCommand(eventArg) {
+  const entryPath = process.argv[1];
+  if (!entryPath) return `token-goat hook ${eventArg} --harness qwen`;
+  return `${quoteShellPath(process.execPath)} ${quoteShellPath(entryPath)} hook ${eventArg} --harness qwen`;
+}
+function installQwen() {
+  const p = qwenSettingsPath();
+  const settings = readQwenSettings(p, { strict: true });
+  const hooks = settings.hooks ?? {};
+  let changed = false;
+  for (const event of QWEN_HOOK_EVENTS) {
+    const command = qwenHookCommand(QWEN_EVENT_ARG[event]);
+    const existingGroups = Array.isArray(hooks[event]) ? hooks[event] : [];
+    if (groupHasTokenGoat(existingGroups, "", (c) => isCurrentQwenTokenGoatCommand(c, command))) {
+      hooks[event] = existingGroups;
+      continue;
+    }
+    const groups = stripStaleGroupHooks(existingGroups, isQwenTokenGoatCommand);
+    groups.push({ matcher: "", hooks: [{ type: "command", command }] });
+    hooks[event] = groups;
+    changed = true;
+  }
+  if (!changed) {
+    return { settingsPath: p, alreadyInstalled: true };
+  }
+  settings.hooks = hooks;
+  recordCreatedBy([p], () => writeSettingsKeepingComments(p, settings, { allowTrailingComma: false }));
+  return { settingsPath: p, alreadyInstalled: false };
+}
+function uninstallQwen() {
+  const p = qwenSettingsPath();
+  const settings = readQwenSettings(p, { strict: true, command: "uninstall" });
+  const removed = settings.hooks !== void 0 && stripOwnHooksFromMap(settings.hooks, isQwenTokenGoatCommand);
+  const result = finishHookUninstall(p, settings, removed, (file, next) => writeSettingsKeepingComments(file, next, { allowTrailingComma: false }));
+  removeCreatedTree([p]);
+  return result;
+}
+function isQwenInstalled() {
+  const settings = readQwenSettings(qwenSettingsPath());
+  const hooks = settings.hooks;
+  if (hooks === void 0) return false;
+  for (const event of QWEN_HOOK_EVENTS) {
+    const command = qwenHookCommand(QWEN_EVENT_ARG[event]);
+    if (!groupHasTokenGoat(hooks[event], "", (c) => isCurrentQwenTokenGoatCommand(c, command))) return false;
+  }
+  return true;
+}
+
+// src/bridges/kimi_install.ts
+init_define_import_meta_env();
+import * as fs4 from "node:fs";
+import * as os3 from "node:os";
+import * as path4 from "node:path";
+
+// src/bridges/kimi.ts
+init_define_import_meta_env();
+var KIMI_HOOK_SCRIPT = `#!/usr/bin/env node
+// token-goat Kimi Code hook shim. Forwards the hook payload to \`token-goat hook <event>\`, then rewrites the response into Kimi's own contract: permissionDecision "deny" for a block, top-level "message" for a hint, empty stdout for a no-op.
+'use strict'
+${SHIM_REQUIRES}
+
+${SHIM_VALID_HOOK_EVENTS}
+
+// Kimi Code publishes no ambient per-session env var identifying its own hook
+// subprocesses, so the harness identity has to be injected here for
+// detectHarness() (src/bridges/registry.ts) to resolve 'kimi'.
+process.env.TOKEN_GOAT_HARNESS_OVERRIDE = 'kimi'
+
+// Pull the hint text out of a token-goat response: hookSpecificOutput.additionalContext
+// (most events) or the top-level systemMessage (notification/pre_compact, which Claude
+// Code rejects additionalContext on). Kimi reads neither, so both fold into its 'message'.
+function hintText(parsed) {
+  if (!parsed || typeof parsed !== 'object') return ''
+  const hso = parsed.hookSpecificOutput
+  if (hso && typeof hso === 'object' && typeof hso.additionalContext === 'string') return hso.additionalContext
+  if (typeof parsed.systemMessage === 'string') return parsed.systemMessage
+  return ''
+}
+
+// Translate a token-goat (Claude Code shaped) response into Kimi's contract.
+// Returns '' for anything Kimi cannot act on, which the caller writes as empty
+// stdout rather than '{}' -- see this module's docstring for why that matters
+// on UserPromptSubmit.
+function toKimi(parsed) {
+  if (!parsed || typeof parsed !== 'object') return ''
+  if (parsed.decision === 'block' && typeof parsed.reason === 'string' && parsed.reason) {
+    return JSON.stringify({
+      message: parsed.reason,
+      hookSpecificOutput: { permissionDecision: 'deny', permissionDecisionReason: parsed.reason },
+    })
+  }
+  const hint = hintText(parsed)
+  if (hint) return JSON.stringify({ message: hint })
+  return ''
+}
+
+${SHIM_TRY_SERVER}
+
+${SHIM_TRY_IN_PROCESS}
+
+${SHIM_MAX_BUFFER_CONST}
+${shimFallbackTimeoutConst("kimi")}
+
+async function main() {
+  const eventName = process.argv[2] || ''
+  if (!VALID_HOOK_EVENTS.has(eventName)) return
+  let input = ''
+  try {
+    input = require('node:fs').readFileSync(0, 'utf8')
+  } catch {
+    return
+  }
+  // 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 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]
+  let stdout = await tryInProcess(entryPath, eventName, input)
+  if (stdout === undefined) {
+${SHIM_SPAWN_LADDER}
+      : spawnSync('token-goat hook ' + eventName, {
+          input,
+          encoding: 'utf8',
+          shell: true,
+          timeout: SHIM_FALLBACK_TIMEOUT_MS,
+          killSignal: 'SIGKILL',
+          maxBuffer: SHIM_MAX_BUFFER_BYTES,
+        })
+    if (res.status !== 0 || !res.stdout) return
+    stdout = res.stdout
+  }
+  let parsed
+  try {
+    parsed = JSON.parse(stdout)
+  } catch {
+    return
+  }
+  const out = toKimi(parsed)
+  if (out) process.stdout.write(out)
+}
+
+main().catch(() => {
+  // Fail open: write nothing, exit 0. Kimi treats a silent hook as "allow".
+})
+`;
+
+// src/bridges/kimi_install.ts
+var KIMI_EVENT_ARG = {
+  PreToolUse: "pre_tool_use",
+  PostToolUse: "post_tool_use",
+  PreCompact: "pre_compact",
+  UserPromptSubmit: "user_prompt_submit",
+  SubagentStop: "subagent_stop",
+  SessionStart: "session_start"
+};
+var KIMI_HOOK_EVENTS = Object.keys(KIMI_EVENT_ARG);
+var KimiConfigParseError = class extends Error {
+};
+function kimiHome() {
+  const override = process.env["KIMI_CODE_HOME"];
+  if (override !== void 0 && override.trim() !== "") return path4.resolve(override);
+  return path4.join(os3.homedir(), ".kimi-code");
+}
+function kimiConfigPath() {
+  return path4.join(kimiHome(), "config.toml");
+}
+function kimiAgentsPath() {
+  return path4.join(kimiHome(), "AGENTS.md");
+}
+function kimiHookScriptPath() {
+  return path4.join(kimiHome(), "hooks", SHIM_FILE);
+}
+function kimiLegacyHookScriptPath() {
+  return path4.join(kimiHome(), "hooks", LEGACY_SHIM_FILE);
+}
+function kimiSkillDir() {
+  return path4.join(kimiHome(), "skills", "token-goat");
+}
+function kimiSkillPath() {
+  return path4.join(kimiSkillDir(), "SKILL.md");
+}
+function readKimiConfig(p, opts = {}) {
+  const refuse = (problem, detail) => new KimiConfigParseError(
+    (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 {
+    raw = fs4.readFileSync(p, "utf8");
+  } catch (e) {
+    const code = e.code;
+    if (opts.strict === true && code !== "ENOENT" && code !== "ENOTDIR") throw refuse("exists but cannot be read", code ?? extractErrorMessage(e));
+    return {};
+  }
+  try {
+    return parse(raw);
+  } catch (e) {
+    if (opts.strict === true) throw refuse("exists but contains invalid TOML", extractErrorMessage(e));
+    return {};
+  }
+}
+var KIMI_COMMAND_MARKER = "token-goat";
+var KIMI_MARKER_PATTERN = anchoredMarkerPattern(KIMI_COMMAND_MARKER);
+function isKimiTokenGoatCommand(command) {
+  return typeof command === "string" && KIMI_MARKER_PATTERN.test(command);
+}
+var AGENTS_BEGIN = "<!-- token-goat-kimi-begin -->";
+var AGENTS_END = "<!-- token-goat-kimi-end -->";
+function buildKimiAgentsBlock() {
+  return buildGuidanceBlock({
+    beginMarker: AGENTS_BEGIN,
+    endMarker: AGENTS_END,
+    fallbackToolClause: "Kimi Code's native `Read`, `Grep`, `Glob`, and `ReadMediaFile` tools (shell commands like `cat`/`type` run inside `Bash`)",
+    gdrive: loadConfig().gdrive.enabled
+  });
+}
+function writeKimiAgentsBlock(p) {
+  return upsertDelimitedBlock(p, AGENTS_BEGIN, AGENTS_END, buildKimiAgentsBlock());
+}
+function stripKimiAgentsBlock(p) {
+  return stripDelimitedBlock(p, AGENTS_BEGIN, AGENTS_END);
+}
+function kimiSkillContent() {
+  const gdrive = loadConfig().gdrive.enabled;
+  const frontmatter = [
+    "---",
+    "name: token-goat",
+    skillDescriptionLine(gdrive),
+    "---"
+  ].join("\n");
+  const body = buildGuidanceBody("Kimi Code's own Read, Grep, and Glob preference rules", { gdrive });
+  return `${frontmatter}
+
+${body}
+`;
+}
+function writeKimiSkill() {
+  return writeIfDifferent(kimiSkillPath(), kimiSkillContent(), true);
+}
+function kimiArtifactPaths() {
+  return [kimiConfigPath(), kimiAgentsPath(), kimiSkillPath(), kimiHookScriptPath(), kimiLegacyHookScriptPath()];
+}
+function installKimi() {
+  return recordCreatedBy(kimiArtifactPaths(), installKimiFiles);
+}
+function installKimiFiles() {
+  const configPath = kimiConfigPath();
+  const agentsPath = kimiAgentsPath();
+  const scriptPath = kimiHookScriptPath();
+  const desired = KIMI_HOOK_EVENTS.map((event) => ({
+    event,
+    command: kimiHookCommandFor(scriptPath, KIMI_EVENT_ARG[event] ?? "")
+  }));
+  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 ${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));
+  atomicWriteText(scriptPath, KIMI_HOOK_SCRIPT);
+  atomicWriteText(kimiLegacyHookScriptPath(), legacyShimForwarder(""));
+  const config = readKimiConfig(configPath, { strict: true });
+  const existing = Array.isArray(config.hooks) ? config.hooks : [];
+  const foreign = existing.filter((h) => !isKimiTokenGoatCommand(h?.command));
+  const ours = existing.filter((h) => isKimiTokenGoatCommand(h?.command));
+  const hooksChanged = JSON.stringify(ours) !== JSON.stringify(desired);
+  const agentsChanged = writeKimiAgentsBlock(agentsPath);
+  const skillChanged = writeKimiSkill();
+  if (hooksChanged) {
+    config.hooks = [...foreign, ...desired];
+    ensureDirSync(path4.dirname(configPath));
+    backupFile(configPath);
+    writeConfigText(configPath, stringify(config));
+  }
+  return {
+    configPath,
+    agentsPath,
+    hookScriptPath: scriptPath,
+    skillPath: kimiSkillPath(),
+    alreadyInstalled: !hooksChanged && !agentsChanged && !skillChanged
+  };
+}
+function uninstallKimi() {
+  const configPath = kimiConfigPath();
+  const config = readKimiConfig(configPath, { strict: true, command: "uninstall" });
+  let removed = false;
+  if (Array.isArray(config.hooks)) {
+    const kept = config.hooks.filter((h) => !isKimiTokenGoatCommand(h?.command));
+    if (kept.length !== config.hooks.length) {
+      if (kept.length === 0) {
+        delete config.hooks;
+      } else {
+        config.hooks = kept;
+      }
+      backupFile(configPath);
+      writeConfigText(configPath, stringify(config));
+      removed = true;
+    }
+  }
+  if (stripKimiAgentsBlock(kimiAgentsPath())) removed = true;
+  try {
+    if (fs4.existsSync(kimiSkillDir())) {
+      removeCreatedBackups(kimiSkillPath());
+      fs4.rmSync(kimiSkillDir(), { recursive: true, force: true });
+      removed = true;
+    }
+  } catch {
+  }
+  for (const p of [kimiHookScriptPath(), kimiLegacyHookScriptPath()]) {
+    try {
+      if (fs4.existsSync(p)) {
+        fs4.rmSync(p, { force: true });
+        removed = true;
+      }
+    } catch {
+    }
+  }
+  removeCreatedBackups(configPath);
+  removeCreatedTree(kimiArtifactPaths());
+  return removed;
+}
+function kimiHookCommandFor(scriptPath, eventArg, opts = {}) {
+  const bin = nativeHookBinary(process.argv[1], opts);
+  const native = bin === void 0 ? void 0 : nativeHookCommandLine(process.platform === "win32" ? "cmd" : "sh", bin, "kimi", scriptPath, eventArg);
+  return native ?? hookCommandFor(scriptPath, eventArg);
+}
+function wiredKimiHookWords() {
+  const hooks = readKimiConfig(kimiConfigPath()).hooks;
+  if (!Array.isArray(hooks)) return [];
+  const scriptPath = kimiHookScriptPath();
+  const expected = new Set(KIMI_HOOK_EVENTS.map((e) => kimiHookCommandFor(scriptPath, KIMI_EVENT_ARG[e] ?? "", { sync: false })));
+  return hooks.filter((h) => isKimiTokenGoatCommand(h?.command)).map((h) => ({ words: splitHookCommand(h.command, process.platform === "win32" ? "cmd" : "sh"), current: expected.has(h.command) }));
+}
+function isKimiInstalled() {
+  const config = readKimiConfig(kimiConfigPath());
+  if (!Array.isArray(config.hooks)) return false;
+  const scriptPath = kimiHookScriptPath();
+  for (const event of KIMI_HOOK_EVENTS) {
+    const expected = kimiHookCommandFor(scriptPath, KIMI_EVENT_ARG[event] ?? "", { sync: false });
+    if (!config.hooks.some((h) => h?.event === event && h?.command === expected)) return false;
+  }
+  return true;
+}
+
+// src/bridges/pi_install.ts
+init_define_import_meta_env();
+import * as fs5 from "node:fs";
+import * as os4 from "node:os";
+import * as path5 from "node:path";
+
+// src/bridges/pi.ts
+init_define_import_meta_env();
+var PI_EXTENSION_SCRIPT = `// token-goat bridge extension for pi (pi-coding-agent)
+// Bridges pi's extension events to token-goat's subprocess hook protocol.
+// https://github.com/DFKHelper/token-goat
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { spawnSync } from "node:child_process"
+import crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// pi built-in tool names -> token-goat internal tool names. powershell is pi's Windows shell twin of bash -- same input schema (PowerShellToolInput = BashToolInput, i.e. command/timeout) and registered under its own name (badlogic/pi-mono packages/coding-agent/src/core/tools/powershell.ts + tools/index.ts's ToolName union). Unmapped, every shell command in a powershell-tool pi session bypassed the Bash hooks entirely, the same shape as the Copilot shim's bash/powershell pairing.
+const TOOL_TO_TG: Record<string, string> = {
+  read: "Read",
+  bash: "Bash",
+  powershell: "Bash",
+  edit: "Edit",
+  write: "Write",
+  grep: "Grep",
+  find: "Glob",
+};
+
+// pi tool args (camelCase/short) -> token-goat snake_case tool_input keys
+const ARGS_TO_TG: Record<string, Record<string, string>> = {
+  read: { path: "file_path", offset: "offset", limit: "limit" },
+  bash: { command: "command", timeout: "timeout" },
+  powershell: { command: "command", timeout: "timeout" },
+  edit: { path: "file_path" },
+  write: { path: "file_path" },
+  grep: { pattern: "pattern", path: "path" },
+  find: { pattern: "pattern", path: "path" },
+};
+
+// Tools with a pre-hook whose output shape this extension can act on: deny ({block}), updatedInput (in-place arg rewrite), or the Read image-shrink materialization. Glob's pre handler (preGlobDedupHandler in hooks_glob.ts -- the old claim here that Glob has no pre handler was stale) emits only an advisory contextOutput hint, which pi's tool_call contract has no channel for (see the module docblock), so calling it would cost a hook call per find only to drop the answer; it stays excluded for that reason.
+const PRE_HOOK_TOOLS = new Set(["Read", "Grep", "Bash", "WebFetch"]);
+
+// resolveEntryPath reads a sidecar JSON file (token-goat-entry.json, written by
+// installPi next to this extension file) containing the absolute path to the
+// token-goat CLI entry that was running at install time. Unlike Codex/Copilot,
+// this extension has no per-invocation command line to bake a path into (pi
+// loads it once as a module, then calls into it via pi.on(...) handlers), so
+// the sidecar file is the install-time channel for this value instead. Returns
+// undefined (triggering the PATH-based fallback below) if the sidecar is
+// missing, unreadable, or points at a path that no longer exists -- e.g. an
+// older install predating this file, or a moved/removed token-goat install.
+function resolveEntryPath(): string | undefined {
+  try {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const sidecarPath = path.join(here, "token-goat-entry.json");
+    const parsed = JSON.parse(fs.readFileSync(sidecarPath, "utf8")) as { entryPath?: unknown };
+    if (typeof parsed.entryPath === "string" && parsed.entryPath && fs.existsSync(parsed.entryPath)) {
+      return parsed.entryPath;
+    }
+  } catch {
+    // fall through to undefined
+  }
+  return undefined;
+}
+
+// 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 returns its exported
+// relayInProcess() function, so callHook can call straight into the hook registry
+// instead of spawnSync-ing a whole second node process for every single hook call in
+// this long-lived agent process. Cached after the first successful resolution (the
+// module itself is cached by Node's ESM loader on repeat import() calls of the same
+// URL, so this mainly avoids repeat fs.existsSync/sidecar-read overhead). Returns
+// undefined (triggering the spawnSync fallback below) when entryPath is absent, the
+// sibling file doesn't exist (an install predating this file), or anything else goes
+// wrong -- this must never throw.
+type RelayInProcessFn = (event: string, payload: unknown, harnessWaitMs?: number, opts?: { elapsedMs?: () => number }) => Promise<string>;
+let cachedRelayInProcess: RelayInProcessFn | undefined;
+async function resolveRelayInProcess(): Promise<RelayInProcessFn | undefined> {
+  if (cachedRelayInProcess) return cachedRelayInProcess;
+  const entryPath = resolveEntryPath();
+  if (!entryPath) return undefined;
+  try {
+    const hookLibPath = path.join(path.dirname(entryPath), "token-goat-hook.mjs");
+    if (!fs.existsSync(hookLibPath)) return undefined;
+    const mod = (await import(pathToFileURL(hookLibPath).href)) as { relayInProcess?: unknown };
+    if (typeof mod.relayInProcess !== "function") return undefined;
+    cachedRelayInProcess = mod.relayInProcess as RelayInProcessFn;
+    return cachedRelayInProcess;
+  } catch {
+    return 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
+    // 'pi' for every call this bridge makes, instead of relying on a guessed
+    // ambient env var pi-coding-agent may or may not set.
+    //
+    // Invoking "token-goat" as a bare command here depends on PATH resolution
+    // (the npm global bin being on whatever PATH pi-coding-agent's own process
+    // inherits) -- the same class of single-point-of-failure fixed for the
+    // Codex/Copilot CLI bridges' hook commands. When resolveEntryPath() finds a
+    // baked install-time path, invoke it directly via process.execPath instead,
+    // sidestepping PATH entirely; otherwise fall back to the old PATH-based
+    // lookup (e.g. an extension installed before this fix).
+    const entryPath = resolveEntryPath();
+    const r = entryPath
+      ? spawnSync(process.execPath, [entryPath, "hook", event], {
+          input: JSON.stringify(payload),
+          encoding: "utf8",
+          timeout: SHIM_FALLBACK_TIMEOUT_MS,
+          killSignal: "SIGKILL",
+          windowsHide: true,
+          maxBuffer: 32 * 1024 * 1024,
+          env: { ...process.env, TOKEN_GOAT_HARNESS_OVERRIDE: "pi" },
+        })
+      : spawnSync('token-goat hook ' + event, {
+          input: JSON.stringify(payload),
+          encoding: "utf8",
+          timeout: SHIM_FALLBACK_TIMEOUT_MS,
+          killSignal: "SIGKILL",
+          shell: true,
+          windowsHide: true,
+          maxBuffer: 32 * 1024 * 1024,
+          env: { ...process.env, TOKEN_GOAT_HARNESS_OVERRIDE: "pi" },
+        });
+    if (r.error) return null;
+    const out = r.stdout?.trim();
+    if (!out) return null;
+    return JSON.parse(out) as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+}
+
+// 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 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();
+  const relay = await resolveRelayInProcess();
+  if (relay) {
+    try {
+      process.env.TOKEN_GOAT_HARNESS_OVERRIDE = "pi";
+      const out = await relay(event, payload, undefined, { elapsedMs: () => performance.now() - start });
+      const trimmed = out?.trim();
+      if (!trimmed) return null;
+      return JSON.parse(trimmed) as Record<string, unknown>;
+    } catch {
+      // fall through to the spawnSync fallback below
+    }
+  }
+  return callHookViaSpawn(event, payload);
+}
+
+function reverseArgMap(tool: string): Record<string, string> {
+  const fwd = ARGS_TO_TG[tool] ?? {};
+  return Object.fromEntries(Object.entries(fwd).map(([piKey, tgKey]) => [tgKey, piKey]));
+}
+
+const UNICODE_SPACES = new RegExp("[" + [0xa0, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200a, 0x202f, 0x205f, 0x3000].map((c) => String.fromCharCode(c)).join("") + "]", "g");
+
+function fileExists(p: string): boolean {
+  try {
+    fs.accessSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// The absolute path pi will open for a read/edit/write "path" argument. pi rewrites the argument before resolving it (pi-coding-agent 0.99.1, core/tools/path-utils.js resolveToCwd over utils/paths.js normalizePath), in this order: trim, unicode spaces to plain spaces, drop one leading "@", on Windows turn a Git Bash, Cygwin or WSL drive path (/c/x, /cygdrive/c/x, /mnt/c/x) into C:/x, expand "~", convert a file:// URL, then resolve against the session cwd. A read of a missing file also tries the macOS screenshot spellings (resolveReadPath). token-goat was sent the argument as written, so "@src/a.ts" or "~/notes.md" named a file that does not exist: a re-read went unrecognised and an edit never reached the index.
+function resolvePiPath(raw: string, base: string, isRead: boolean): string {
+  let p = raw.trim().replace(UNICODE_SPACES, " ");
+  if (p.startsWith("@")) p = p.slice(1);
+  if (process.platform === "win32" && p.startsWith("/") && !p.startsWith("//") && !p.includes(String.fromCharCode(92))) {
+    const m = p.match(/^[/](?:mnt[/]|cygdrive[/])?([a-z])(?:[/](.*))?$/i);
+    if (m) p = m[1].toUpperCase() + ":/" + (m[2] ?? "");
+  }
+  if (p === "~") p = os.homedir();
+  else if (p.startsWith("~/") || (process.platform === "win32" && p.startsWith("~" + String.fromCharCode(92)))) p = path.join(os.homedir(), p.slice(2));
+  else if (/^file:[/][/]/.test(p)) {
+    try { p = fileURLToPath(p); } catch {}
+  }
+  const resolved = path.resolve(base, p);
+  if (!isRead || fileExists(resolved)) return resolved;
+  const amPm = resolved.replace(/ (AM|PM)[.]/gi, String.fromCharCode(0x202f) + "$1.");
+  const nfd = resolved.normalize("NFD");
+  const curly = (s: string) => s.replace(/'/g, String.fromCharCode(0x2019));
+  for (const variant of [amPm, nfd, curly(resolved), curly(nfd)]) {
+    if (variant !== resolved && fileExists(variant)) return variant;
+  }
+  return resolved;
+}
+
+function toToolInput(tool: string, input: Record<string, unknown>, base: string): Record<string, unknown> {
+  const argMap = ARGS_TO_TG[tool] ?? {};
+  const out: Record<string, unknown> = {};
+  for (const [piKey, tgKey] of Object.entries(argMap)) {
+    if (input[piKey] !== undefined) out[tgKey] = input[piKey];
+  }
+  if (typeof out["file_path"] === "string") out["file_path"] = resolvePiPath(out["file_path"] as string, base, tool === "read");
+  return out;
+}
+
+// Pull the additionalContext / systemMessage string out of a hook response,
+// whichever shape it came back as (see the response-contract note in this
+// module's header comment).
+function extractContext(resp: Record<string, unknown>): string | undefined {
+  const hso = resp["hookSpecificOutput"] as Record<string, unknown> | undefined;
+  if (hso && typeof hso["additionalContext"] === "string") return hso["additionalContext"] as string;
+  if (typeof resp["systemMessage"] === "string") return resp["systemMessage"] as string;
+  return undefined;
+}
+
+function extractUpdatedInput(resp: Record<string, unknown>): Record<string, unknown> | undefined {
+  const hso = resp["hookSpecificOutput"] as Record<string, unknown> | undefined;
+  return hso ? (hso["updatedInput"] as Record<string, unknown> | undefined) : undefined;
+}
+
+// Decode a token-goat image-shrink additionalContext payload
+// ("<summary>\\ndata:image/<fmt>;base64,<data>") into a real file on disk,
+// since pi's tool_call handler has no context-injection channel -- only
+// in-place arg mutation. Returns undefined (leaving the read path untouched)
+// if the context isn't a shrink payload or anything goes wrong writing it.
+// Best-effort sweep of previously materialized shrunk copies in the OS temp dir: typed twin of pruneMaterializedShrinks in shrink_block.ts (MATERIALIZE_SHRUNK_IMAGE_JS), which documents why pi keeps its own copy. The temp file only needs to outlive the single tool call whose path 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.
+const MATERIALIZED_SHRINK_MAX_AGE_MS = 60 * 60 * 1000;
+let lastMaterializedShrinkSweepAtMs = 0;
+function pruneMaterializedShrinks(): void {
+  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.
+  }
+}
+
+function materializeShrunkImage(context: string | undefined): string | undefined {
+  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;
+  }
+}
+
+export default function (pi: ExtensionAPI) {
+  // Stable per-session id derived from pi's session file (filesystem-safe), or
+  // a process-scoped fallback for ephemeral sessions. Recomputed on every
+  // session_start (new / resume / fork all re-fire it).
+  let sessionId = \`pi-\${process.pid}\`;
+  let cwd = process.cwd();
+  // Manifest captured at session_before_compact, injected after compaction.
+  let pendingManifest: string | undefined;
+
+  // No forwarding callHook for session_start here (there used to be one):
+  // token-goat retired the session_start hook -- it only ever reached a
+  // permanent no-op handler (see the removal in src/hooks_session.ts and
+  // src/types.ts). This subscription is kept regardless, because it's pi's
+  // own lifecycle event and is still needed to refresh sessionId/cwd for
+  // every other bridged call below.
+  pi.on("session_start", (_event, ctx) => {
+    cwd = ctx.cwd ?? process.cwd();
+    const file = ctx.sessionManager?.getSessionFile?.();
+    sessionId = file ? \`pi-\${file.replace(/[^A-Za-z0-9._-]/g, "_")}\` : \`pi-\${process.pid}\`;
+  });
+
+  pi.on("tool_call", async (event, ctx) => {
+    const tg = TOOL_TO_TG[event.toolName];
+    if (!tg || !PRE_HOOK_TOOLS.has(tg)) return;
+
+    const input = event.input as Record<string, unknown>;
+    const resp = await callHook("pre_tool_use", {
+      session_id: sessionId,
+      tool_name: tg,
+      tool_input: toToolInput(event.toolName, input, ctx?.cwd ?? cwd),
+      cwd: ctx?.cwd ?? cwd,
+    });
+    if (!resp) return;
+
+    // Deny: block the tool call with a reason (e.g. confirmed re-read).
+    if (resp["decision"] === "block") {
+      return {
+        block: true,
+        reason: (resp["reason"] as string) ?? "blocked by token-goat",
+      };
+    }
+
+    // Rewrite: update tool args in place (e.g. compressed bash command).
+    // token-goat returns its own snake_case keys; map them back.
+    const updated = extractUpdatedInput(resp);
+    if (updated) {
+      const rev = reverseArgMap(event.toolName);
+      for (const [tgKey, val] of Object.entries(updated)) {
+        input[rev[tgKey] ?? tgKey] = val;
+      }
+      return;
+    }
+
+    // Image shrink has no context channel here -- translate it into a
+    // rewritten path pointing at a materialized shrunk copy instead.
+    if (tg === "Read") {
+      const shrunkPath = materializeShrunkImage(extractContext(resp));
+      if (shrunkPath) input["path"] = shrunkPath;
+    }
+  });
+
+  pi.on("tool_result", async (event, ctx) => {
+    const tg = TOOL_TO_TG[event.toolName];
+    if (!tg) return;
+    // event.content is tool_result's real output field (ToolResultEventBase.content:
+    // (TextContent | ImageContent)[] -- verified against pi's own
+    // core/extensions/types.ts). Join the text blocks into a single string so
+    // extractReadOutput's truncation-marker detection (which only recognizes a
+    // string tool_response.output) can see it, mirroring opencode.ts's
+    // tool_response: { output } shape.
+    const contentBlocks = Array.isArray(event.content) ? event.content : [];
+    const output = contentBlocks
+      .filter((c: { type?: string }) => c && c.type === "text")
+      .map((c: { text?: string }) => c.text ?? "")
+      .join("\\n");
+    const resp = await callHook("post_tool_use", {
+      session_id: sessionId,
+      tool_name: tg,
+      tool_input: toToolInput(event.toolName, (event.input ?? {}) as Record<string, unknown>, ctx?.cwd ?? cwd),
+      cwd: ctx?.cwd ?? cwd,
+      tool_response: { output },
+    });
+    if (!resp) return;
+
+    // rewriteOutput: replace the tool result the model sees. pi's tool_result handler CAN modify the result: its own types declare "Fired after a tool executes. Can modify result." over ToolResultEvent and a ToolResultEventResult of { content, details, isError, usage }, and the shipped runtime applies it (dist/core/extensions/runner.js emitToolResult assigns handlerResult.content onto the event, and dist/core/agent-session.js afterToolCall returns hookResult.content as the tool result content). Without this, injection fencing, secret redaction and output compression were computed and thrown away on every pi session, the same whitelist-shaped drop fixed for opencode.
+    const hso = resp["hookSpecificOutput"] as Record<string, unknown> | undefined;
+    const updatedToolOutput = hso && typeof hso["updatedToolOutput"] === "string" ? (hso["updatedToolOutput"] as string) : undefined;
+    if (updatedToolOutput === undefined) return;
+
+    // Replace only the text blocks, in place, and keep every non-text block (images) untouched: emitToolResult overwrites content wholesale, so anything not carried here is dropped from what the model sees. details/isError/usage are deliberately not returned, since runner.js only overwrites the fields a handler actually provides.
+    const rewritten: typeof contentBlocks = [];
+    let replaced = false;
+    for (const block of contentBlocks) {
+      const isText = Boolean(block) && (block as { type?: string }).type === "text";
+      if (!isText) {
+        rewritten.push(block);
+        continue;
+      }
+      if (replaced) continue;
+      replaced = true;
+      rewritten.push({ type: "text", text: updatedToolOutput });
+    }
+    if (!replaced) rewritten.push({ type: "text", text: updatedToolOutput });
+    return { content: rewritten };
+  });
+
+  // Compaction: pi's session_before_compact REPLACES the summary rather than
+  // appending to it (unlike opencode's additive output.context). So capture the
+  // token-goat manifest here, let pi build its own summary, then inject the
+  // manifest as a post-compaction message that survives into the new context
+  // window. This preserves the edited-file / symbol manifest within pi's
+  // replace-only compaction model.
+  pi.on("session_before_compact", async (_event, _ctx) => {
+    const resp = await callHook("pre_compact", { session_id: sessionId, trigger: "auto" });
+    pendingManifest = resp?.["systemMessage"] as string | undefined;
+  });
+
+  pi.on("session_compact", async (_event, _ctx) => {
+    if (pendingManifest) {
+      pi.sendMessage(
+        { customType: "token-goat-manifest", content: pendingManifest, display: false },
+        { deliverAs: "nextTurn" },
+      );
+      pendingManifest = undefined;
+    }
+  });
+}
+`;
+
+// src/bridges/pi_install.ts
+function piGlobalExtensionPath() {
+  return path5.join(os4.homedir(), ".pi", "agent", "extensions", "token-goat.ts");
+}
+function piLocalExtensionPath() {
+  return path5.join(process.cwd(), ".pi", "extensions", "token-goat.ts");
+}
+function piExtensionPath(opts = {}) {
+  return opts.local === true ? piLocalExtensionPath() : piGlobalExtensionPath();
+}
+function piEntrySidecarPath(opts = {}) {
+  return path5.join(path5.dirname(piExtensionPath(opts)), "token-goat-entry.json");
+}
+function installPi(opts = {}) {
+  return withInstallScope(projectScopeRoot(opts), () => {
+    const extensionPath = piExtensionPath(opts);
+    const { alreadyInstalled } = recordCreatedBy([extensionPath, piEntrySidecarPath(opts)], () => installSingleFilePlugin(extensionPath, piEntrySidecarPath(opts), PI_EXTENSION_SCRIPT));
+    return { extensionPath, alreadyInstalled };
+  });
+}
+function uninstallPiScope(opts) {
+  return withInstallScope(projectScopeRoot(opts), () => {
+    const removed = uninstallSingleFilePlugin(piExtensionPath(opts), piEntrySidecarPath(opts));
+    removeCreatedTree([piExtensionPath(opts), piEntrySidecarPath(opts)]);
+    return removed;
+  });
+}
+function uninstallPi(opts = {}) {
+  if (opts.local === true) {
+    return uninstallPiScope({ local: true });
+  }
+  const globalRemoved = uninstallPiScope({ local: false });
+  const localRemoved = uninstallPiScope({ local: true });
+  return globalRemoved || localRemoved;
+}
+function isPiInstalled(opts = {}) {
+  return fs5.existsSync(piExtensionPath(opts));
+}
+
+// src/bridges/opencode_install.ts
+init_define_import_meta_env();
+import * as fs6 from "node:fs";
+import * as os5 from "node:os";
+import * as path6 from "node:path";
+
+// src/bridges/opencode.ts
+init_define_import_meta_env();
+
+// src/bridges/relay_block.ts
+init_define_import_meta_env();
+var BRIDGE_RELAY_JS = `// resolveEntryPath reads a sidecar JSON file (token-goat-entry.json, written by
+// the install step next to this plugin file) containing the absolute path to
+// the token-goat CLI entry that was running at install time. Unlike
+// Codex/Copilot's generated hook commands, this plugin has no per-invocation
+// command line to bake a path into (the host loads it once as a module), so
+// callHook reads this sidecar at runtime instead, to invoke that entry
+// directly via process.execPath rather than depending on PATH resolution for
+// a bare "token-goat" lookup -- the same single-point-of-failure class fixed
+// for the Codex/Copilot CLI bridges' hook commands and pi's extension
+// (resolveEntryPath). Returns undefined (triggering the PATH-based
+// shell:true fallback below) if the sidecar is missing, unreadable, or
+// points at a path that no longer exists.
+function resolveEntryPath() {
+  try {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const sidecarPath = path.join(here, "token-goat-entry.json");
+    const parsed = JSON.parse(fs.readFileSync(sidecarPath, "utf8"));
+    if (typeof parsed.entryPath === "string" && parsed.entryPath && fs.existsSync(parsed.entryPath)) {
+      return parsed.entryPath;
+    }
+  } catch {
+    // fall through to undefined
+  }
+  return undefined;
+}
+
+// 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 returns its exported
+// relayInProcess() function, so callHook can call straight into the hook registry
+// instead of spawnSync-ing a whole second node process for every single hook call in
+// this long-lived host process. Cached after the first successful resolution (the
+// module itself is cached by Node's ESM loader on repeat import() calls of the same
+// URL, so this mainly avoids repeat fs.existsSync/sidecar-read overhead). Returns
+// undefined (triggering the spawnSync fallback below) when entryPath is absent, the
+// sibling file doesn't exist (an install predating this file), or anything else goes
+// wrong -- this must never throw.
+let cachedRelayInProcess;
+async function resolveRelayInProcess() {
+  if (cachedRelayInProcess) return cachedRelayInProcess;
+  const entryPath = resolveEntryPath();
+  if (!entryPath) return undefined;
+  try {
+    const hookLibPath = path.join(path.dirname(entryPath), "token-goat-hook.mjs");
+    if (!fs.existsSync(hookLibPath)) return undefined;
+    const mod = await import(pathToFileURL(hookLibPath).href);
+    if (typeof mod.relayInProcess !== "function") return undefined;
+    cachedRelayInProcess = mod.relayInProcess;
+    return cachedRelayInProcess;
+  } catch {
+    return undefined;
+  }
+}
+
+${shimFallbackTimeoutConst("relay")}
+
+function callHookViaSpawn(event, payload) {
+  try {
+    // Invoking "token-goat" as a bare command here depends on PATH resolution
+    // (the npm global bin being on whatever PATH the host process inherits) --
+    // on Windows a global npm install resolves "token-goat" to a .cmd/.ps1
+    // shim, which spawnSync cannot exec without shell: true. When
+    // resolveEntryPath() finds a baked install-time path, invoke it directly
+    // via process.execPath instead, sidestepping PATH entirely; otherwise
+    // fall back to the old PATH-based lookup with shell: true so a .cmd/.ps1
+    // shim still resolves (e.g. an install predating this fix).
+    const entryPath = resolveEntryPath();
+    const r = entryPath
+      ? spawnSync(process.execPath, [entryPath, "hook", event], {
+          input: JSON.stringify(payload),
+          encoding: "utf8",
+          timeout: SHIM_FALLBACK_TIMEOUT_MS,
+          killSignal: "SIGKILL",
+          windowsHide: true,
+          maxBuffer: 32 * 1024 * 1024,
+        })
+      : spawnSync("token-goat hook " + event, {
+          input: JSON.stringify(payload),
+          encoding: "utf8",
+          timeout: SHIM_FALLBACK_TIMEOUT_MS,
+          killSignal: "SIGKILL",
+          shell: true,
+          windowsHide: true,
+          maxBuffer: 32 * 1024 * 1024,
+        });
+    if (r.error) return null;
+    const out = r.stdout ? r.stdout.trim() : "";
+    if (!out) return null;
+    return JSON.parse(out);
+  } catch {
+    return null;
+  }
+}
+
+// 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 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, 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();
+  const relay = await resolveRelayInProcess();
+  if (relay) {
+    try {
+      const out = await relay(event, payload, undefined, { elapsedMs: () => performance.now() - start });
+      const trimmed = out ? out.trim() : "";
+      if (!trimmed) return null;
+      return JSON.parse(trimmed);
+    } catch {
+      // fall through to the spawnSync fallback below
+    }
+  }
+  return callHookViaSpawn(event, payload);
+}`;
+
+// src/bridges/opencode.ts
+var OPENCODE_PLUGIN_SCRIPT = `// token-goat bridge plugin for opencode
+// Bridges opencode's plugin hooks to token-goat's subprocess hook protocol.
+// https://github.com/DFKHelper/token-goat
+import { spawnSync } from "node:child_process"
+import crypto from "node:crypto"
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { fileURLToPath, pathToFileURL } from "node:url"
+
+// opencode built-in tool id -> token-goat canonical tool name. websearch/skill/task were re-verified against opencode's own source at the tag matching the installed release (anomalyco/opencode v1.18.16 packages/opencode/src/tool/): WebSearchTool registers as "websearch" (websearch.ts), SkillTool as "skill" (skill.ts), TaskTool as "task" (task.ts, params prompt/subagent_type/description -- the exact keys token-goat's hooks_agent_spawn.ts reads, which registers a lowercase 'task' handler). Unmapped, all three were dead mechanisms here: no WebSearch repeat-search deny/compression, no repeat-skill-load deny, no agent-spawn briefing or report compaction. apply_patch is mapped to Edit (see patchTextPaths below). lsp/plan/question/todo have no token-goat equivalent and stay unmapped.
+const TOOL_TO_TG = {
+  read: "Read",
+  bash: "Bash",
+  edit: "Edit",
+  write: "Write",
+  grep: "Grep",
+  glob: "Glob",
+  webfetch: "WebFetch",
+  websearch: "WebSearch",
+  skill: "Skill",
+  task: "task",
+  apply_patch: "Edit",
+}
+
+// Tools with a pre_tool_use handler server-side whose OUTPUT SHAPE this hook can act on: deny (throw), updatedInput (args rewrite), or the Read image-shrink materialization. websearch (repeat-search deny within the dedup TTL, hooks_websearch.ts), skill (repeat-load deny, hooks_skill.ts) and task (briefing updatedInput rewrite, hooks_agent_spawn.ts) all qualify. Edit/Write have no pre-hook at all. Glob DOES have one (preGlobDedupHandler, hooks_glob.ts) -- the old claim here that it has none was stale -- but its only output is an advisory contextOutput hint, and tool.execute.before has no context channel (see the module docblock), so calling it would spawn a subprocess per glob only to drop the answer; it stays excluded for that reason, not the old one.
+const PRE_HOOK_TOOLS = new Set(["read", "bash", "grep", "webfetch", "websearch", "skill", "task"])
+
+// opencode tool args (camelCase) -> token-goat snake_case tool_input keys. websearch's query (websearch.ts Parameters), skill's name (skill.ts Parameters; hooks_skill.ts reads tool_input['skill']) and task's prompt/subagent_type/description (task.ts BaseParameterFields) are all from opencode's own schemas at v1.18.16.
+const ARGS_TO_TG = {
+  read: { filePath: "file_path", offset: "offset", limit: "limit" },
+  bash: { command: "command", timeout: "timeout" },
+  edit: { filePath: "file_path" },
+  write: { filePath: "file_path" },
+  grep: { pattern: "pattern", path: "path" },
+  glob: { pattern: "pattern", path: "path" },
+  webfetch: { url: "url" },
+  websearch: { query: "query" },
+  skill: { name: "skill" },
+  task: { prompt: "prompt", subagent_type: "subagent_type", description: "description" },
+}
+
+function reverseArgMap(tool) {
+  const fwd = ARGS_TO_TG[tool] ?? {}
+  const rev = {}
+  for (const [opencodeKey, tgKey] of Object.entries(fwd)) rev[tgKey] = opencodeKey
+  return rev
+}
+
+// opencode's apply_patch tool (tool/apply_patch.ts, v1.18.33) takes one patchText argument and no per-file path; it is the tool opencode offers GPT models in place of edit and write. The file paths are the header lines of the patch (patch/index.ts parsePatchHeader: "*** Add File: ", "*** Delete File: ", "*** Update File: ", plus "*** Move to: " for a rename), each trimmed and resolved against the instance directory, which is the directory this plugin sends as cwd. A trailing carriage return is dropped by the trim. Left unmapped, an edit a GPT model made was never queued for reindexing.
+const PATCH_PATH_HEADERS = ["*** Add File: ", "*** Delete File: ", "*** Update File: ", "*** Move to: "]
+
+function patchTextPaths(patchText) {
+  const paths = []
+  if (typeof patchText !== "string") return paths
+  for (const line of patchText.split(String.fromCharCode(10))) {
+    for (const header of PATCH_PATH_HEADERS) {
+      if (!line.startsWith(header)) continue
+      const p = line.slice(header.length).trim()
+      if (p && !paths.includes(p)) paths.push(p)
+    }
+  }
+  return paths
+}
+
+function toToolInput(tool, args) {
+  if (tool === "apply_patch") {
+    const paths = patchTextPaths(args && args.patchText)
+    return paths.length === 1 ? { file_path: paths[0], file_paths: paths } : { file_paths: paths }
+  }
+  const map = ARGS_TO_TG[tool] ?? {}
+  const out = {}
+  for (const [opencodeKey, tgKey] of Object.entries(map)) {
+    if (args && args[opencodeKey] !== undefined) out[tgKey] = args[opencodeKey]
+  }
+  return out
+}
+
+${BRIDGE_RELAY_JS}
+
+// Pull the additionalContext / systemMessage string out of a hook response,
+// whichever shape it came back as (see the response-contract note above).
+function extractContext(resp) {
+  if (!resp) return undefined
+  const hso = resp.hookSpecificOutput
+  if (hso && typeof hso.additionalContext === "string") return hso.additionalContext
+  if (typeof resp.systemMessage === "string") return resp.systemMessage
+  return undefined
+}
+
+function extractUpdatedInput(resp) {
+  const hso = resp && resp.hookSpecificOutput
+  return hso && typeof hso === "object" ? hso.updatedInput : undefined
+}
+
+export const TokenGoatPlugin = async ({ directory }) => {
+  return {
+    "tool.execute.before": async (input, output) => {
+      const tg = TOOL_TO_TG[input.tool]
+      if (!tg || !PRE_HOOK_TOOLS.has(input.tool)) return
+
+      const resp = await callHook("pre_tool_use", {
+        session_id: input.sessionID,
+        tool_name: tg,
+        tool_input: toToolInput(input.tool, output.args),
+        cwd: directory,
+      })
+      if (!resp) return
+
+      if (resp.decision === "block") {
+        throw new Error(resp.reason || "blocked by token-goat")
+      }
+
+      const updated = extractUpdatedInput(resp)
+      if (updated) {
+        const rev = reverseArgMap(input.tool)
+        for (const [tgKey, val] of Object.entries(updated)) {
+          output.args[rev[tgKey] ?? tgKey] = val
+        }
+      }
+    },
+
+    "tool.execute.after": async (input, output) => {
+      const tg = TOOL_TO_TG[input.tool]
+      if (!tg) return
+
+      const resp = await callHook("post_tool_use", {
+        session_id: input.sessionID,
+        tool_name: tg,
+        tool_input: toToolInput(input.tool, input.args),
+        tool_response: { output: output.output, exit_code: output.metadata ? output.metadata.exit : undefined },
+        cwd: directory,
+      })
+      if (!resp) return
+
+      // rewriteOutput: replace the tool result wholesale. This is the shape every post_tool_use rewrite producer emits (WebFetch injection fencing and secret redaction, websearch redaction, bash/grep output compression, agent-report compaction), and it went unapplied here for the same whitelist reason the response-contract docblock above used to omit it -- the plugin only handled the shapes its author listed, so opencode sessions got the appended hint channel but never a fenced, redacted or compressed result. Mutating output.output is the exact mechanism the context append below already relies on, so this claims no capability the append did not.
+      const hso = resp.hookSpecificOutput
+      const updatedToolOutput = hso && typeof hso.updatedToolOutput === "string" ? hso.updatedToolOutput : undefined
+      if (updatedToolOutput !== undefined) {
+        output.output = updatedToolOutput
+        return
+      }
+
+      const context = extractContext(resp)
+      if (context && typeof output.output === "string") {
+        output.output += \`\\n\\n[token-goat] \${context}\`
+      }
+    },
+
+    "experimental.session.compacting": async (input, output) => {
+      const resp = await callHook("pre_compact", { session_id: input.sessionID })
+      const manifest = resp && typeof resp.systemMessage === "string" ? resp.systemMessage : undefined
+      if (manifest) output.context.push(manifest)
+    },
+  }
+}
+`;
+
+// src/bridges/opencode_install.ts
+function opencodeGlobalConfigDir() {
+  const xdgConfigHome = process.env["XDG_CONFIG_HOME"];
+  if (xdgConfigHome !== void 0 && xdgConfigHome.trim() !== "") return xdgConfigHome;
+  return path6.join(os5.homedir(), ".config");
+}
+function opencodePluginPath() {
+  return path6.join(opencodeGlobalConfigDir(), "opencode", "plugins", "token-goat.ts");
+}
+function opencodeEntrySidecarPath() {
+  return path6.join(path6.dirname(opencodePluginPath()), "token-goat-entry.json");
+}
+function legacyWindowsPluginPath() {
+  if (process.platform !== "win32") return null;
+  const appData = process.env["APPDATA"];
+  const root = appData !== void 0 && appData.trim() !== "" ? appData : path6.join(os5.homedir(), "AppData", "Roaming");
+  return path6.join(root, "opencode", "plugins", "token-goat.ts");
+}
+function removeLegacyWindowsPlugin() {
+  const legacy = legacyWindowsPluginPath();
+  if (legacy === null) return false;
+  return uninstallSingleFilePlugin(legacy, path6.join(path6.dirname(legacy), "token-goat-entry.json"));
+}
+function installOpencode() {
+  const pluginPath = opencodePluginPath();
+  const { alreadyInstalled } = recordCreatedBy([pluginPath, opencodeEntrySidecarPath()], () => installSingleFilePlugin(pluginPath, opencodeEntrySidecarPath(), OPENCODE_PLUGIN_SCRIPT));
+  removeLegacyWindowsPlugin();
+  return { pluginPath, alreadyInstalled };
+}
+function uninstallOpencode() {
+  const removedLegacy = removeLegacyWindowsPlugin();
+  const removed = uninstallSingleFilePlugin(opencodePluginPath(), opencodeEntrySidecarPath());
+  removeCreatedTree([opencodePluginPath(), opencodeEntrySidecarPath()]);
+  return removed || removedLegacy;
+}
+function isOpencodeInstalled() {
+  return fs6.existsSync(opencodePluginPath());
+}
+
+// src/bridges/openclaw_install.ts
+init_define_import_meta_env();
+import * as fs7 from "node:fs";
+import * as os6 from "node:os";
+import * as path7 from "node:path";
+
+// src/bridges/openclaw.ts
+init_define_import_meta_env();
+var OPENCLAW_PLUGIN_SCRIPT = `// token-goat bridge plugin for OpenClaw
+// Bridges OpenClaw's tool-call and session hooks to token-goat's subprocess
+// hook protocol. https://github.com/DFKHelper/token-goat
+//
+// NOTE ON PARAMETER SHAPES: OpenClaw's bash tool really does use token-goat's own key names (command/timeout), but the path-carrying tools (read/edit/write) send the file path under "path", not "file_path" -- read out of OpenClaw's own tool input schemas (src/agents/sessions/tools/read-tool-contract.ts, edit.ts, bash.ts in openclaw/openclaw). toToolInput below ADDS the canonical file_path alongside the original path so token-goat's getFilePath()-based handlers can see it, without renaming anything. The built-in tool NAME list below is broader than any single source confirms, since an unmatched name is a harmless no-op here, not a wrong rewrite.
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// OpenClaw built-in tool names -> token-goat internal tool names.
+const TOOL_TO_TG = {
+  read: "Read",
+  write: "Write",
+  edit: "Edit",
+  apply_patch: "Edit",
+  exec: "Bash",
+  bash: "Bash",
+  grep: "Grep",
+  glob: "Glob",
+  find: "Glob",
+  webfetch: "WebFetch",
+  web_search: "WebFetch",
+  web_fetch: "WebFetch",
+};
+
+// Tools with a pre_tool_use handler whose output shape this hook can act on: deny (block/blockReason), updatedInput (params rewrite), or the Read image-shrink materialization. Edit/Write have no pre handler at all. Glob (OpenClaw's find) DOES have one -- preGlobDedupHandler in hooks_glob.ts; the old claim here that it has none was stale -- but its only output is an advisory contextOutput hint and before_tool_call has no context channel, so calling it would spawn a hook subprocess per find only to drop the answer; it stays excluded for that reason (matching pi.ts/opencode.ts's corrected note).
+const PRE_HOOK_TOOLS = new Set(["Read", "Grep", "Bash", "WebFetch"]);
+
+// OpenClaw tools whose file path travels under "path" (see the parameter-shapes note above). apply_patch is handled separately: its input is a patch document naming any number of files.
+const PATH_ARG_TOOLS = new Set(["read", "write", "edit"]);
+
+// The directory OpenClaw resolves a relative tool path against. Checked against OpenClaw 2026.9.7: its coding tools resolve against the agent workspace (agents.list[].workspace, else agents.defaults.workspace, else the state dir's workspace folder), not the gateway process's own directory, and the tool-call hook context carries only agentId/sessionId/sessionKey/runId/toolCallId, no directory. So the workspace is looked up through the plugin runtime's own resolver, api.runtime.agent.resolveAgentWorkspaceDir(api.runtime.config.current(), agentId). The workspace differs from the resolve base only when a run asked for a separate cwd or runs sandboxed, and neither is visible to a plugin. process.cwd() is the last resort for a runtime without that resolver.
+function workspaceFor(api, ctx) {
+  if (ctx && typeof ctx.workspaceDir === "string" && ctx.workspaceDir) return ctx.workspaceDir;
+  try {
+    const rt = api && api.runtime;
+    const dir = rt.agent.resolveAgentWorkspaceDir(rt.config.current(), ctx && ctx.agentId);
+    if (typeof dir === "string" && dir) return dir;
+  } catch {}
+  return process.cwd();
+}
+
+// Turn a tool's raw path argument into the absolute path OpenClaw will open, applying OpenClaw's own rewrites in its order: a leading "@" (a file reference) is dropped unless a file or folder literally named that way exists, a file:// URL becomes a path, and "~", "~/" and, on Windows, "~" plus a backslash expand to the home folder. Without this, a relative path was resolved against whatever directory token-goat happened to run in, so a re-read was never recognised and an edit was never queued for reindexing.
+function resolveToolPathArg(raw, base) {
+  let p = raw.trim();
+  if (p.startsWith("@") && p.length > 1) {
+    const first = p.split("/")[0].split(path.sep)[0];
+    if (!fs.existsSync(path.resolve(base, p)) && !fs.existsSync(path.resolve(base, first))) p = p.slice(1);
+  }
+  if (/^file:[/][/]/i.test(p)) {
+    try { p = fileURLToPath(p); } catch {}
+  }
+  if (p === "~") p = os.homedir();
+  else if (p.startsWith("~/") || p.startsWith("~" + path.sep)) p = path.join(os.homedir(), p.slice(2));
+  return path.resolve(base, p);
+}
+
+// apply_patch (params.input, OpenClaw's apply-patch-paths extractApplyPatchTargets) names its files on header lines, leading whitespace allowed, with a rename's "*** Move to: " following its "*** Update File: ".
+const PATCH_PATH_HEADERS = ["*** Add File: ", "*** Delete File: ", "*** Update File: ", "*** Move to: "];
+
+function patchTextPaths(patchText) {
+  const paths = [];
+  if (typeof patchText !== "string") return paths;
+  for (const rawLine of patchText.split(String.fromCharCode(10))) {
+    const line = rawLine.trimStart();
+    for (const header of PATCH_PATH_HEADERS) {
+      if (!line.startsWith(header)) continue;
+      const p = line.slice(header.length).trim();
+      if (p && !paths.includes(p)) paths.push(p);
+    }
+  }
+  return paths;
+}
+
+// Build token-goat's tool_input from OpenClaw's params: same object, plus the canonical file_path (absolute, see resolveToolPathArg) added alongside the original path for the tools that carry one, or file_paths for apply_patch. derived is OpenClaw's own resolution of the patch's files (event.derivedPaths), preferred over re-parsing the patch. Never renames or drops a key.
+function toToolInput(toolName, params, base, derived) {
+  const p = params || {};
+  if (PATH_ARG_TOOLS.has(toolName) && typeof p.path === "string" && p.file_path === undefined) {
+    return { ...p, file_path: resolveToolPathArg(p.path, base) };
+  }
+  if (toolName === "apply_patch" && p.file_path === undefined) {
+    const files = derived && derived.length ? derived : patchTextPaths(p.input).map((f) => resolveToolPathArg(f, base));
+    if (files.length === 1) return { ...p, file_path: files[0], file_paths: files };
+    if (files.length > 1) return { ...p, file_paths: files };
+  }
+  return p;
+}
+
+// Pull the additionalContext / systemMessage string out of a hook response, whichever shape it came back as (see the response-contract note in this module's header comment).
+function extractContext(resp) {
+  if (!resp) return undefined;
+  const hso = resp["hookSpecificOutput"];
+  if (hso && typeof hso["additionalContext"] === "string") return hso["additionalContext"];
+  if (typeof resp["systemMessage"] === "string") return resp["systemMessage"];
+  return undefined;
+}
+
+${BRIDGE_RELAY_JS}
+
+${MATERIALIZE_SHRUNK_IMAGE_JS}
+
+export default definePluginEntry({
+  id: "token-goat",
+  name: "token-goat",
+  description:
+    "Bridges OpenClaw's tool-call and session hooks to token-goat's read-hinting, bash compression, and index-refresh pipeline.",
+  register(api) {
+    // No confirmed stable per-session id on tool-call context (see module
+    // header) -- fall back to a per-process pseudo-id if ctx carries none.
+    let sessionId = \`openclaw-\${process.pid}-\${Date.now()}\`;
+
+    api.on("session_start", (event, ctx) => {
+      sessionId = (ctx && (ctx.sessionId || ctx.sessionKey)) || sessionId;
+    });
+
+    // No forwarding callHook for session_start here (there used to be one):
+    // token-goat retired the session_start hook -- it only ever reached a
+    // permanent no-op handler (see the removal in src/hooks_session.ts and
+    // src/types.ts). The subscription above is kept regardless, because it's
+    // OpenClaw's own lifecycle event and is still needed to refresh
+    // sessionId for every other bridged call below.
+
+    // No api.on("session_end", ...) here: token-goat's own HOOK_EVENTS
+    // (src/types.ts) has no session_end member, so calling it would be the
+    // same invented-event-name no-op already found and fixed once for pi's
+    // bridge (commit 2f0a15e4). OpenClaw's session_end is a real lifecycle
+    // event, but token-goat has no corresponding hook to bridge it to.
+
+    // apply_patch's files as OpenClaw itself resolved them (event.derivedPaths, absolute), keyed by toolCallId: only before_tool_call carries them, and after_tool_call is where the edit is recorded. Capped so a call that never completes cannot grow it without bound.
+    const patchPaths = new Map();
+
+    api.on("before_tool_call", async (event, ctx) => {
+      const callId = event.toolCallId || (ctx && ctx.toolCallId);
+      if (event.toolName === "apply_patch" && callId && Array.isArray(event.derivedPaths)) {
+        patchPaths.set(callId, [...event.derivedPaths]);
+        if (patchPaths.size > 256) patchPaths.delete(patchPaths.keys().next().value);
+      }
+      const tg = TOOL_TO_TG[event.toolName];
+      if (!tg || !PRE_HOOK_TOOLS.has(tg)) return {};
+
+      const sid = (ctx && (ctx.sessionId || ctx.sessionKey)) || sessionId;
+      const base = workspaceFor(api, ctx);
+      const resp = await callHook("pre_tool_use", {
+        session_id: sid,
+        tool_name: tg,
+        tool_input: toToolInput(event.toolName, event.params, base),
+        cwd: base,
+      });
+      if (!resp) return {};
+
+      // Deny: block the tool call with a reason (e.g. confirmed re-read).
+      if (resp["decision"] === "block") {
+        return { block: true, blockReason: resp["reason"] || "blocked by token-goat" };
+      }
+
+      // Rewrite: token-goat returns its own snake_case tool_input keys, which
+      // are already OpenClaw's native param shape (see module header) -- no
+      // reverse-mapping needed, just merge over the original params.
+      const hso = resp["hookSpecificOutput"];
+      const updated = hso ? hso["updatedInput"] : undefined;
+      if (updated) {
+        return { params: { ...(event.params || {}), ...updated } };
+      }
+
+      // Image shrink has no context channel here -- translate it into a rewritten path pointing at a materialized shrunk copy instead, via the same params-rewrite channel the updatedInput merge above already relies on. OpenClaw's read tool takes the path under "path" (see the parameter-shapes note above), and the rest of the original params are preserved.
+      if (tg === "Read") {
+        const shrunkPath = materializeShrunkImage(extractContext(resp));
+        if (shrunkPath) return { params: { ...(event.params || {}), path: shrunkPath } };
+      }
+
+      return {};
+    });
+
+    api.on("after_tool_call", async (event, ctx) => {
+      const tg = TOOL_TO_TG[event.toolName];
+      if (!tg) return;
+      const sid = (ctx && (ctx.sessionId || ctx.sessionKey)) || sessionId;
+      // event.result's shape is unverified against a live OpenClaw instance
+      // (see module header) -- token-goat's post_tool_use handlers already
+      // accept tool_response as either a raw string or an object keyed by
+      // output/content/text/body, so forward it as-is when it's already an
+      // object, or wrap a bare string/other value as { output } so those
+      // handlers can find it either way, mirroring opencode.ts's and
+      // pi.ts's tool_response: { output } shape.
+      const toolResponse =
+        event.result && typeof event.result === "object" ? event.result : { output: event.result };
+      const callId = event.toolCallId || (ctx && ctx.toolCallId);
+      const derived = callId ? patchPaths.get(callId) : undefined;
+      if (callId) patchPaths.delete(callId);
+      const base = workspaceFor(api, ctx);
+      await callHook("post_tool_use", {
+        session_id: sid,
+        tool_name: tg,
+        tool_input: toToolInput(event.toolName, event.params, base, derived),
+        cwd: base,
+        tool_response: toolResponse,
+      });
+    });
+
+    // Observation-only: no manifest-reinjection channel exists here (see
+    // module header). This keeps token-goat's own session bookkeeping in
+    // sync with real compaction events.
+    api.on("before_compaction", async (event, ctx) => {
+      const sid = (ctx && (ctx.sessionId || ctx.sessionKey)) || sessionId;
+      await callHook("pre_compact", { session_id: sid, trigger: "auto" });
+    });
+  },
+});
+`;
+
+// src/bridges/openclaw_install.ts
+var OpenclawConfigParseError = class extends Error {
+};
+var OPENCLAW_PLUGIN_ID = "token-goat";
+function openclawHomeDir() {
+  return path7.join(os6.homedir(), ".openclaw");
+}
+function openclawConfigPath() {
+  return path7.join(openclawHomeDir(), "openclaw.json");
+}
+function openclawPluginPath() {
+  return path7.join(openclawHomeDir(), "plugins", "token-goat.ts");
+}
+function openclawEntrySidecarPath() {
+  return path7.join(path7.dirname(openclawPluginPath()), "token-goat-entry.json");
+}
+function readOpenclawConfig(p, opts = {}) {
+  const refuse = (problem, detail) => new OpenclawConfigParseError(
+    (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 {
+    raw = fs7.readFileSync(p, "utf8");
+  } catch (e) {
+    const code = e.code;
+    if (opts.strict === true && code !== "ENOENT" && code !== "ENOTDIR") throw refuse("exists but cannot be read", code ?? extractErrorMessage(e));
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = parseJsonOrJsonc(raw);
+  } catch (e) {
+    if (opts.strict === true) throw refuse("exists but contains invalid JSON", extractErrorMessage(e));
+    return {};
+  }
+  if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+    const settings = parsed;
+    const paths = settings.plugins?.load?.paths;
+    if (paths !== void 0 && !Array.isArray(paths)) {
+      if (opts.strict === true) throw refuse("has a 'plugins.load.paths' field that isn't a JSON array");
+      delete settings.plugins?.load?.paths;
+    }
+    return settings;
+  }
+  if (opts.strict === true) throw refuse("does not contain a JSON object at the top level");
+  return {};
+}
+function openclawArtifactPaths() {
+  return [openclawConfigPath(), openclawPluginPath(), openclawEntrySidecarPath()];
+}
+function installOpenclaw() {
+  return recordCreatedBy(openclawArtifactPaths(), installOpenclawFiles);
+}
+function installOpenclawFiles() {
+  const configPath = openclawConfigPath();
+  const pluginPath = openclawPluginPath();
+  let existingPlugin;
+  try {
+    existingPlugin = fs7.readFileSync(pluginPath, "utf8");
+  } catch {
+    existingPlugin = void 0;
+  }
+  const pluginChanged = existingPlugin !== OPENCLAW_PLUGIN_SCRIPT;
+  const settings = readOpenclawConfig(configPath, { strict: true });
+  const entryPath = process.argv[1];
+  if (entryPath) {
+    ensureDirSync(path7.dirname(pluginPath));
+    atomicWriteText(openclawEntrySidecarPath(), JSON.stringify({ entryPath }));
+  }
+  const plugins = settings.plugins ?? {};
+  const loadPaths = [...plugins.load?.paths ?? []];
+  const entries = { ...plugins.entries ?? {} };
+  let configChanged = false;
+  if (!loadPaths.some((p) => foldPath(p) === foldPath(pluginPath))) {
+    loadPaths.push(pluginPath);
+    configChanged = true;
+  }
+  if (entries[OPENCLAW_PLUGIN_ID] === void 0) {
+    entries[OPENCLAW_PLUGIN_ID] = { enabled: true };
+    configChanged = true;
+  }
+  if (!pluginChanged && !configChanged) {
+    return { configPath, pluginPath, alreadyInstalled: true };
+  }
+  if (pluginChanged) {
+    ensureDirSync(path7.dirname(pluginPath));
+    atomicWriteText(pluginPath, OPENCLAW_PLUGIN_SCRIPT);
+  }
+  if (configChanged) {
+    settings.plugins = { ...plugins, load: { ...plugins.load, paths: loadPaths }, entries };
+    writeSettingsKeepingComments(configPath, settings);
+  }
+  return { configPath, pluginPath, alreadyInstalled: false };
+}
+function uninstallOpenclaw() {
+  const configPath = openclawConfigPath();
+  const pluginPath = openclawPluginPath();
+  const settings = readOpenclawConfig(configPath, { strict: true, command: "uninstall" });
+  let removed = false;
+  try {
+    fs7.unlinkSync(pluginPath);
+    removed = true;
+  } catch {
+  }
+  try {
+    fs7.unlinkSync(openclawEntrySidecarPath());
+  } catch {
+  }
+  const plugins = settings.plugins;
+  if (plugins !== void 0) {
+    const loadPaths = plugins.load?.paths;
+    const entries = plugins.entries;
+    let configChanged = false;
+    if (loadPaths !== void 0 && loadPaths.some((p) => foldPath(p) === foldPath(pluginPath))) {
+      const kept = loadPaths.filter((p) => foldPath(p) !== foldPath(pluginPath));
+      if (kept.length > 0) {
+        plugins.load = { ...plugins.load, paths: kept };
+      } else if (plugins.load !== void 0) {
+        delete plugins.load.paths;
+        if (Object.keys(plugins.load).length === 0) delete plugins.load;
+      }
+      configChanged = true;
+      removed = true;
+    }
+    if (entries !== void 0 && entries[OPENCLAW_PLUGIN_ID] !== void 0) {
+      delete entries[OPENCLAW_PLUGIN_ID];
+      if (Object.keys(entries).length === 0) delete plugins.entries;
+      configChanged = true;
+      removed = true;
+    }
+    if (configChanged) {
+      if (Object.keys(plugins).length === 0) {
+        delete settings.plugins;
+      } else {
+        settings.plugins = plugins;
+      }
+      writeSettingsKeepingComments(configPath, settings);
+    }
+  }
+  removeCreatedBackups(configPath);
+  removeCreatedTree(openclawArtifactPaths());
+  return removed;
+}
+function isOpenclawInstalled() {
+  if (!fs7.existsSync(openclawPluginPath())) return false;
+  const settings = readOpenclawConfig(openclawConfigPath());
+  const plugins = settings.plugins;
+  if (plugins === void 0) return false;
+  const targetFolded = foldPath(openclawPluginPath());
+  const hasPath = (plugins.load?.paths ?? []).some((p) => foldPath(p) === targetFolded);
+  const hasEntry = plugins.entries?.[OPENCLAW_PLUGIN_ID] !== void 0;
+  return hasPath && hasEntry;
+}
+
+// src/bridges/grok.ts
+init_define_import_meta_env();
+var GROK_HOOK_SCRIPT = `#!/usr/bin/env node
+// token-goat Grok CLI hook shim. Forwards the hook payload to \`token-goat hook <event>\`, then -- for pre_tool_use only -- translates token-goat's {"decision":"block",...} deny shape into Grok's documented {"decision":"deny",...} shape and sets exit code 2.
+'use strict'
+${SHIM_REQUIRES}
+
+// Keep in sync with HOOK_EVENTS in src/types.ts.
+const VALID_HOOK_EVENTS = new Set([
+  'pre_tool_use',
+  'post_tool_use',
+  'notification',
+  'stop',
+  'pre_compact',
+  'user_prompt_submit',
+  'subagent_stop',
+])
+
+function allowResponse(eventName) {
+  return eventName === 'pre_tool_use' ? '{"decision":"allow"}' : '{}'
+}
+
+${SHIM_TRY_SERVER}
+
+${SHIM_TRY_IN_PROCESS}
+
+${SHIM_MAX_BUFFER_CONST}
+${shimFallbackTimeoutConst("grok")}
+
+async function main() {
+  const eventName = process.argv[2] || ''
+  if (!VALID_HOOK_EVENTS.has(eventName)) {
+    process.stdout.write('{}')
+    return
+  }
+  let input = ''
+  try {
+    input = require('node:fs').readFileSync(0, 'utf8')
+  } catch {
+    process.stdout.write(allowResponse(eventName))
+    return
+  }
+  // process.argv[3], when present, is the absolute path to the token-goat CLI entry
+  // that ran 'token-goat install --grok' (baked in by hookCommandFor in
+  // grok_install.ts). Try the in-process hook lib first (tryInProcess above) -- this
+  // avoids spawning a second node process altogether. If that's unavailable, invoking
+  // the entry directly via process.execPath sidesteps PATH resolution for this inner
+  // call, the same reasoning as every other bridge shim's inner call. Falls back
+  // further to the old PATH-based shell:true invocation when argv[3] is absent. A
+  // 3000ms timeout/killSignal on both spawnSync fallbacks bounds them well under
+  // Grok's own hook timeout (default 5s, per the hooks doc), so token-goat degrades to
+  // its own fail-open response rather than being force-killed by Grok first.
+  const entryPath = process.argv[3]
+  let stdout = await tryInProcess(entryPath, eventName, input)
+  if (stdout === undefined) {
+${SHIM_SPAWN_LADDER}
+      : spawnSync('token-goat hook ' + eventName, {
+          input,
+          encoding: 'utf8',
+          shell: true,
+          timeout: SHIM_FALLBACK_TIMEOUT_MS,
+          killSignal: 'SIGKILL',
+          maxBuffer: SHIM_MAX_BUFFER_BYTES,
+        })
+    if (res.status !== 0 || !res.stdout) {
+      process.stdout.write(allowResponse(eventName))
+      return
+    }
+    stdout = res.stdout
+  }
+  let parsed
+  try {
+    parsed = JSON.parse(stdout)
+  } catch {
+    process.stdout.write(allowResponse(eventName))
+    return
+  }
+
+  if (eventName !== 'pre_tool_use') {
+    // Passive events: Grok ignores stdout entirely (per the hooks doc), so the exact
+    // shape doesn't matter -- forward token-goat's response verbatim.
+    process.stdout.write(JSON.stringify(parsed))
+    return
+  }
+
+  if (parsed && parsed.decision === 'block') {
+    process.stdout.write(JSON.stringify({ decision: 'deny', reason: parsed.reason || 'blocked by token-goat' }))
+    process.exitCode = 2
+    return
+  }
+  process.stdout.write('{"decision":"allow"}')
+}
+
+main().catch((err) => {
+  try {
+    process.stdout.write(allowResponse(process.argv[2] || ''))
+  } catch {
+    // stdout itself is broken; nothing more can be done here.
+  }
+})
+`;
+
+// src/bridges/grok_install.ts
+init_define_import_meta_env();
+import * as fs8 from "node:fs";
+import * as os7 from "node:os";
+import * as path8 from "node:path";
+var GROK_HOOK_EVENTS = ["PreToolUse", "PostToolUse", "PreCompact", "UserPromptSubmit", "SubagentStop"];
+var GROK_EVENT_ARG = {
+  PreToolUse: "pre_tool_use",
+  PostToolUse: "post_tool_use",
+  PreCompact: "pre_compact",
+  UserPromptSubmit: "user_prompt_submit",
+  SubagentStop: "subagent_stop"
+};
+function grokHooksDir() {
+  return path8.join(os7.homedir(), ".grok", "hooks");
+}
+function grokConfigPath() {
+  return path8.join(grokHooksDir(), "token-goat.json");
+}
+function grokHookScriptPath() {
+  return path8.join(grokHooksDir(), SHIM_FILE);
+}
+function grokLegacyHookScriptPath() {
+  return path8.join(grokHooksDir(), LEGACY_SHIM_FILE);
+}
+function grokHookCommandFor(scriptPath, eventArg, opts = {}) {
+  const bin = nativeHookBinary(process.argv[1], opts);
+  const native = bin === void 0 ? void 0 : nativeHookCommandLine(process.platform === "win32" ? "powershell" : "sh", bin, "grok", scriptPath, eventArg);
+  return native ?? (process.platform === "win32" ? powershellHookLine(hookPowershellCommand(scriptPath, eventArg)) : hookCommandFor(scriptPath, eventArg));
+}
+function wiredGrokHookWords() {
+  let config;
+  try {
+    config = JSON.parse(stripBom(fs8.readFileSync(grokConfigPath(), "utf8")));
+  } catch {
+    return [];
+  }
+  const scriptPath = grokHookScriptPath();
+  const expected = new Set(GROK_HOOK_EVENTS.map((e) => grokHookCommandFor(scriptPath, GROK_EVENT_ARG[e], { sync: false })));
+  const out = [];
+  for (const groups of Object.values(config?.hooks ?? {})) {
+    for (const g of Array.isArray(groups) ? groups : []) {
+      for (const h of Array.isArray(g?.hooks) ? g.hooks : []) {
+        if (typeof h?.command === "string") out.push({ words: splitHookCommand(h.command, process.platform === "win32" ? "powershell" : "sh"), current: expected.has(h.command) });
+      }
+    }
+  }
+  return out;
+}
+function buildConfig(scriptPath) {
+  const hooks = {};
+  for (const event of GROK_HOOK_EVENTS) {
+    hooks[event] = [
+      { matcher: "", hooks: [{ type: "command", command: grokHookCommandFor(scriptPath, GROK_EVENT_ARG[event]) }] }
+    ];
+  }
+  return { hooks };
+}
+function installGrok() {
+  return recordCreatedBy(grokArtifactPaths(), installGrokFiles);
+}
+function grokArtifactPaths() {
+  return [grokConfigPath(), grokHookScriptPath(), grokLegacyHookScriptPath()];
+}
+function installGrokFiles() {
+  const configPath = grokConfigPath();
+  const scriptPath = grokHookScriptPath();
+  const config = buildConfig(scriptPath);
+  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 ${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("{}"));
+  const scriptChanged = writeIfDifferent(scriptPath, GROK_HOOK_SCRIPT);
+  const desiredText = `${JSON.stringify(config, null, 2)}
+`;
+  const configChanged = writeIfDifferent(configPath, desiredText, true);
+  return { configPath, hookScriptPath: scriptPath, alreadyInstalled: !scriptChanged && !forwarderChanged && !configChanged };
+}
+function uninstallGrok() {
+  const configPath = grokConfigPath();
+  const scriptPath = grokHookScriptPath();
+  let removedAny = false;
+  try {
+    fs8.unlinkSync(configPath);
+    removedAny = true;
+  } catch {
+  }
+  for (const p of [scriptPath, grokLegacyHookScriptPath()]) {
+    try {
+      fs8.unlinkSync(p);
+      removedAny = true;
+    } catch {
+    }
+  }
+  removeCreatedBackups(configPath);
+  removeCreatedTree(grokArtifactPaths());
+  return removedAny;
+}
+function isGrokInstalled() {
+  return fs8.existsSync(grokConfigPath()) && fs8.existsSync(grokHookScriptPath());
+}
+
+// src/bridges/antigravity_install.ts
+init_define_import_meta_env();
+import * as fs9 from "node:fs";
+import * as os8 from "node:os";
+import * as path9 from "node:path";
+var HOOK_NAME = "token-goat";
+var PLUGIN_DIR_NAME = "token-goat";
+var SHIM_FILE2 = "token-goat-hook.cmd";
+var HOOK_TIMEOUT_SECONDS = 30;
+var SHIM_MARKER = "--harness antigravity";
+var ANTIGRAVITY_HOOK_EVENTS = ["PreToolUse", "PostToolUse"];
+var ANTIGRAVITY_EVENT_ARG = {
+  PreToolUse: "pre_tool_use",
+  PostToolUse: "post_tool_use"
+};
+var AntigravitySettingsParseError = class extends Error {
+};
+function geminiDir() {
+  return path9.join(os8.homedir(), ".gemini");
+}
+function geminiConfigDir() {
+  return path9.join(geminiDir(), "config");
+}
+function antigravityPluginsDir() {
+  return path9.join(geminiConfigDir(), "plugins");
+}
+function antigravityPluginDir() {
+  return path9.join(antigravityPluginsDir(), PLUGIN_DIR_NAME);
+}
+function antigravityHooksPath() {
+  return path9.join(antigravityPluginDir(), "hooks.json");
+}
+function pluginManifestPath() {
+  return path9.join(antigravityPluginDir(), "plugin.json");
+}
+function shimPath() {
+  return path9.join(antigravityPluginDir(), SHIM_FILE2);
+}
+function readJsonObject(p, label, opts = {}) {
+  const refuse = (problem, detail) => new AntigravitySettingsParseError(
+    (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 {
+    raw = fs9.readFileSync(p, "utf8");
+  } catch (e) {
+    const code = e.code;
+    if (opts.strict === true && code !== "ENOENT" && code !== "ENOTDIR") throw refuse("exists but cannot be read", code ?? extractErrorMessage(e));
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stripBom(raw));
+  } catch (e) {
+    if (opts.strict === true) throw refuse("exists but contains invalid JSON", extractErrorMessage(e));
+    return void 0;
+  }
+  if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) return parsed;
+  if (opts.strict === true) throw refuse("does not contain a JSON object at the top level");
+  return void 0;
+}
+function shimContent() {
+  const entryPath = process.argv[1];
+  const escape = (value) => quoteShellPath(value).replace(/%/g, "%%");
+  const invocation = entryPath ? `${escape(process.execPath)} ${escape(entryPath)}` : "token-goat";
+  return `@${invocation} hook %1 ${SHIM_MARKER}\r
+@exit /b %ERRORLEVEL%\r
+`;
+}
+function antigravityHookCommand(eventArg, platform = process.platform) {
+  if (platform === "win32") return `.\\${SHIM_FILE2} ${eventArg}`;
+  const entryPath = process.argv[1];
+  if (!entryPath) return `token-goat hook ${eventArg} ${SHIM_MARKER}`;
+  return `${quoteShellPath(process.execPath)} ${quoteShellPath(entryPath)} hook ${eventArg} ${SHIM_MARKER}`;
+}
+function desiredHookEntry() {
+  const entry = {};
+  for (const event of ANTIGRAVITY_HOOK_EVENTS) {
+    entry[event] = [{ matcher: "*", hooks: [{ type: "command", command: antigravityHookCommand(ANTIGRAVITY_EVENT_ARG[event]), timeout: HOOK_TIMEOUT_SECONDS }] }];
+  }
+  return entry;
+}
+function readShim() {
+  try {
+    return fs9.readFileSync(shimPath(), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function installAntigravity() {
+  const pluginDir = antigravityPluginDir();
+  const hooksPath = antigravityHooksPath();
+  const manifestPath = pluginManifestPath();
+  const hooksFile = readJsonObject(hooksPath, "plugin hooks file", { strict: true, command: "install" });
+  const manifest = readJsonObject(manifestPath, "plugin manifest", { strict: true, command: "install" });
+  let changed = false;
+  for (const dir of [geminiDir(), geminiConfigDir(), antigravityPluginsDir(), pluginDir]) ensureDirRecordingCreation(dir);
+  if (manifest === void 0) {
+    writeJsonSettings(manifestPath, { name: PLUGIN_DIR_NAME });
+    recordCreatedConfig(manifestPath);
+    changed = true;
+  }
+  if (process.platform === "win32") {
+    const content = shimContent();
+    const existing = readShim();
+    if (existing !== content) {
+      atomicWriteText(shimPath(), content);
+      if (existing === void 0) recordCreatedConfig(shimPath());
+      changed = true;
+    }
+  }
+  const desired = desiredHookEntry();
+  const current = hooksFile?.[HOOK_NAME];
+  if (JSON.stringify(current) !== JSON.stringify(desired)) {
+    writeJsonSettings(hooksPath, { ...hooksFile ?? {}, [HOOK_NAME]: desired });
+    if (hooksFile === void 0) recordCreatedConfig(hooksPath);
+    changed = true;
+  }
+  return { pluginDir, alreadyInstalled: !changed };
+}
+function uninstallAntigravity() {
+  const pluginDir = antigravityPluginDir();
+  const hooksPath = antigravityHooksPath();
+  const manifestPath = pluginManifestPath();
+  const hooksFile = readJsonObject(hooksPath, "plugin hooks file", { strict: true, command: "uninstall" });
+  let removed = false;
+  if (hooksFile !== void 0 && Object.prototype.hasOwnProperty.call(hooksFile, HOOK_NAME)) {
+    const rest = { ...hooksFile };
+    delete rest[HOOK_NAME];
+    removed = true;
+    if (Object.keys(rest).length === 0 && takeCreatedConfig(hooksPath)) {
+      fs9.unlinkSync(hooksPath);
+    } else {
+      writeJsonSettings(hooksPath, rest);
+    }
+  }
+  removeCreatedBackups(hooksPath);
+  const shim = readShim();
+  if (shim?.includes(SHIM_MARKER) === true) {
+    fs9.unlinkSync(shimPath());
+    takeCreatedConfig(shimPath());
+    removed = true;
+  }
+  const manifest = readJsonObject(manifestPath, "plugin manifest");
+  if (manifest !== void 0 && hasCreatedConfig(manifestPath) && JSON.stringify(manifest) === JSON.stringify({ name: PLUGIN_DIR_NAME }) && !fs9.existsSync(hooksPath)) {
+    fs9.unlinkSync(manifestPath);
+    takeCreatedConfig(manifestPath);
+    removed = true;
+  }
+  removeCreatedBackups(manifestPath);
+  for (const dir of [pluginDir, antigravityPluginsDir(), geminiConfigDir(), geminiDir()]) removeCreatedIfEmpty(dir);
+  return removed;
+}
+function isAntigravityInstalled() {
+  const hooksFile = readJsonObject(antigravityHooksPath(), "plugin hooks file");
+  if (hooksFile !== void 0 && Object.prototype.hasOwnProperty.call(hooksFile, HOOK_NAME)) return true;
+  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,
+  isGeminiInstalled,
+  installQwen,
+  uninstallQwen,
+  isQwenInstalled,
+  kimiConfigPath,
+  kimiHookScriptPath,
+  installKimi,
+  uninstallKimi,
+  wiredKimiHookWords,
+  isKimiInstalled,
+  installPi,
+  uninstallPi,
+  isPiInstalled,
+  installOpencode,
+  uninstallOpencode,
+  isOpencodeInstalled,
+  installOpenclaw,
+  uninstallOpenclaw,
+  isOpenclawInstalled,
+  GROK_HOOK_SCRIPT,
+  grokConfigPath,
+  grokHookScriptPath,
+  wiredGrokHookWords,
+  installGrok,
+  uninstallGrok,
+  isGrokInstalled,
+  installAntigravity,
+  uninstallAntigravity,
+  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
+};