token-goat 2.9.28 → 2.9.30

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

@@ -0,0 +1,2228 @@
+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,
+  editAt,
+  finishHookUninstall,
+  groupHasTokenGoat,
+  hookCommandRewrittenSpan,
+  legacyShimForwarder,
+  nativeHookBinary,
+  nativeHookCommandLine,
+  skillDescriptionLine,
+  splitHookCommand
+} from "./token-goat-chunk-OJBNYTJP.mjs";
+import {
+  parseJsonOrJsonc,
+  stripBom
+} from "./token-goat-chunk-XKI4SEMX.mjs";
+import {
+  toolMatcherFor
+} from "./token-goat-chunk-P4QMM4WK.mjs";
+import {
+  GEMINI_TOOL_NAME_MAP
+} from "./token-goat-chunk-VPBBTSJR.mjs";
+import {
+  loadConfig,
+  parse,
+  stringify
+} from "./token-goat-chunk-7IN2MKDS.mjs";
+import {
+  atomicWriteText,
+  backupFile,
+  ensureDirRecordingCreation,
+  ensureDirSync,
+  extractErrorMessage,
+  hasCreatedConfig,
+  hookCommandFor,
+  hookPowershellCommand,
+  installSingleFilePlugin,
+  projectScopeRoot,
+  recordCreatedBy,
+  recordCreatedConfig,
+  removeCreatedBackups,
+  removeCreatedIfEmpty,
+  removeCreatedTree,
+  stripDelimitedBlock,
+  stripOwnHooksFromMap,
+  stripStaleGroupHooks,
+  takeCreatedConfig,
+  uninstallSingleFilePlugin,
+  upsertDelimitedBlock,
+  withInstallScope,
+  writeConfigText,
+  writeIfDifferent,
+  writeJsonSettings
+} from "./token-goat-chunk-GOLEOXZP.mjs";
+import {
+  foldPath,
+  powershellHookLine,
+  quoteShellPath
+} from "./token-goat-chunk-AM5V6GSX.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 '${p}' is unreadable: it ${problem}. Uninstall left it and its backups untouched; fix the file and run uninstall again.` : `Gemini settings file '${p}' ${problem}. Fix or back up the file before running install.`) + (detail === void 0 ? "" : ` (${detail})`)
+  );
+  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 '${p}' is unreadable: it ${problem}. Uninstall left it and its backups untouched; fix the file and run uninstall again.` : `Qwen Code settings file '${p}' ${problem}. Fix or back up the file before running install.`) + (detail === void 0 ? "" : ` (${detail})`)
+  );
+  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}
+
+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 3000ms
+  // 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: 3000,
+          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 '${p}' is unreadable: it ${problem}. Uninstall left it untouched, along with the hook shim it may still name, the AGENTS.md block, the skill and the file's backups; fix the file and run uninstall again.` : `Kimi Code config file '${p}' ${problem}. Fix or back up the file before running install.`) + (detail === void 0 ? "" : ` (${detail})`)
+  );
+  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 "${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;
+  }
+}
+
+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: 3000,
+          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: 3000,
+          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 with a 3000ms timeout/killSignal so token-goat degrades to
+// its own fail-open null rather than being force-killed by pi's own hook timeout
+// budget, ~5000ms) when the in-process path is unavailable or throws.
+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;
+  }
+}
+
+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: 3000,
+          killSignal: "SIGKILL",
+          windowsHide: true,
+          maxBuffer: 32 * 1024 * 1024,
+        })
+      : spawnSync("token-goat hook " + event, {
+          input: JSON.stringify(payload),
+          encoding: "utf8",
+          timeout: 3000,
+          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 with a 3000ms timeout/killSignal so token-goat degrades to
+// its own fail-open null rather than being force-killed by the host's own hook timeout
+// budget, ~5000ms) when the in-process path is unavailable or throws.
+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
+}
+
+${MATERIALIZE_SHRUNK_IMAGE_JS}
+
+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
+        }
+        return
+      }
+
+      // Image shrink has no context channel here -- translate it into a
+      // rewritten filePath pointing at a materialized shrunk copy instead.
+      if (tg === "Read") {
+        const shrunkPath = materializeShrunkImage(extractContext(resp))
+        if (shrunkPath) output.args.filePath = shrunkPath
+      }
+    },
+
+    "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 '${p}' is unreadable: it ${problem}. Uninstall left it untouched, along with the plugin it may still load, the plugin's entry sidecar and the file's backups; fix the file and run uninstall again.` : `OpenClaw config file '${p}' ${problem}. Fix or back up the file before running install.`) + (detail === void 0 ? "" : ` (${detail})`)
+  );
+  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}
+
+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: 3000,
+          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 "${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} '${p}' is unreadable: it ${problem}. Uninstall left it and its backups untouched; fix the file and run uninstall again.` : `Antigravity ${label} '${p}' ${problem}. Fix or back up the file before running install.`) + (detail === void 0 ? "" : ` (${detail})`)
+  );
+  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;
+}
+
+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
+};