@theagenthub/cli 0.3.1 → 0.3.3

package/bin/agenthub.cjs

@@ -59,6 +59,616 @@ var init_paths = __esm({
   }
 });
 
+// src/cli/amp-plugin.ts
+function ampPlugin(command, as = "file") {
+  const header = as === "package" ? PACKAGE_HEADER : `${AMP_MARKER}
+// Re-run that command to update it, or \`agenthub hooks uninstall amp\` to remove it.`;
+  return `${header}
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+${as === "package" ? PACKAGE_COMMAND : `const COMMAND = ${JSON.stringify(command)};`}
+const TIMEOUT_MS = 5000;
+
+export const description = "Agent Hub: teammates' agents' messages in your threads, and an idle thread wakes for their requests.";
+
+/** Runs agenthub; resolves to its exit code and stdout, or code -1 on any failure. */
+function run(args, input, cwd, timeoutMs, onChild) {
+  return new Promise((resolve) => {
+    let out = "";
+    let child;
+    try {
+      child = spawn(COMMAND, args, { cwd, stdio: ["pipe", "pipe", "ignore"], windowsHide: true, shell: process.platform === "win32" });
+    } catch {
+      return resolve({ code: -1, out: "" });
+    }
+    onChild?.(child);
+    const timer = timeoutMs ? setTimeout(() => child.kill(), timeoutMs) : undefined;
+    child.stdout.on("data", (chunk) => (out += chunk));
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolve({ code: -1, out: "" });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({ code: code ?? -1, out: out.trim() });
+    });
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+  });
+}
+
+export default function agenthub(amp) {
+  let cwd = process.cwd();
+  try {
+    const root = amp.system?.workspaceRoot ? String(amp.system.workspaceRoot) : "";
+    if (root) cwd = root.startsWith("file:") ? fileURLToPath(root) : root;
+  } catch {}
+  const started = new Set();
+  const waiting = new Map();
+  const stopWaiting = (id) => {
+    waiting.get(id)?.kill();
+    waiting.delete(id);
+  };
+  const notify = async (event, id, extra) => {
+    const { out } = await run(["notify", "--format", "amp", "--event", event], JSON.stringify({ session_id: id, cwd, ...extra }), cwd, TIMEOUT_MS);
+    return out;
+  };
+  const say = async (id, content, steer) => {
+    try {
+      await amp.threads.get(id).appendUserMessage({ type: "user-message", content }, steer ? { steer: true } : undefined);
+    } catch (e) {
+      amp.logger?.log?.("agenthub: couldn't add to thread " + id + ": " + e);
+    }
+  };
+  const wake = async (id) => {
+    const { code, out } = await run(["wait"], JSON.stringify({ session_id: id, cwd }), cwd, 0, (child) => {
+      stopWaiting(id);
+      waiting.set(id, child);
+    });
+    // An agenthub too old to know \`wait\` exits 2 too, but prints nothing on stdout.
+    if (code === 2 && out) await say(id, out, false);
+  };
+
+  amp.on("agent.start", async (event) => {
+    const id = event.thread?.id;
+    if (!id) return;
+    stopWaiting(id);
+    const first = !started.has(id);
+    started.add(id);
+    const text = await notify(first ? "session-start" : "prompt", id);
+    return text ? { message: { content: text, display: false } } : undefined;
+  });
+
+  amp.on("tool.result", async (event) => {
+    const id = event.thread?.id;
+    if (!id) return;
+    const text = await notify("post-tool", id);
+    if (!text) return;
+    if (typeof event.output === "string") return { status: event.status, output: event.output + "\\n\\n" + text };
+    await say(id, text, true);
+  });
+
+  amp.on("agent.end", async (event) => {
+    const id = event.thread?.id;
+    if (!id) return;
+    // A cancelled turn isn't kept going, and doesn't start a waiter.
+    const out = await notify("stop", id, { status: event.status });
+    if (out) {
+      try {
+        const r = JSON.parse(out);
+        if (r.decision === "block" && r.reason) return { action: "continue", userMessage: r.reason };
+      } catch {}
+    }
+    if (event.status !== "cancelled") void wake(id);
+  });
+
+  amp.onDispose?.(() => {
+    for (const child of waiting.values()) child.kill();
+    waiting.clear();
+  });
+}
+`;
+}
+var AMP_MARKER, PACKAGE_HEADER, PACKAGE_COMMAND;
+var init_amp_plugin = __esm({
+  "src/cli/amp-plugin.ts"() {
+    "use strict";
+    AMP_MARKER = "// Agent Hub plugin for Amp, written by `agenthub hooks install amp`.";
+    PACKAGE_HEADER = `// Agent Hub plugin for Amp. Copy it to ~/.config/amp/plugins/ (or a repo's .amp/plugins/).
+// Needs the agenthub CLI: curl -fsSL https://get.theagenthub.app | sh`;
+    PACKAGE_COMMAND = `const COMMAND =
+  process.env.AGENTHUB_BIN ||
+  [join(homedir(), ".local", "bin", "agenthub"), join(process.env.LOCALAPPDATA || homedir(), "Programs", "agenthub", "agenthub.exe")].find((f) => existsSync(f)) ||
+  "agenthub";`;
+  }
+});
+
+// src/cli/opencode-plugin.ts
+function opencodePlugin(command, as = "file") {
+  const header = as === "package" ? PACKAGE_HEADER2 : `${OPENCODE_MARKER}
+// Re-run that command to update it, or \`agenthub hooks uninstall opencode\` to remove it.`;
+  return `${header}
+import { spawn } from "node:child_process";
+
+${as === "package" ? PACKAGE_COMMAND2 : `const COMMAND = ${JSON.stringify(command)};`}
+const TIMEOUT_MS = 5000;
+
+function notify(event, sessionID, cwd) {
+  return new Promise((resolve) => {
+    let out = "";
+    let child;
+    try {
+      child = spawn(COMMAND, ["notify", "--format", "text", "--event", event], {
+        cwd,
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true,
+        shell: process.platform === "win32",
+      });
+    } catch {
+      return resolve("");
+    }
+    const timer = setTimeout(() => {
+      child.kill();
+      resolve("");
+    }, TIMEOUT_MS);
+    child.stdout.on("data", (chunk) => (out += chunk));
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolve("");
+    });
+    child.on("close", () => {
+      clearTimeout(timer);
+      resolve(out.trim());
+    });
+    child.stdin.on("error", () => {});
+    child.stdin.end(JSON.stringify({ session_id: sessionID, cwd }));
+  });
+}
+
+/** Runs \`agenthub wait\`; resolves to the text to wake the session with, or "" when it shouldn't. */
+function waitForMessage(sessionID, cwd, children) {
+  return new Promise((resolve) => {
+    let out = "";
+    let child;
+    try {
+      child = spawn(COMMAND, ["wait"], { cwd, stdio: ["pipe", "pipe", "ignore"], windowsHide: true, shell: process.platform === "win32" });
+    } catch {
+      return resolve("");
+    }
+    children.get(sessionID)?.kill();
+    children.set(sessionID, child);
+    child.stdout.on("data", (chunk) => (out += chunk));
+    child.on("error", () => resolve(""));
+    child.on("close", (code) => {
+      if (children.get(sessionID) === child) children.delete(sessionID);
+      // An agenthub too old to know \`wait\` exits 2 too, but prints nothing on stdout.
+      resolve(code === 2 ? out.trim() : "");
+    });
+    child.stdin.on("error", () => {});
+    child.stdin.end(JSON.stringify({ session_id: sessionID, cwd }));
+  });
+}
+
+function partId() {
+  return "prt_" + Date.now().toString(16) + Math.random().toString(36).slice(2, 12);
+}
+
+export const AgentHub = async ({ directory, client }) => {
+  const started = new Set();
+  const waiting = new Map();
+  let presence = Promise.resolve();
+  const wake = async (sessionID) => {
+    const send = client?.session?.promptAsync ?? client?.session?.prompt;
+    if (!send) return;
+    const text = await waitForMessage(sessionID, directory, waiting);
+    if (!text) return;
+    try {
+      await send.call(client.session, { path: { id: sessionID }, body: { parts: [{ type: "text", text }] } });
+    } catch {
+      /* the session is gone, or busy again */
+    }
+  };
+  return {
+    "chat.message": async (input, output) => {
+      waiting.get(input.sessionID)?.kill();
+      const first = !started.has(input.sessionID);
+      started.add(input.sessionID);
+      const text = await notify(first ? "session-start" : "prompt", input.sessionID, directory);
+      const messageID = input.messageID ?? output.message?.id;
+      if (!text || !messageID) return;
+      output.parts.push({ id: partId(), sessionID: input.sessionID, messageID, type: "text", text, synthetic: true });
+    },
+    "tool.execute.after": async (input, output) => {
+      const text = await notify("post-tool", input.sessionID, directory);
+      if (text && typeof output.output === "string") output.output += "\\n\\n<agenthub>\\n" + text + "\\n</agenthub>";
+    },
+    // Presence updates don't block OpenCode, but run one at a time so "offline" can't be
+    // overtaken by an earlier "idle".
+    event: async ({ event }) => {
+      if (event.type === "session.idle") {
+        const sessionID = event.properties.sessionID;
+        presence = presence.then(() => notify("stop", sessionID, directory));
+        // Not awaited: it waits as long as the session is idle.
+        presence.then(() => wake(sessionID)).catch(() => {});
+      } else if (event.type === "session.deleted") {
+        waiting.get(event.properties.info.id)?.kill();
+        presence = presence.then(() => notify("session-end", event.properties.info.id, directory));
+      }
+    },
+  };
+};
+
+// OpenCode 2 loads the default export's setup() and ignores the hooks above; OpenCode 1
+// reads the named export (and default.server, the same function). setup() returns early
+// when OpenCode 1 calls it too.
+async function setup(ctx) {
+  if (!ctx?.session?.hook || !ctx.tool?.hook || !ctx.event?.subscribe) return;
+  const directory = ctx.location?.directory ?? process.cwd();
+  const started = new Set();
+  const waiting = new Map();
+  let presence = Promise.resolve();
+  const wake = async (sessionID) => {
+    if (typeof ctx.session.synthetic !== "function") return;
+    const text = await waitForMessage(sessionID, directory, waiting);
+    if (!text) return;
+    try {
+      await ctx.session.synthetic({ sessionID, text, description: "Agent Hub: new message", delivery: "queue", resume: true });
+    } catch {
+      /* the session is gone, or busy again */
+    }
+  };
+  const wrap = (text) => "\\n\\n<agenthub>\\n" + text + "\\n</agenthub>";
+
+  // V2 has no hidden message parts, so the notice is appended to the prompt's text.
+  await ctx.session.hook("prompt", async (event) => {
+    waiting.get(event.sessionID)?.kill();
+    const first = !started.has(event.sessionID);
+    started.add(event.sessionID);
+    const text = await notify(first ? "session-start" : "prompt", event.sessionID, directory);
+    if (text && event.prompt && typeof event.prompt.text === "string") event.prompt.text += wrap(text);
+  });
+  // The model reads a tool's result.content.
+  await ctx.tool.hook("execute.after", async (event) => {
+    if (event.status !== "completed" || !Array.isArray(event.result?.content)) return;
+    const text = await notify("post-tool", event.sessionID, directory);
+    if (text) event.result.content.push({ type: "text", text: wrap(text).trimStart() });
+  });
+
+  const controller = new AbortController();
+  (async () => {
+    const types = ["session.execution.succeeded", "session.execution.failed", "session.execution.interrupted", "session.deleted"];
+    for await (const event of ctx.event.subscribe({ types, signal: controller.signal })) {
+      const sessionID = event.data?.sessionID;
+      if (!sessionID) continue;
+      const kind = event.type === "session.deleted" ? "session-end" : "stop";
+      if (kind === "session-end") {
+        started.delete(sessionID);
+        waiting.get(sessionID)?.kill();
+      }
+      presence = presence.then(() => notify(kind, sessionID, directory));
+      // A finished run (not one the user interrupted) waits for a hub message; not awaited.
+      if (event.type === "session.execution.succeeded" || event.type === "session.execution.failed") {
+        presence.then(() => wake(sessionID)).catch(() => {});
+      }
+    }
+  })().catch(() => {});
+  return () => {
+    controller.abort();
+    for (const child of waiting.values()) child.kill();
+  };
+}
+
+export default { id: "agenthub", server: AgentHub, setup };
+`;
+}
+var OPENCODE_MARKER, PACKAGE_HEADER2, PACKAGE_COMMAND2;
+var init_opencode_plugin = __esm({
+  "src/cli/opencode-plugin.ts"() {
+    "use strict";
+    OPENCODE_MARKER = "// Agent Hub plugin for OpenCode, written by `agenthub hooks install opencode`.";
+    PACKAGE_HEADER2 = `// Agent Hub plugin for OpenCode, from the @theagenthub/opencode npm package.
+// Needs the agenthub CLI: curl -fsSL https://get.theagenthub.app | sh`;
+    PACKAGE_COMMAND2 = `import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const COMMAND =
+  process.env.AGENTHUB_BIN ||
+  [join(homedir(), ".local", "bin", "agenthub"), join(process.env.LOCALAPPDATA || homedir(), "Programs", "agenthub", "agenthub.exe")].find((f) => existsSync(f)) ||
+  "agenthub";`;
+  }
+});
+
+// src/cli/hooks.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  HARNESSES: () => HARNESSES,
+  KIMI_BEGIN: () => KIMI_BEGIN,
+  KIMI_END: () => KIMI_END,
+  USER_SCOPE_ONLY: () => USER_SCOPE_ONLY,
+  WAIT_MAX_S: () => WAIT_MAX_S,
+  WAIT_TIMEOUT_S: () => WAIT_TIMEOUT_S,
+  cliHooksFile: () => cliHooksFile,
+  hookFile: () => hookFile,
+  installHooks: () => installHooks,
+  uninstallHooks: () => uninstallHooks
+});
+function hookFile(harness, scope, cwd, home = (0, import_node_os2.homedir)(), env = process.env) {
+  const user = scope === "user";
+  const base = user ? home : cwd;
+  switch (harness) {
+    case "claude-code":
+      return user ? (0, import_node_path3.join)(home, ".claude", "settings.json") : (0, import_node_path3.join)(cwd, ".claude", "settings.local.json");
+    case "codex":
+      return (0, import_node_path3.join)(base, ".codex", "hooks.json");
+    case "copilot":
+      return user ? (0, import_node_path3.join)(env.COPILOT_HOME || (0, import_node_path3.join)(home, ".copilot"), "hooks", "agenthub.json") : (0, import_node_path3.join)(cwd, ".github", "hooks", "agenthub.json");
+    case "opencode":
+      return user ? (0, import_node_path3.join)(env.XDG_CONFIG_HOME || (0, import_node_path3.join)(home, ".config"), "opencode", "plugins", "agenthub.js") : (0, import_node_path3.join)(cwd, ".opencode", "plugins", "agenthub.js");
+    case "droid":
+      return (0, import_node_path3.join)(base, ".factory", "hooks.json");
+    case "gemini":
+      return (0, import_node_path3.join)(base, ".gemini", "settings.json");
+    case "qwen":
+      return (0, import_node_path3.join)(base, ".qwen", "settings.json");
+    case "cursor":
+      return (0, import_node_path3.join)(base, ".cursor", "hooks.json");
+    case "antigravity":
+      return user ? (0, import_node_path3.join)(home, ".gemini", "config", "hooks.json") : (0, import_node_path3.join)(cwd, ".agents", "hooks.json");
+    case "kimi":
+      return (0, import_node_path3.join)(home, ".kimi-code", "config.toml");
+    case "goose":
+      return (0, import_node_path3.join)(base, ".agents", "plugins", "agenthub", "hooks", "hooks.json");
+    case "crush":
+      return user ? (0, import_node_path3.join)(env.XDG_CONFIG_HOME || (0, import_node_path3.join)(home, ".config"), "crush", "crush.json") : (0, import_node_fs2.existsSync)((0, import_node_path3.join)(cwd, "crush.json")) ? (0, import_node_path3.join)(cwd, "crush.json") : (0, import_node_path3.join)(cwd, ".crush.json");
+    case "amp":
+      return user ? (0, import_node_path3.join)(env.XDG_CONFIG_HOME || (0, import_node_path3.join)(home, ".config"), "amp", "plugins", "agenthub.ts") : (0, import_node_path3.join)(cwd, ".amp", "plugins", "agenthub.ts");
+  }
+}
+function cliHooksFile(harness, cwd, home = (0, import_node_os2.homedir)(), env = process.env) {
+  const project = (harness === "claude-code" ? env.CLAUDE_PROJECT_DIR : void 0) || cwd;
+  const files = harness === "codex" ? [(0, import_node_path3.join)(env.CODEX_HOME || (0, import_node_path3.join)(home, ".codex"), "hooks.json"), (0, import_node_path3.join)(project, ".codex", "hooks.json")] : [(0, import_node_path3.join)(home, ".claude", "settings.json"), (0, import_node_path3.join)(project, ".claude", "settings.local.json"), (0, import_node_path3.join)(project, ".claude", "settings.json")];
+  for (const f of files) {
+    try {
+      if (/agenthub[^"]* notify/.test((0, import_node_fs2.readFileSync)(f, "utf8"))) return f;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function installHooks(harness, file2, command = "agenthub") {
+  (0, import_node_fs2.mkdirSync)((0, import_node_path3.dirname)(file2), { recursive: true });
+  const notify2 = (event) => `${command} notify --format ${harness} --event ${event}`;
+  const pairs = HARNESS_EVENTS[harness] ?? [];
+  switch (harness) {
+    case "opencode":
+      (0, import_node_fs2.writeFileSync)(file2, opencodePlugin(command));
+      return ["chat.message", "tool.execute.after", "session.idle", "session.deleted"];
+    case "amp":
+      (0, import_node_fs2.writeFileSync)(file2, ampPlugin(command));
+      return ["agent.start", "tool.result", "agent.end"];
+    case "copilot":
+    case "cursor":
+    case "crush": {
+      const config2 = readJson(file2);
+      if (harness !== "crush") config2.version = 1;
+      const hooks = config2.hooks ??= {};
+      for (const [event, notifyEvent] of pairs) {
+        const kept = (hooks[event] ?? []).filter((h) => !isOurs(h));
+        const entry = harness === "copilot" ? { type: "command", command: notify2(notifyEvent), timeoutSec: 10 } : { command: notify2(notifyEvent), timeout: 10 };
+        hooks[event] = [...kept, entry];
+      }
+      writeJson(file2, config2);
+      return pairs.map(([e]) => e);
+    }
+    case "antigravity": {
+      const config2 = readJson(file2);
+      config2.agenthub = Object.fromEntries(pairs.map(([event, n]) => [event, [{ hooks: [{ type: "command", command: notify2(n), timeout: 10 }] }]]));
+      writeJson(file2, config2);
+      return pairs.map(([e]) => e);
+    }
+    case "kimi": {
+      const before = (0, import_node_fs2.existsSync)(file2) ? stripKimi((0, import_node_fs2.readFileSync)(file2, "utf8")) : "";
+      const block = [KIMI_BEGIN, ...pairs.flatMap(([event, n]) => ["[[hooks]]", `event = "${event}"`, `command = ${JSON.stringify(notify2(n))}`, "timeout = 10", ""]), KIMI_END, ""].join("\n");
+      (0, import_node_fs2.writeFileSync)(file2, `${before}${before && !before.endsWith("\n") ? "\n" : ""}${before ? "\n" : ""}${block}`);
+      return pairs.map(([e]) => e);
+    }
+    case "goose": {
+      const root = (0, import_node_path3.dirname)((0, import_node_path3.dirname)(file2));
+      writeJson((0, import_node_path3.join)(root, "plugin.json"), GOOSE_PLUGIN);
+      writeJson(file2, { hooks: Object.fromEntries(pairs.map(([event, n]) => [event, [{ hooks: [{ type: "command", command: notify2(n), timeout: 10 }] }]])) });
+      return pairs.map(([e]) => e);
+    }
+    case "droid":
+    case "gemini":
+    case "qwen": {
+      const config2 = readJson(file2);
+      const hooks = harness === "droid" ? config2 : config2.hooks ??= {};
+      const timeout = harness === "droid" ? 10 : 1e4;
+      for (const [event, n] of pairs) {
+        hooks[event] = [...keepOthers(hooks[event]), { hooks: [{ type: "command", command: notify2(n), timeout }] }];
+      }
+      writeJson(file2, config2);
+      return pairs.map(([e]) => e);
+    }
+    case "claude-code":
+    case "codex": {
+      const config2 = readJson(file2);
+      const hooks = config2.hooks ??= {};
+      for (const event of EVENTS) {
+        const entry = { hooks: [{ type: "command", command: `${command} notify --format ${harness}`, timeout: TIMEOUT_S[harness][event] ?? 10 }] };
+        if (event === "PostToolUse" && harness === "claude-code") entry.matcher = "*";
+        if (event === "Stop" && harness === "claude-code") {
+          entry.hooks.push({ type: "command", command: `${command} wait --max ${WAIT_MAX_S}`, asyncRewake: true, timeout: WAIT_TIMEOUT_S });
+        }
+        hooks[event] = [...keepOthers(hooks[event]), entry];
+      }
+      writeJson(file2, config2);
+      return EVENTS;
+    }
+  }
+}
+function uninstallHooks(harness, file2) {
+  if (!(0, import_node_fs2.existsSync)(file2)) return false;
+  switch (harness) {
+    case "opencode":
+      if (!(0, import_node_fs2.readFileSync)(file2, "utf8").startsWith(OPENCODE_MARKER)) return false;
+      (0, import_node_fs2.rmSync)(file2);
+      return true;
+    case "amp":
+      if (!(0, import_node_fs2.readFileSync)(file2, "utf8").startsWith(AMP_MARKER)) return false;
+      (0, import_node_fs2.rmSync)(file2);
+      return true;
+    case "kimi": {
+      const text = (0, import_node_fs2.readFileSync)(file2, "utf8");
+      const kept = stripKimi(text);
+      if (kept === text) return false;
+      (0, import_node_fs2.writeFileSync)(file2, kept);
+      return true;
+    }
+    case "goose": {
+      const root = (0, import_node_path3.dirname)((0, import_node_path3.dirname)(file2));
+      if (readJson((0, import_node_path3.join)(root, "plugin.json")).name !== GOOSE_PLUGIN.name) return false;
+      (0, import_node_fs2.rmSync)(root, { recursive: true, force: true });
+      return true;
+    }
+    case "antigravity": {
+      const config2 = readJson(file2);
+      if (!("agenthub" in config2)) return false;
+      delete config2.agenthub;
+      writeJson(file2, config2);
+      return true;
+    }
+    case "copilot":
+    case "cursor":
+    case "crush": {
+      const config2 = readJson(file2);
+      if (!config2.hooks) return false;
+      let changed = false;
+      for (const [event, entries] of Object.entries(config2.hooks)) {
+        const kept = entries.filter((h) => !isOurs(h));
+        if (kept.length !== entries.length) changed = true;
+        if (kept.length) config2.hooks[event] = kept;
+        else delete config2.hooks[event];
+      }
+      if (!changed) return false;
+      const empty = !Object.keys(config2.hooks).length && Object.keys(config2).every((k) => k === "version" || k === "hooks");
+      if (harness === "copilot" && empty) (0, import_node_fs2.rmSync)(file2);
+      else writeJson(file2, config2);
+      return true;
+    }
+    default: {
+      const config2 = readJson(file2);
+      const hooks = harness === "droid" ? config2 : config2.hooks;
+      if (!hooks || typeof hooks !== "object") return false;
+      let changed = false;
+      for (const [event, groups] of Object.entries(hooks)) {
+        if (!Array.isArray(groups)) continue;
+        const kept = keepOthers(groups);
+        if (kept.length !== groups.length || kept.some((g, i) => g.hooks.length !== groups[i].hooks.length)) changed = true;
+        if (kept.length) hooks[event] = kept;
+        else delete hooks[event];
+      }
+      if (changed) writeJson(file2, config2);
+      return changed;
+    }
+  }
+}
+function keepOthers(groups) {
+  return (groups ?? []).map((g) => ({ ...g, hooks: (g.hooks ?? []).filter((h) => !isOurs(h)) })).filter((g) => g.hooks.length);
+}
+function stripKimi(text) {
+  const start = text.indexOf(KIMI_BEGIN);
+  if (start < 0) return text;
+  const end = text.indexOf(KIMI_END, start);
+  const after = end < 0 ? "" : text.slice(end + KIMI_END.length).replace(/^\n/, "");
+  return (text.slice(0, start).replace(/\n+$/, "\n") + after).replace(/^\n+$/, "");
+}
+function readJson(file2) {
+  return (0, import_node_fs2.existsSync)(file2) ? JSON.parse((0, import_node_fs2.readFileSync)(file2, "utf8")) : {};
+}
+function writeJson(file2, value) {
+  (0, import_node_fs2.writeFileSync)(file2, JSON.stringify(value, null, 2) + "\n");
+}
+var import_node_fs2, import_node_os2, import_node_path3, HARNESSES, USER_SCOPE_ONLY, EVENTS, CLAUDE_PAIRS, HARNESS_EVENTS, WAIT_MAX_S, WAIT_TIMEOUT_S, TIMEOUT_S, KIMI_BEGIN, KIMI_END, GOOSE_PLUGIN, OURS, isOurs;
+var init_hooks = __esm({
+  "src/cli/hooks.ts"() {
+    "use strict";
+    import_node_fs2 = require("node:fs");
+    import_node_os2 = require("node:os");
+    import_node_path3 = require("node:path");
+    init_amp_plugin();
+    init_opencode_plugin();
+    HARNESSES = ["claude-code", "codex", "copilot", "opencode", "droid", "gemini", "qwen", "cursor", "antigravity", "kimi", "goose", "amp", "crush"];
+    USER_SCOPE_ONLY = /* @__PURE__ */ new Set(["kimi"]);
+    EVENTS = ["SessionStart", "UserPromptSubmit", "PostToolUse", "Stop", "SessionEnd"];
+    CLAUDE_PAIRS = [
+      ["SessionStart", "session-start"],
+      ["UserPromptSubmit", "prompt"],
+      ["PostToolUse", "post-tool"],
+      ["Stop", "stop"],
+      ["SessionEnd", "session-end"]
+    ];
+    HARNESS_EVENTS = {
+      copilot: [
+        ["sessionStart", "session-start"],
+        ["userPromptSubmitted", "prompt"],
+        ["postToolUse", "post-tool"],
+        ["agentStop", "stop"],
+        ["sessionEnd", "session-end"]
+      ],
+      droid: CLAUDE_PAIRS,
+      qwen: CLAUDE_PAIRS,
+      gemini: [
+        ["SessionStart", "session-start"],
+        ["BeforeAgent", "prompt"],
+        ["AfterTool", "post-tool"],
+        ["AfterAgent", "stop"],
+        ["SessionEnd", "session-end"]
+      ],
+      // beforeSubmitPrompt can't add context, so prompts are left out.
+      cursor: [
+        ["sessionStart", "session-start"],
+        ["postToolUse", "post-tool"],
+        ["stop", "stop"],
+        ["sessionEnd", "session-end"]
+      ],
+      // PostToolUse can't add context; PreInvocation runs before each model call, so it stands in
+      // for both prompts and tool calls. There's no session end.
+      antigravity: [
+        ["SessionStart", "session-start"],
+        ["PreInvocation", "post-tool"],
+        ["Stop", "stop"]
+      ],
+      // SessionStart and PostToolUse only observe; the first prompt gets the session-start notice.
+      kimi: [
+        ["UserPromptSubmit", "prompt"],
+        ["Stop", "stop"],
+        ["SessionEnd", "session-end"]
+      ],
+      // Crush has only PreToolUse; its first one in a session gets the session-start notice.
+      crush: [["PreToolUse", "post-tool"]],
+      // Goose hooks can't add context: Stop keeps a turn going for a request, and presence.
+      goose: [
+        ["Stop", "stop"],
+        ["SessionEnd", "session-end"]
+      ]
+    };
+    WAIT_MAX_S = 12 * 3600;
+    WAIT_TIMEOUT_S = WAIT_MAX_S + 60;
+    TIMEOUT_S = { "claude-code": {}, codex: { SessionEnd: 3 } };
+    KIMI_BEGIN = "# >>> agenthub hooks: agenthub hooks uninstall kimi removes this block >>>";
+    KIMI_END = "# <<< agenthub hooks <<<";
+    GOOSE_PLUGIN = { name: "agenthub", version: "1.0.0", description: "Agent Hub: handle hub requests that arrive during a turn, and presence" };
+    OURS = [/^(?:\S*[\\/])?agenthub(?:\.js|\.exe)?\s+(?:notify|wait)\b/i, /^"(?:[^"]*[\\/])?agenthub(?:\.js|\.exe)?"\s+(?:notify|wait)\b/i];
+    isOurs = (h) => typeof h?.command === "string" && OURS.some((r) => r.test(h.command));
+  }
+});
+
 // src/cli/session.ts
 var session_exports = {};
 __export(session_exports, {
@@ -463,6 +1073,98 @@ var init_update = __esm({
   }
 });
 
+// src/cli/kimi.ts
+var kimi_exports = {};
+__export(kimi_exports, {
+  KIMI_DEFAULT_PORT: () => KIMI_DEFAULT_PORT,
+  deliverToKimi: () => deliverToKimi,
+  kimiHome: () => kimiHome,
+  kimiServers: () => kimiServers,
+  kimiWakeable: () => kimiWakeable,
+  startKimiWaiter: () => startKimiWaiter
+});
+function kimiHome(env, home = (0, import_node_os3.homedir)()) {
+  return env.KIMI_CODE_HOME || (0, import_node_path7.join)(home, ".kimi-code");
+}
+function kimiWakeable(payload) {
+  const client = payload?.client_type;
+  return typeof payload?.session_id === "string" && typeof client === "string" && client !== TUI_CLIENT;
+}
+function kimiServers(env, home = (0, import_node_os3.homedir)()) {
+  const dir = (0, import_node_path7.join)(kimiHome(env, home), "server", "instances");
+  const urls = [];
+  let files = [];
+  try {
+    files = (0, import_node_fs6.readdirSync)(dir);
+  } catch {
+  }
+  for (const f of files) {
+    try {
+      const entry = JSON.parse((0, import_node_fs6.readFileSync)((0, import_node_path7.join)(dir, f), "utf8"));
+      if (typeof entry.url === "string" && /^https?:\/\//.test(entry.url)) urls.push(entry.url.replace(/\/+$/, ""));
+      else if (typeof entry.port === "number") {
+        const host = typeof entry.host === "string" && entry.host && entry.host !== "0.0.0.0" ? entry.host : "127.0.0.1";
+        urls.push(`http://${host}:${entry.port}`);
+      }
+    } catch {
+    }
+  }
+  urls.push(`http://127.0.0.1:${KIMI_DEFAULT_PORT}`);
+  return [...new Set(urls)];
+}
+async function deliverToKimi(sessionId, text, deps = {}) {
+  const env = deps.env ?? process.env;
+  const fetchFn = deps.fetch ?? fetch;
+  let token = "";
+  try {
+    token = (0, import_node_fs6.readFileSync)((0, import_node_path7.join)(kimiHome(env, deps.home), "server.token"), "utf8").trim();
+  } catch {
+  }
+  for (const base of kimiServers(env, deps.home)) {
+    try {
+      const res = await fetchFn(`${base}/api/v1/sessions/${encodeURIComponent(sessionId)}/prompts`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...token ? { Authorization: `Bearer ${token}` } : {} },
+        body: JSON.stringify({ content: [{ type: "text", text }] }),
+        signal: AbortSignal.timeout(1e4)
+      });
+      await res.body?.cancel().catch(() => {
+      });
+      if (res.ok) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function startKimiWaiter(payload, env = process.env) {
+  const script = process.argv[1];
+  const args = script && /\.[cm]?[jt]s$/.test(script) ? [script, "wait", "--deliver", "kimi"] : ["wait", "--deliver", "kimi"];
+  try {
+    const child = (0, import_node_child_process4.spawn)(process.execPath, args, {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+      env: { ...env, AGENTHUB_WAIT_PAYLOAD: JSON.stringify(payload) }
+    });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+var import_node_child_process4, import_node_fs6, import_node_os3, import_node_path7, KIMI_DEFAULT_PORT, TUI_CLIENT;
+var init_kimi = __esm({
+  "src/cli/kimi.ts"() {
+    "use strict";
+    import_node_child_process4 = require("node:child_process");
+    import_node_fs6 = require("node:fs");
+    import_node_os3 = require("node:os");
+    import_node_path7 = require("node:path");
+    KIMI_DEFAULT_PORT = 58627;
+    TUI_CLIENT = "kimi_code_cli";
+  }
+});
+
 // src/cli/watch.ts
 var watch_exports = {};
 __export(watch_exports, {
@@ -611,15 +1313,19 @@ var init_watch = __esm({
 var wait_exports = {};
 __export(wait_exports, {
   DEFAULT_WAIT_MS: () => DEFAULT_WAIT_MS,
+  actMode: () => actMode,
+  actSetting: () => actSetting,
   addPending: () => addPending,
   claimFile: () => claimFile,
+  continueNotice: () => continueNotice,
   mergeInbox: () => mergeInbox,
   pendingFile: () => pendingFile,
   releaseWaiter: () => releaseWaiter,
   takePending: () => takePending,
   wait: () => wait,
   wakeMode: () => wakeMode,
-  wakeSetting: () => wakeSetting
+  wakeSetting: () => wakeSetting,
+  wokenNotice: () => wokenNotice
 });
 function wakeSetting(env, origin) {
   const settings = readSettings(env);
@@ -630,23 +1336,39 @@ function wakeSetting(env, origin) {
   const mode = ["0", "false", "off", "no"].includes(v) ? "off" : v === "all" ? "all" : "requests";
   return { mode, from };
 }
+function actSetting(env, origin) {
+  const settings = readSettings(env);
+  const key = origin ? projectKey(origin) : void 0;
+  const project = key ? settings.wake_act_projects?.[key] : void 0;
+  const [raw, from] = env.AGENTHUB_WAKE_ACT !== void 0 ? [env.AGENTHUB_WAKE_ACT, "env"] : project ? [project, "project"] : settings.wake_act ? [settings.wake_act, "user"] : ["", "default"];
+  return { mode: raw.trim().toLowerCase() === "ask" ? "ask" : "auto", from };
+}
+function actMode(env, origin) {
+  return actSetting(env, origin).mode;
+}
+function wokenNotice(act) {
+  return act === "ask" ? `Agent Hub woke this session while it was idle, for new hub messages. ${ASK_FIRST}` : WOKEN;
+}
+function continueNotice(act) {
+  return act === "ask" ? `These came in during the turn. ${ASK_FIRST}` : "Handle these as the Agent Hub rules say before you finish.";
+}
 function wakeMode(env, origin) {
   return wakeSetting(env, origin).mode;
 }
 function claimFile(env, key) {
-  return (0, import_node_path7.join)(cacheDir(env), `wait-${key}.json`);
+  return (0, import_node_path8.join)(cacheDir(env), `wait-${key}.json`);
 }
 function pendingFile(env, key) {
-  return (0, import_node_path7.join)(cacheDir(env), `pending-${key}.json`);
+  return (0, import_node_path8.join)(cacheDir(env), `pending-${key}.json`);
 }
 function releaseWaiter(env, key) {
-  (0, import_node_fs6.rmSync)(claimFile(env, key), { force: true });
+  (0, import_node_fs7.rmSync)(claimFile(env, key), { force: true });
 }
 function takePending(env, key) {
   const file2 = pendingFile(env, key);
   try {
-    const pending = JSON.parse((0, import_node_fs6.readFileSync)(file2, "utf8"));
-    (0, import_node_fs6.rmSync)(file2, { force: true });
+    const pending = JSON.parse((0, import_node_fs7.readFileSync)(file2, "utf8"));
+    (0, import_node_fs7.rmSync)(file2, { force: true });
     return pending;
   } catch {
     return void 0;
@@ -657,12 +1379,12 @@ function addPending(env, key, inbox) {
   const file2 = pendingFile(env, key);
   let before;
   try {
-    before = JSON.parse((0, import_node_fs6.readFileSync)(file2, "utf8"));
+    before = JSON.parse((0, import_node_fs7.readFileSync)(file2, "utf8"));
   } catch {
     before = void 0;
   }
-  (0, import_node_fs6.mkdirSync)((0, import_node_path7.join)(file2, ".."), { recursive: true, mode: 448 });
-  (0, import_node_fs6.writeFileSync)(file2, JSON.stringify(mergeInbox(before, inbox)), { mode: 384 });
+  (0, import_node_fs7.mkdirSync)((0, import_node_path8.join)(file2, ".."), { recursive: true, mode: 448 });
+  (0, import_node_fs7.writeFileSync)(file2, JSON.stringify(mergeInbox(before, inbox)), { mode: 384 });
 }
 function mergeInbox(earlier, later) {
   if (!earlier) return later;
@@ -677,23 +1399,24 @@ async function wait(opts, deps) {
   const fetchFn = deps.fetch ?? fetch;
   const now = deps.now ?? Date.now;
   const sleep = deps.sleep ?? defaultSleep2;
-  const cwd = typeof opts.payload?.cwd === "string" ? opts.payload.cwd : deps.cwd ?? process.cwd();
+  const cwd = payloadCwd(opts.payload) ?? deps.cwd ?? process.cwd();
   const hub = hubUrl(env);
   if (!hub) return NOTHING;
   const { origin, upstream } = (deps.remotes ?? gitRemotes)(cwd);
   if (!origin) return NOTHING;
   const mode = wakeMode(env, origin);
   if (mode === "off") return NOTHING;
+  const act = actMode(env, origin);
   if (!await onHub(hub, [origin, upstream], fetchFn, env, now).catch(() => false)) return NOTHING;
   const agentName = hookAgentName(opts.payload, env);
   const key = sessionKey(hub, origin, agentName);
   const id = (0, import_node_crypto2.randomBytes)(8).toString("hex");
   const claim2 = claimFile(env, key);
-  (0, import_node_fs6.mkdirSync)((0, import_node_path7.join)(claim2, ".."), { recursive: true, mode: 448 });
-  (0, import_node_fs6.writeFileSync)(claim2, JSON.stringify({ id, pid: process.pid, at: now() }));
+  (0, import_node_fs7.mkdirSync)((0, import_node_path8.join)(claim2, ".."), { recursive: true, mode: 448 });
+  (0, import_node_fs7.writeFileSync)(claim2, JSON.stringify({ id, pid: process.pid, at: now() }));
   const holds = () => {
     try {
-      return JSON.parse((0, import_node_fs6.readFileSync)(claim2, "utf8")).id === id;
+      return JSON.parse((0, import_node_fs7.readFileSync)(claim2, "utf8")).id === id;
     } catch {
       return false;
     }
@@ -740,7 +1463,7 @@ async function wait(opts, deps) {
             const data = JSON.parse(ev.data);
             const wakes = data.messages.some((m) => m.new && (mode === "all" || m.type !== "fyi"));
             if (wakes && holds()) return { code: 2, text: `${formatInbox(mergeInbox(takePending(env, key), data))}
-${WOKEN}` };
+${wokenNotice(act)}` };
             addPending(env, key, data);
           } else if (ev.event === "end") {
             const { reason } = JSON.parse(ev.data);
@@ -756,7 +1479,7 @@ ${WOKEN}` };
     clearInterval(check2);
     opts.signal?.removeEventListener("abort", stop);
     ac.abort();
-    if (holds()) (0, import_node_fs6.rmSync)(claim2, { force: true });
+    if (holds()) (0, import_node_fs7.rmSync)(claim2, { force: true });
   }
 }
 function defaultSleep2(ms, signal) {
@@ -768,13 +1491,13 @@ function defaultSleep2(ms, signal) {
     }, { once: true });
   });
 }
-var import_node_crypto2, import_node_fs6, import_node_path7, DEFAULT_WAIT_MS, MAX_BACKOFF_MS2, NOTHING, WOKEN;
+var import_node_crypto2, import_node_fs7, import_node_path8, DEFAULT_WAIT_MS, MAX_BACKOFF_MS2, NOTHING, ASK_FIRST, WOKEN;
 var init_wait = __esm({
   "src/cli/wait.ts"() {
     "use strict";
     import_node_crypto2 = require("node:crypto");
-    import_node_fs6 = require("node:fs");
-    import_node_path7 = require("node:path");
+    import_node_fs7 = require("node:fs");
+    import_node_path8 = require("node:path");
     init_paths();
     init_notify();
     init_session();
@@ -783,6 +1506,7 @@ var init_wait = __esm({
     DEFAULT_WAIT_MS = 12 * 36e5;
     MAX_BACKOFF_MS2 = 6e4;
     NOTHING = { code: 0, text: "" };
+    ASK_FIRST = "The user asked to be asked first (agenthub wake ask): don't act on these yet. Tell the user in a few lines who sent what, ask which ones to handle, and stop. Don't claim, answer, complete or decline any of them until the user says so.";
     WOKEN = "Agent Hub woke this session while it was idle, so the user may be away. Handle these as the Agent Hub rules say: answer questions and do reviews read-only, and complete them; leave a handoff, or anything that would run commands, push, merge or touch secrets, for the user and say so.";
   }
 });
@@ -791,31 +1515,48 @@ var init_wait = __esm({
 var notify_exports = {};
 __export(notify_exports, {
   CARD_NUDGE_MS: () => CARD_NUDGE_MS,
+  NOTIFY_FORMATS: () => NOTIFY_FORMATS,
   TASK_CHECK_MS: () => TASK_CHECK_MS,
   formatInbox: () => formatInbox,
   gitBranch: () => gitBranch,
   gitRemotes: () => gitRemotes,
   hookAgentName: () => hookAgentName,
   notify: () => notify,
+  notifyHook: () => notifyHook,
   onHub: () => onHub,
+  payloadCwd: () => payloadCwd,
   sessionKey: () => sessionKey
 });
 async function notify(opts, deps) {
+  return (await notifyHook(opts, deps)).stdout;
+}
+async function notifyHook(opts, deps) {
   try {
     const event = opts.event ?? HOOK_EVENTS[String(opts.payload?.hook_event_name ?? "")] ?? "post-tool";
     const update = event === "session-start" && deps.version ? updateNotice(deps.version, { env: deps.env ?? process.env, fetch: deps.fetch ?? fetch, ...deps.now ? { now: deps.now } : {} }) : Promise.resolve("");
     const [text, notice] = await Promise.all([run(opts, event, deps).catch(() => ""), update.catch(() => "")]);
-    if (typeof text === "object") return text.raw;
-    return render(opts.format, event, [text, notice].filter(Boolean).join("\n"));
+    if (typeof text === "object") return text;
+    return { stdout: render(opts.format, event, [text, notice].filter(Boolean).join("\n")) };
   } catch {
-    return "";
+    return { stdout: "" };
+  }
+}
+function payloadCwd(payload) {
+  const first = (v) => Array.isArray(v) ? v[0] : void 0;
+  const dir = payload?.cwd ?? payload?.working_dir ?? first(payload?.workspace_roots) ?? first(payload?.workspacePaths);
+  if (typeof dir !== "string" || !dir) return void 0;
+  if (!dir.startsWith("file:")) return dir;
+  try {
+    return (0, import_node_url.fileURLToPath)(dir);
+  } catch {
+    return void 0;
   }
 }
 async function run(opts, event, deps) {
   const env = deps.env ?? process.env;
   const now = deps.now ?? Date.now;
   const fetchFn = deps.fetch ?? fetch;
-  const cwd = typeof opts.payload?.cwd === "string" ? opts.payload.cwd : deps.cwd ?? process.cwd();
+  const cwd = payloadCwd(opts.payload) ?? deps.cwd ?? process.cwd();
   const out = (text) => text;
   const hub = hubUrl(env);
   if (!hub) return "";
@@ -825,24 +1566,34 @@ async function run(opts, event, deps) {
   const agentName = hookAgentName(opts.payload, env);
   const throttleKey = sessionKey(hub, origin, agentName);
   if (event !== "stop") releaseWaiter(env, throttleKey);
+  if (event === FIRST_EVENT_STARTS[opts.format]) {
+    const started = (0, import_node_path9.join)(cacheDir(env), `started-${throttleKey}.json`);
+    if (!readFlag(started)) {
+      writeFlag(started);
+      event = "session-start";
+    }
+  }
   const wait2 = THROTTLE_MS[event];
-  if (wait2 && !throttle((0, import_node_path8.join)(cacheDir(env), `notify-${throttleKey}.json`), wait2, now())) return "";
+  if (wait2 && !throttle((0, import_node_path9.join)(cacheDir(env), `notify-${throttleKey}.json`), wait2, now())) return "";
   const token = await accessToken(hub, { store: deps.store, fetch: fetchFn, env, now });
   if (!token) return event === "session-start" ? out(`Agent Hub: not signed in. Ask the user to run \`agenthub login --hub ${hub}\` to get teammates' messages here.`) : "";
   const who = { project: origin, ...upstream ? { upstream } : {}, ...agentName ? { agent_name: agentName } : {} };
   const headers = { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };
   const signal = AbortSignal.timeout(3e3);
-  if (event === "stop" && opts.format === "codex" && wakeMode(env, origin) !== "off") {
+  const block = STOP_BLOCK[opts.format];
+  const stopped = [opts.payload?.status, opts.payload?.terminationReason].some((v) => typeof v === "string" && /abort|cancel|interrupt/i.test(v));
+  if (event === "stop" && block && !stopped && wakeMode(env, origin) !== "off") {
     const res2 = await fetchFn(`${hub}/api/inbox?${new URLSearchParams(who)}`, { headers, signal });
     if (res2.ok) {
       const inbox2 = mergeInbox(takePending(env, throttleKey), await res2.json());
       const mode = wakeMode(env, origin);
       if (inbox2.messages.some((m) => m.new && (mode === "all" || m.type !== "fyi"))) {
-        return { raw: JSON.stringify({ decision: "block", reason: `${formatInbox(inbox2)}
-Handle these as the Agent Hub rules say before you finish.` }) };
+        return block(`${formatInbox(inbox2)}
+${continueNotice(actMode(env, origin))}`);
       }
       addPending(env, throttleKey, inbox2);
     }
+    if (opts.format === "kimi" && kimiWakeable(opts.payload)) (deps.startKimiWaiter ?? startKimiWaiter)(opts.payload, env);
   }
   if (event === "stop" || event === "session-end") {
     await fetchFn(`${hub}/api/presence`, {
@@ -858,14 +1609,14 @@ Handle these as the Agent Hub rules say before you finish.` }) };
     const { membership } = await res.json().catch(() => ({}));
     const args = [`remote="${origin}"`, ...upstream ? [`upstream="${upstream}"`] : [], ...agentName ? [`agent_name="${agentName}"`] : []].join(", ");
     const keep = agentName ? " Use exactly that agent_name: it's how hub notices find this session." : "";
-    const waitingFile = (0, import_node_path8.join)(cacheDir(env), `waiting-${throttleKey}.json`);
+    const waitingFile = (0, import_node_path9.join)(cacheDir(env), `waiting-${throttleKey}.json`);
     const wasWaiting = readFlag(waitingFile);
     if (membership === "pending") {
       if (!wasWaiting) writeFlag(waitingFile);
       return event === "session-start" || !wasWaiting ? out("Agent Hub: your request to join this project is waiting for a project admin's approval. You'll be told here once it's approved.") : "";
     }
     if (wasWaiting) {
-      (0, import_node_fs7.rmSync)(waitingFile, { force: true });
+      (0, import_node_fs8.rmSync)(waitingFile, { force: true });
       if (membership === "active") return out(`Agent Hub: a project admin approved you. Call the agenthub join_project tool with ${args} to join.${keep}`);
       return out("Agent Hub: a project admin turned down your request to join this project.");
     }
@@ -879,7 +1630,7 @@ Handle these as the Agent Hub rules say before you finish.` }) };
   const card = await keepCardCurrent(inbox, event, {
     // Without a name the hub picks the user's latest agent here, which may be another session's.
     branch: agentName ? (deps.branch ?? gitBranch)(cwd) : void 0,
-    stateFile: (0, import_node_path8.join)(cacheDir(env), `card-${throttleKey}.json`),
+    stateFile: (0, import_node_path9.join)(cacheDir(env), `card-${throttleKey}.json`),
     now: now(),
     post: (fields) => fetchFn(`${hub}/api/card`, { method: "POST", headers, body: JSON.stringify({ ...who, ...fields }), signal })
   }).catch(() => "");
@@ -909,18 +1660,18 @@ async function keepCardCurrent(inbox, event, ctx) {
 }
 function readState(path) {
   try {
-    return JSON.parse((0, import_node_fs7.readFileSync)(path, "utf8"));
+    return JSON.parse((0, import_node_fs8.readFileSync)(path, "utf8"));
   } catch {
     return {};
   }
 }
 function writeState(path, state) {
-  (0, import_node_fs7.mkdirSync)((0, import_node_path8.join)(path, ".."), { recursive: true, mode: 448 });
-  (0, import_node_fs7.writeFileSync)(path, JSON.stringify(state));
+  (0, import_node_fs8.mkdirSync)((0, import_node_path9.join)(path, ".."), { recursive: true, mode: 448 });
+  (0, import_node_fs8.writeFileSync)(path, JSON.stringify(state));
 }
 function gitBranch(cwd) {
   try {
-    return (0, import_node_child_process4.execFileSync)("git", ["-C", cwd, "branch", "--show-current"], { stdio: ["ignore", "pipe", "ignore"], timeout: 1e3 }).toString().trim() || void 0;
+    return (0, import_node_child_process5.execFileSync)("git", ["-C", cwd, "branch", "--show-current"], { stdio: ["ignore", "pipe", "ignore"], timeout: 1e3 }).toString().trim() || void 0;
   } catch {
     return void 0;
   }
@@ -930,7 +1681,7 @@ function sessionKey(hub, origin, agentName) {
 }
 function hookAgentName(payload, env) {
   if (env.AGENTHUB_AGENT_NAME) return env.AGENTHUB_AGENT_NAME;
-  const session = payload?.session_id ?? payload?.sessionId;
+  const session = payload?.session_id ?? payload?.sessionId ?? payload?.conversation_id ?? payload?.conversationId;
   if (typeof session !== "string" || !session) return void 0;
   return `s-${(0, import_node_crypto3.createHash)("sha256").update(session).digest("hex").slice(0, 8)}`;
 }
@@ -963,38 +1714,44 @@ function clean(s) {
 }
 function render(format, event, text) {
   if (!text) return "";
-  if (format === "text") return text;
+  if (format === "text" || format === "kimi" || format === "amp" || format === "roo") return text;
+  if (format === "goose") return "";
+  if (event === "stop" || event === "session-end") return "";
+  if (format === "crush") return JSON.stringify({ context: text });
+  if (format === "cursor") return JSON.stringify({ additional_context: text });
+  if (format === "antigravity") return JSON.stringify({ injectSteps: [{ systemMessage: text }] });
+  if (format === "gemini") return JSON.stringify({ hookSpecificOutput: { hookEventName: GEMINI_EVENT_NAMES[event], additionalContext: text } });
   if (format === "codex" && event === "session-start") return text;
   if (format === "copilot") return JSON.stringify({ additionalContext: text });
   return JSON.stringify({ hookSpecificOutput: { hookEventName: EVENT_NAMES[event], additionalContext: text } });
 }
 function readFlag(path) {
   try {
-    (0, import_node_fs7.readFileSync)(path);
+    (0, import_node_fs8.readFileSync)(path);
     return true;
   } catch {
     return false;
   }
 }
 function writeFlag(path) {
-  (0, import_node_fs7.mkdirSync)((0, import_node_path8.join)(path, ".."), { recursive: true, mode: 448 });
-  (0, import_node_fs7.writeFileSync)(path, "{}");
+  (0, import_node_fs8.mkdirSync)((0, import_node_path9.join)(path, ".."), { recursive: true, mode: 448 });
+  (0, import_node_fs8.writeFileSync)(path, "{}");
 }
 function throttle(path, waitMs, now) {
   try {
-    const last = JSON.parse((0, import_node_fs7.readFileSync)(path, "utf8")).at;
+    const last = JSON.parse((0, import_node_fs8.readFileSync)(path, "utf8")).at;
     if (now - last < waitMs) return false;
   } catch {
   }
-  (0, import_node_fs7.mkdirSync)((0, import_node_path8.join)(path, ".."), { recursive: true, mode: 448 });
-  (0, import_node_fs7.writeFileSync)(path, JSON.stringify({ at: now }));
+  (0, import_node_fs8.mkdirSync)((0, import_node_path9.join)(path, ".."), { recursive: true, mode: 448 });
+  (0, import_node_fs8.writeFileSync)(path, JSON.stringify({ at: now }));
   return true;
 }
 async function onHub(hub, remotes, fetchFn, env, now) {
-  const path = (0, import_node_path8.join)(cacheDir(env), `providers-${(0, import_node_crypto3.createHash)("sha256").update(hub).digest("hex").slice(0, 16)}.json`);
+  const path = (0, import_node_path9.join)(cacheDir(env), `providers-${(0, import_node_crypto3.createHash)("sha256").update(hub).digest("hex").slice(0, 16)}.json`);
   let providers;
   try {
-    const cached2 = JSON.parse((0, import_node_fs7.readFileSync)(path, "utf8"));
+    const cached2 = JSON.parse((0, import_node_fs8.readFileSync)(path, "utf8"));
     if (now() - cached2.at < PROVIDERS_TTL_MS) providers = cached2.providers;
   } catch {
   }
@@ -1002,8 +1759,8 @@ async function onHub(hub, remotes, fetchFn, env, now) {
     const res = await fetchFn(`${hub}/api/providers`, { signal: AbortSignal.timeout(3e3) });
     if (!res.ok) return false;
     providers = (await res.json()).providers;
-    (0, import_node_fs7.mkdirSync)((0, import_node_path8.join)(path, ".."), { recursive: true, mode: 448 });
-    (0, import_node_fs7.writeFileSync)(path, JSON.stringify({ at: now(), providers }));
+    (0, import_node_fs8.mkdirSync)((0, import_node_path9.join)(path, ".."), { recursive: true, mode: 448 });
+    (0, import_node_fs8.writeFileSync)(path, JSON.stringify({ at: now(), providers }));
   }
   const hosts = /* @__PURE__ */ new Set();
   for (const p of providers) {
@@ -1022,7 +1779,7 @@ async function onHub(hub, remotes, fetchFn, env, now) {
 function gitRemotes(cwd) {
   const get = (name) => {
     try {
-      return (0, import_node_child_process4.execFileSync)("git", ["-C", cwd, "remote", "get-url", name], { stdio: ["ignore", "pipe", "ignore"], timeout: 1e3 }).toString().trim() || void 0;
+      return (0, import_node_child_process5.execFileSync)("git", ["-C", cwd, "remote", "get-url", name], { stdio: ["ignore", "pipe", "ignore"], timeout: 1e3 }).toString().trim() || void 0;
     } catch {
       return void 0;
     }
@@ -1031,26 +1788,33 @@ function gitRemotes(cwd) {
   const upstream = origin ? get("upstream") : void 0;
   return { ...origin ? { origin } : {}, ...upstream ? { upstream } : {} };
 }
-var import_node_child_process4, import_node_crypto3, import_node_fs7, import_node_path8, HOOK_EVENTS, EVENT_NAMES, THROTTLE_MS, PROVIDERS_TTL_MS, CARD_NUDGE_MS, TASK_CHECK_MS;
+var import_node_child_process5, import_node_crypto3, import_node_fs8, import_node_path9, import_node_url, NOTIFY_FORMATS, HOOK_EVENTS, EVENT_NAMES, GEMINI_EVENT_NAMES, THROTTLE_MS, PROVIDERS_TTL_MS, STOP_BLOCK, FIRST_EVENT_STARTS, CARD_NUDGE_MS, TASK_CHECK_MS;
 var init_notify = __esm({
   "src/cli/notify.ts"() {
     "use strict";
-    import_node_child_process4 = require("node:child_process");
+    import_node_child_process5 = require("node:child_process");
     import_node_crypto3 = require("node:crypto");
-    import_node_fs7 = require("node:fs");
-    import_node_path8 = require("node:path");
+    import_node_fs8 = require("node:fs");
+    import_node_path9 = require("node:path");
+    import_node_url = require("node:url");
     init_registry();
     init_paths();
     init_session();
     init_settings();
     init_update();
+    init_kimi();
     init_wait();
+    NOTIFY_FORMATS = ["claude-code", "codex", "copilot", "droid", "gemini", "qwen", "cursor", "antigravity", "kimi", "goose", "amp", "roo", "crush", "text"];
     HOOK_EVENTS = {
       SessionStart: "session-start",
       UserPromptSubmit: "prompt",
       PostToolUse: "post-tool",
       Stop: "stop",
-      SessionEnd: "session-end"
+      SessionEnd: "session-end",
+      // Gemini CLI
+      BeforeAgent: "prompt",
+      AfterTool: "post-tool",
+      AfterAgent: "stop"
     };
     EVENT_NAMES = {
       "session-start": "SessionStart",
@@ -1059,8 +1823,29 @@ var init_notify = __esm({
       stop: "Stop",
       "session-end": "SessionEnd"
     };
+    GEMINI_EVENT_NAMES = { ...EVENT_NAMES, prompt: "BeforeAgent", "post-tool": "AfterTool", stop: "AfterAgent" };
     THROTTLE_MS = { "post-tool": 3e4, prompt: 1e4 };
     PROVIDERS_TTL_MS = 24 * 36e5;
+    STOP_BLOCK = {
+      codex: (reason) => ({ stdout: JSON.stringify({ decision: "block", reason }) }),
+      copilot: (reason) => ({ stdout: JSON.stringify({ decision: "block", reason }) }),
+      droid: (reason) => ({ stdout: JSON.stringify({ decision: "block", reason }) }),
+      qwen: (reason) => ({ stdout: JSON.stringify({ decision: "block", reason }) }),
+      goose: (reason) => ({ stdout: JSON.stringify({ decision: "block", reason }) }),
+      // The Amp plugin returns agent.end's `continue` with the reason as the next user message.
+      amp: (reason) => ({ stdout: JSON.stringify({ decision: "block", reason }) }),
+      // The Roo Code extension sends the reason to the task with sendMessage.
+      roo: (reason) => ({ stdout: JSON.stringify({ decision: "block", reason }) }),
+      // AfterAgent: deny sends the reason to the agent as a new prompt.
+      gemini: (reason) => ({ stdout: JSON.stringify({ decision: "deny", reason }) }),
+      // stop: Cursor submits followup_message as the next user message.
+      cursor: (reason) => ({ stdout: JSON.stringify({ followup_message: reason }) }),
+      // Stop: the reason is injected as a system message and the agent goes on.
+      antigravity: (reason) => ({ stdout: JSON.stringify({ decision: "continue", reason }) }),
+      // Stop: exit 2 blocks it, with stderr as the reason.
+      kimi: (reason) => ({ stdout: "", stderr: reason, code: 2 })
+    };
+    FIRST_EVENT_STARTS = { kimi: "prompt", crush: "post-tool" };
     CARD_NUDGE_MS = 10 * 6e4;
     TASK_CHECK_MS = 30 * 6e4;
   }
@@ -27704,7 +28489,7 @@ function dispatcherFor(instance) {
   if (!instance.caBundlePath) return void 0;
   let d = dispatchers.get(instance.id);
   if (!d) {
-    const ca = (0, import_node_fs8.readFileSync)(instance.caBundlePath, "utf8");
+    const ca = (0, import_node_fs9.readFileSync)(instance.caBundlePath, "utf8");
     d = new import_undici.Agent({ connect: { ca: [...import_node_tls.rootCertificates, ca] } });
     dispatchers.set(instance.id, d);
   }
@@ -27721,11 +28506,11 @@ function fetchFor(instance, override) {
     signal: AbortSignal.timeout(1e4)
   });
 }
-var import_node_fs8, import_node_tls, import_undici, dispatchers;
+var import_node_fs9, import_node_tls, import_undici, dispatchers;
 var init_http = __esm({
   "src/providers/http.ts"() {
     "use strict";
-    import_node_fs8 = require("node:fs");
+    import_node_fs9 = require("node:fs");
     import_node_tls = require("node:tls");
     import_undici = __toESM(require_undici(), 1);
     dispatchers = /* @__PURE__ */ new Map();
@@ -55604,7 +56389,7 @@ var init_types = __esm({
 
 // src/providers/config.ts
 function loadConfigFile(path, opts = {}) {
-  const read = opts.readFile ?? ((p) => (0, import_node_fs9.readFileSync)(p, "utf8"));
+  const read = opts.readFile ?? ((p) => (0, import_node_fs10.readFileSync)(p, "utf8"));
   let text;
   try {
     text = read(path);
@@ -55615,7 +56400,7 @@ function loadConfigFile(path, opts = {}) {
 }
 function buildConfig(raw, opts = {}) {
   const env = opts.env ?? process.env;
-  const read = opts.readFile ?? ((p) => (0, import_node_fs9.readFileSync)(p, "utf8"));
+  const read = opts.readFile ?? ((p) => (0, import_node_fs10.readFileSync)(p, "utf8"));
   const parsed = configSchema.safeParse(raw);
   if (!parsed.success) {
     throw new ConfigError(
@@ -55796,11 +56581,11 @@ function checkNoHostCollisions(instances) {
     for (const a of inst.remoteAliases) claim2(a.port ? `${a.host}:${a.port}` : a.host, inst.id);
   }
 }
-var import_node_fs9, import_yaml, secretRef, oauthSchema, providerSchema, configSchema, ConfigError;
+var import_node_fs10, import_yaml, secretRef, oauthSchema, providerSchema, configSchema, ConfigError;
 var init_config = __esm({
   "src/providers/config.ts"() {
     "use strict";
-    import_node_fs9 = require("node:fs");
+    import_node_fs10 = require("node:fs");
     import_yaml = __toESM(require_dist(), 1);
     init_zod();
     init_defaults();
@@ -55901,7 +56686,7 @@ var init_admin = __esm({
 });
 
 // src/cli/index.ts
-var import_node_fs10 = require("node:fs");
+var import_node_fs11 = require("node:fs");
 
 // src/cli/credentials.ts
 var import_node_child_process = require("node:child_process");
@@ -56002,278 +56787,8 @@ function credentialStore(env = process.env) {
   return new FileCredentialStore(configDir(env));
 }
 
-// src/cli/hooks.ts
-var import_node_fs2 = require("node:fs");
-var import_node_os2 = require("node:os");
-var import_node_path3 = require("node:path");
-
-// src/cli/opencode-plugin.ts
-var OPENCODE_MARKER = "// Agent Hub plugin for OpenCode, written by `agenthub hooks install opencode`.";
-var PACKAGE_HEADER = `// Agent Hub plugin for OpenCode, from the @theagenthub/opencode npm package.
-// Needs the agenthub CLI: curl -fsSL https://get.theagenthub.app | sh`;
-var PACKAGE_COMMAND = `import { existsSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-const COMMAND =
-  process.env.AGENTHUB_BIN ||
-  [join(homedir(), ".local", "bin", "agenthub"), join(process.env.LOCALAPPDATA || homedir(), "Programs", "agenthub", "agenthub.exe")].find((f) => existsSync(f)) ||
-  "agenthub";`;
-function opencodePlugin(command, as = "file") {
-  const header = as === "package" ? PACKAGE_HEADER : `${OPENCODE_MARKER}
-// Re-run that command to update it, or \`agenthub hooks uninstall opencode\` to remove it.`;
-  return `${header}
-import { spawn } from "node:child_process";
-
-${as === "package" ? PACKAGE_COMMAND : `const COMMAND = ${JSON.stringify(command)};`}
-const TIMEOUT_MS = 5000;
-
-function notify(event, sessionID, cwd) {
-  return new Promise((resolve) => {
-    let out = "";
-    let child;
-    try {
-      child = spawn(COMMAND, ["notify", "--format", "text", "--event", event], {
-        cwd,
-        stdio: ["pipe", "pipe", "ignore"],
-        windowsHide: true,
-        shell: process.platform === "win32",
-      });
-    } catch {
-      return resolve("");
-    }
-    const timer = setTimeout(() => {
-      child.kill();
-      resolve("");
-    }, TIMEOUT_MS);
-    child.stdout.on("data", (chunk) => (out += chunk));
-    child.on("error", () => {
-      clearTimeout(timer);
-      resolve("");
-    });
-    child.on("close", () => {
-      clearTimeout(timer);
-      resolve(out.trim());
-    });
-    child.stdin.on("error", () => {});
-    child.stdin.end(JSON.stringify({ session_id: sessionID, cwd }));
-  });
-}
-
-/** Runs \`agenthub wait\`; resolves to the text to wake the session with, or "" when it shouldn't. */
-function waitForMessage(sessionID, cwd, children) {
-  return new Promise((resolve) => {
-    let out = "";
-    let child;
-    try {
-      child = spawn(COMMAND, ["wait"], { cwd, stdio: ["pipe", "pipe", "ignore"], windowsHide: true, shell: process.platform === "win32" });
-    } catch {
-      return resolve("");
-    }
-    children.get(sessionID)?.kill();
-    children.set(sessionID, child);
-    child.stdout.on("data", (chunk) => (out += chunk));
-    child.on("error", () => resolve(""));
-    child.on("close", (code) => {
-      if (children.get(sessionID) === child) children.delete(sessionID);
-      // An agenthub too old to know \`wait\` exits 2 too, but prints nothing on stdout.
-      resolve(code === 2 ? out.trim() : "");
-    });
-    child.stdin.on("error", () => {});
-    child.stdin.end(JSON.stringify({ session_id: sessionID, cwd }));
-  });
-}
-
-function partId() {
-  return "prt_" + Date.now().toString(16) + Math.random().toString(36).slice(2, 12);
-}
-
-export const AgentHub = async ({ directory, client }) => {
-  const started = new Set();
-  const waiting = new Map();
-  let presence = Promise.resolve();
-  const wake = async (sessionID) => {
-    const send = client?.session?.promptAsync ?? client?.session?.prompt;
-    if (!send) return;
-    const text = await waitForMessage(sessionID, directory, waiting);
-    if (!text) return;
-    try {
-      await send.call(client.session, { path: { id: sessionID }, body: { parts: [{ type: "text", text }] } });
-    } catch {
-      /* the session is gone, or busy again */
-    }
-  };
-  return {
-    "chat.message": async (input, output) => {
-      waiting.get(input.sessionID)?.kill();
-      const first = !started.has(input.sessionID);
-      started.add(input.sessionID);
-      const text = await notify(first ? "session-start" : "prompt", input.sessionID, directory);
-      const messageID = input.messageID ?? output.message?.id;
-      if (!text || !messageID) return;
-      output.parts.push({ id: partId(), sessionID: input.sessionID, messageID, type: "text", text, synthetic: true });
-    },
-    "tool.execute.after": async (input, output) => {
-      const text = await notify("post-tool", input.sessionID, directory);
-      if (text && typeof output.output === "string") output.output += "\\n\\n<agenthub>\\n" + text + "\\n</agenthub>";
-    },
-    // Presence updates don't block OpenCode, but run one at a time so "offline" can't be
-    // overtaken by an earlier "idle".
-    event: async ({ event }) => {
-      if (event.type === "session.idle") {
-        const sessionID = event.properties.sessionID;
-        presence = presence.then(() => notify("stop", sessionID, directory));
-        // Not awaited: it waits as long as the session is idle.
-        presence.then(() => wake(sessionID)).catch(() => {});
-      } else if (event.type === "session.deleted") {
-        waiting.get(event.properties.info.id)?.kill();
-        presence = presence.then(() => notify("session-end", event.properties.info.id, directory));
-      }
-    },
-  };
-};
-
-// OpenCode 2 loads the default export's setup() and ignores the hooks above; OpenCode 1
-// reads the named export (and default.server, the same function). setup() returns early
-// when OpenCode 1 calls it too.
-async function setup(ctx) {
-  if (!ctx?.session?.hook || !ctx.tool?.hook || !ctx.event?.subscribe) return;
-  const directory = ctx.location?.directory ?? process.cwd();
-  const started = new Set();
-  let presence = Promise.resolve();
-  const wrap = (text) => "\\n\\n<agenthub>\\n" + text + "\\n</agenthub>";
-
-  // V2 has no hidden message parts, so the notice is appended to the prompt's text.
-  await ctx.session.hook("prompt", async (event) => {
-    const first = !started.has(event.sessionID);
-    started.add(event.sessionID);
-    const text = await notify(first ? "session-start" : "prompt", event.sessionID, directory);
-    if (text && event.prompt && typeof event.prompt.text === "string") event.prompt.text += wrap(text);
-  });
-  // The model reads a tool's result.content.
-  await ctx.tool.hook("execute.after", async (event) => {
-    if (event.status !== "completed" || !Array.isArray(event.result?.content)) return;
-    const text = await notify("post-tool", event.sessionID, directory);
-    if (text) event.result.content.push({ type: "text", text: wrap(text).trimStart() });
-  });
-
-  const controller = new AbortController();
-  (async () => {
-    const types = ["session.execution.succeeded", "session.execution.failed", "session.execution.interrupted", "session.deleted"];
-    for await (const event of ctx.event.subscribe({ types, signal: controller.signal })) {
-      const sessionID = event.data?.sessionID;
-      if (!sessionID) continue;
-      const kind = event.type === "session.deleted" ? "session-end" : "stop";
-      if (kind === "session-end") started.delete(sessionID);
-      presence = presence.then(() => notify(kind, sessionID, directory));
-    }
-  })().catch(() => {});
-  return () => controller.abort();
-}
-
-export default { id: "agenthub", server: AgentHub, setup };
-`;
-}
-
-// src/cli/hooks.ts
-var HARNESSES = ["claude-code", "codex", "copilot", "opencode"];
-var EVENTS = ["SessionStart", "UserPromptSubmit", "PostToolUse", "Stop", "SessionEnd"];
-var COPILOT_EVENTS = [
-  ["sessionStart", "session-start"],
-  ["userPromptSubmitted", "prompt"],
-  ["postToolUse", "post-tool"],
-  ["agentStop", "stop"],
-  ["sessionEnd", "session-end"]
-];
-var WAIT_MAX_S = 12 * 3600;
-var WAIT_TIMEOUT_S = WAIT_MAX_S + 60;
-var TIMEOUT_S = { "claude-code": {}, codex: { SessionEnd: 3 } };
-function hookFile(harness, scope, cwd, home = (0, import_node_os2.homedir)(), env = process.env) {
-  const user = scope === "user";
-  switch (harness) {
-    case "claude-code":
-      return user ? (0, import_node_path3.join)(home, ".claude", "settings.json") : (0, import_node_path3.join)(cwd, ".claude", "settings.local.json");
-    case "codex":
-      return user ? (0, import_node_path3.join)(home, ".codex", "hooks.json") : (0, import_node_path3.join)(cwd, ".codex", "hooks.json");
-    case "copilot":
-      return user ? (0, import_node_path3.join)(env.COPILOT_HOME || (0, import_node_path3.join)(home, ".copilot"), "hooks", "agenthub.json") : (0, import_node_path3.join)(cwd, ".github", "hooks", "agenthub.json");
-    case "opencode":
-      return user ? (0, import_node_path3.join)(env.XDG_CONFIG_HOME || (0, import_node_path3.join)(home, ".config"), "opencode", "plugins", "agenthub.js") : (0, import_node_path3.join)(cwd, ".opencode", "plugins", "agenthub.js");
-  }
-}
-var OURS = [/^(?:\S*[\\/])?agenthub(?:\.js|\.exe)?\s+(?:notify|wait)\b/i, /^"(?:[^"]*[\\/])?agenthub(?:\.js|\.exe)?"\s+(?:notify|wait)\b/i];
-var isOurs = (h) => typeof h.command === "string" && OURS.some((r) => r.test(h.command));
-function installHooks(harness, file2, command = "agenthub") {
-  (0, import_node_fs2.mkdirSync)((0, import_node_path3.dirname)(file2), { recursive: true });
-  if (harness === "opencode") {
-    (0, import_node_fs2.writeFileSync)(file2, opencodePlugin(command));
-    return ["chat.message", "tool.execute.after", "session.idle", "session.deleted"];
-  }
-  if (harness === "copilot") {
-    const config3 = readJson(file2);
-    config3.version = 1;
-    const hooks2 = config3.hooks ??= {};
-    for (const [event, notifyEvent] of COPILOT_EVENTS) {
-      const kept = (hooks2[event] ?? []).filter((h) => !isOurs(h));
-      hooks2[event] = [...kept, { type: "command", command: `${command} notify --format copilot --event ${notifyEvent}`, timeoutSec: 10 }];
-    }
-    writeJson(file2, config3);
-    return COPILOT_EVENTS.map(([e]) => e);
-  }
-  const config2 = readJson(file2);
-  const hooks = config2.hooks ??= {};
-  for (const event of EVENTS) {
-    const groups = (hooks[event] ?? []).map((g) => ({ ...g, hooks: g.hooks.filter((h) => !isOurs(h)) })).filter((g) => g.hooks.length);
-    const entry = { hooks: [{ type: "command", command: `${command} notify --format ${harness}`, timeout: TIMEOUT_S[harness][event] ?? 10 }] };
-    if (event === "PostToolUse" && harness === "claude-code") entry.matcher = "*";
-    if (event === "Stop" && harness === "claude-code") {
-      entry.hooks.push({ type: "command", command: `${command} wait --max ${WAIT_MAX_S}`, asyncRewake: true, timeout: WAIT_TIMEOUT_S });
-    }
-    hooks[event] = [...groups, entry];
-  }
-  writeJson(file2, config2);
-  return EVENTS;
-}
-function uninstallHooks(harness, file2) {
-  if (!(0, import_node_fs2.existsSync)(file2)) return false;
-  if (harness === "opencode") {
-    if (!(0, import_node_fs2.readFileSync)(file2, "utf8").startsWith(OPENCODE_MARKER)) return false;
-    (0, import_node_fs2.rmSync)(file2);
-    return true;
-  }
-  if (harness === "copilot") {
-    const config3 = readJson(file2);
-    if (!config3.hooks) return false;
-    let changed2 = false;
-    for (const [event, entries] of Object.entries(config3.hooks)) {
-      const kept = entries.filter((h) => !isOurs(h));
-      if (kept.length !== entries.length) changed2 = true;
-      if (kept.length) config3.hooks[event] = kept;
-      else delete config3.hooks[event];
-    }
-    if (!changed2) return false;
-    if (!Object.keys(config3.hooks).length && Object.keys(config3).every((k) => k === "version" || k === "hooks")) (0, import_node_fs2.rmSync)(file2);
-    else writeJson(file2, config3);
-    return true;
-  }
-  const config2 = readJson(file2);
-  if (!config2.hooks) return false;
-  let changed = false;
-  for (const [event, groups] of Object.entries(config2.hooks)) {
-    const kept = groups.map((g) => ({ ...g, hooks: g.hooks.filter((h) => !isOurs(h)) })).filter((g) => g.hooks.length);
-    if (kept.length !== groups.length || kept.some((g, i) => g.hooks.length !== groups[i].hooks.length)) changed = true;
-    if (kept.length) config2.hooks[event] = kept;
-    else delete config2.hooks[event];
-  }
-  if (changed) writeJson(file2, config2);
-  return changed;
-}
-function readJson(file2) {
-  return (0, import_node_fs2.existsSync)(file2) ? JSON.parse((0, import_node_fs2.readFileSync)(file2, "utf8")) : {};
-}
-function writeJson(file2, value) {
-  (0, import_node_fs2.writeFileSync)(file2, JSON.stringify(value, null, 2) + "\n");
-}
+// src/cli/index.ts
+init_hooks();
 
 // src/cli/login.ts
 var import_node_child_process2 = require("node:child_process");
@@ -56330,7 +56845,7 @@ function openBrowser(url2) {
 init_notify();
 
 // src/cli/help.ts
-var HARNESS_LIST = "claude-code, codex, copilot or opencode";
+var HARNESS_LIST = "claude-code, codex, copilot, opencode, amp, droid, gemini, qwen, cursor, antigravity, kimi, goose or crush";
 var COMMANDS = {
   login: {
     short: "sign in to a hub",
@@ -56385,13 +56900,17 @@ var COMMANDS = {
     details: [
       "--scope user (the default) writes your own settings; --scope project writes the repo's local settings.",
       "Claude Code: ~/.claude/settings.json (or .claude/settings.local.json), including the Stop hook that wakes an idle session.",
-      "Codex: ~/.codex/hooks.json; then trust the hooks in Codex's /hooks. Copilot CLI: ~/.copilot/hooks/agenthub.json. OpenCode: a plugin in ~/.config/opencode/plugins/.",
+      "Codex: ~/.codex/hooks.json; then trust the hooks in Codex's /hooks. Copilot CLI: ~/.copilot/hooks/agenthub.json. OpenCode: a plugin in ~/.config/opencode/plugins/. Amp: a plugin in ~/.config/amp/plugins/.",
+      "Factory Droid: ~/.factory/hooks.json. Gemini CLI: ~/.gemini/settings.json. Qwen Code: ~/.qwen/settings.json. Cursor: ~/.cursor/hooks.json. Antigravity: ~/.gemini/config/hooks.json (.agents/hooks.json in a repo). Kimi Code: a block in ~/.kimi-code/config.toml (user scope only). Goose: a plugin in ~/.agents/plugins/agenthub/. Crush: ~/.config/crush/crush.json (PreToolUse only).",
+      "Where a harness can't be woken, its Stop hook hands the agent any request that came in during the turn before it goes idle.",
       "Re-running install updates the hooks; uninstall removes only ours."
     ],
     examples: [
       ["agenthub hooks install claude-code", "for all your Claude Code sessions"],
       ["agenthub hooks install codex", "then open /hooks in Codex to trust them"],
       ["agenthub hooks install opencode --scope project", "only in this repo"],
+      ["agenthub hooks install amp", "an Amp plugin that also wakes idle threads"],
+      ["agenthub hooks install gemini", "Gemini CLI; also droid, qwen, cursor, antigravity, kimi, goose or crush"],
       ["agenthub hooks uninstall claude-code", ""]
     ]
   },
@@ -56407,34 +56926,46 @@ var COMMANDS = {
     ]
   },
   wake: {
-    short: "turn waking idle agents on or off, for every repo or one",
-    usage: ["agenthub wake [on|off|all] [--project]", "agenthub wake default --project"],
-    summary: "Choose whether idle agents are started up when a hub message arrives, in Claude Code, OpenCode and pi.",
+    short: "turn waking idle agents on or off, and choose whether they ask you first",
+    usage: ["agenthub wake [on|off|all|ask|auto] [--project]", "agenthub wake default --project"],
+    summary: "Choose whether idle agents are started up when a hub message arrives, in Claude Code, OpenCode, Amp, pi, Roo Code (with its extension) and Kimi Code (in kimi web), and what they do once woken.",
     details: [
       "on (the default): requests and replies wake an idle agent; fyi waits for its next turn. all: fyi wakes it too. off: nothing wakes it.",
-      "--project sets it for the repo you're in only; it wins over your setting for every repo. default --project removes the repo's own setting.",
-      "Without on|off|all it shows what applies here and where that comes from. AGENTHUB_WAKE=0|on|all overrides it for one shell."
+      "auto (the default): a woken agent handles the messages by itself, within the Agent Hub rules (answers and reviews read-only; handoffs, pushes and merges still wait for you). ask: it tells you what came in and waits for your go-ahead. The same applies when a Stop hook keeps a turn going for a message that came in during it.",
+      "on|off|all and ask|auto are separate settings: set one of each.",
+      "--project sets it for the repo you're in only; it wins over your setting for every repo. default --project removes both of the repo's own settings.",
+      "Without a value it shows what applies here and where that comes from. AGENTHUB_WAKE=0|on|all and AGENTHUB_WAKE_ACT=ask|auto override them for one shell."
     ],
     examples: [
       ["agenthub wake", "what applies in this repo"],
       ["agenthub wake off", "never wake idle agents"],
+      ["agenthub wake ask", "wake them, but have them ask you before acting"],
+      ["agenthub wake auto", "back to the default: act without asking, within the rules"],
       ["agenthub wake off --project", "not in this repo, still elsewhere"],
-      ["agenthub wake all --project", "in this repo, wake for fyi too"],
-      ["agenthub wake default --project", "this repo follows your setting again"]
+      ["agenthub wake ask --project", "ask first in this repo only"],
+      ["agenthub wake default --project", "this repo follows your settings again"]
     ]
   },
   notify: {
     short: "print new messages for a hook",
-    usage: ["agenthub notify --format <claude-code|codex|copilot|text> [--event <session-start|prompt|post-tool|stop|session-end>]"],
+    usage: ["agenthub notify --format <harness|text> [--event <session-start|prompt|post-tool|stop|session-end>] [--plugin]"],
     summary: "What the harness hooks run: reads the hook's JSON on stdin and prints new hub messages for the session, in the harness's format. You don't run it yourself.",
-    details: ["It never fails the harness: off the hub, signed out or on any error it prints nothing. Stop marks the agent idle and session-end takes it offline."],
+    details: [
+      "--format is the harness: claude-code, codex, copilot, amp, droid, gemini, qwen, cursor, antigravity, kimi, goose, crush or roo; or text for plain text (the OpenCode and pi plugins use it).",
+      "It never fails the harness: off the hub, signed out or on any error it prints nothing. Stop marks the agent idle and session-end takes it offline. Only Kimi Code's Stop hook exits 2, to keep a turn going.",
+      "--plugin is what the Claude Code and Codex plugin passes: if `agenthub hooks install` already put hooks in that harness's settings, it prints nothing (at session start, a note on removing them), so notices don't show twice."
+    ],
     examples: [[`echo '{"hook_event_name":"UserPromptSubmit","session_id":"abc"}' | agenthub notify --format text`, "see what a hook would print"]]
   },
   wait: {
     short: "wait for a message that should wake an idle agent",
-    usage: ["agenthub wait [--max <seconds>]"],
+    usage: ["agenthub wait [--max <seconds>] [--deliver kimi] [--plugin]"],
     summary: "What harnesses run when their agent goes idle: waits for a hub message that should wake it, then exits 2 and prints the summaries (else 0). You don't run it yourself.",
-    details: ["The next prompt, a newer waiter for the same session, or --max (12 hours by default) stops it. `agenthub wake` decides whether it waits at all."],
+    details: [
+      "The next prompt, a newer waiter for the same session, or --max (12 hours by default) stops it. `agenthub wake` decides whether it waits at all, and whether its text tells the agent to ask you first.",
+      "--deliver kimi is what Kimi Code's Stop hook starts in the background: instead of printing, it sends the summaries to the session through the local kimi web server.",
+      "--plugin is what the Claude Code plugin's wake hook passes: it exits 0 right away when `agenthub hooks install claude-code` already added a wake hook."
+    ],
     examples: [[`echo '{"session_id":"abc"}' | agenthub wait --max 60; echo $?`, "wait up to a minute; 2 means it would wake the agent"]]
   },
   admin: {
@@ -56458,6 +56989,7 @@ var ENVIRONMENT = `Environment:
   AGENTHUB_URL              the hub (else the one from agenthub login)
   AGENTHUB_AGENT_NAME       a fixed agent name for hooks (default: one per harness session)
   AGENTHUB_WAKE=0|on|all    whether idle agents are woken; overrides agenthub wake
+  AGENTHUB_WAKE_ACT=ask|auto  whether a woken agent asks you first; overrides agenthub wake ask|auto
   AGENTHUB_CREDENTIAL_STORE=file|keychain|auto
   AGENTHUB_HOME             config directory (default ~/.config/agenthub)
   AGENTHUB_DOWNLOAD_URL     where releases come from
@@ -56497,9 +57029,9 @@ function commandHelp(name) {
 init_settings();
 var import_meta = {};
 function version2() {
-  if (true) return "0.3.1";
+  if (true) return "0.3.3";
   try {
-    return JSON.parse((0, import_node_fs10.readFileSync)(new URL("../../package.json", import_meta.url), "utf8")).version;
+    return JSON.parse((0, import_node_fs11.readFileSync)(new URL("../../package.json", import_meta.url), "utf8")).version;
   } catch {
     return "unknown";
   }
@@ -56568,8 +57100,22 @@ async function main(argv) {
       const format = flag(args, "--format") ?? "text";
       const event = flag(args, "--event");
       const payload = await readStdin(500);
-      const out = await notify({ format, event, payload }, { store: credentialStore(), version: version2() });
-      if (out) process.stdout.write(out + "\n");
+      if (args.includes("--plugin") && (format === "claude-code" || format === "codex")) {
+        const { cliHooksFile: cliHooksFile2 } = await Promise.resolve().then(() => (init_hooks(), hooks_exports));
+        const file2 = cliHooksFile2(format, process.cwd());
+        if (file2) {
+          if (event === "session-start" || payload?.hook_event_name === "SessionStart")
+            process.stdout.write(
+              `Agent Hub: ${file2} also runs agenthub notify, so the agenthub plugin's hooks stay out of the way. To use only the plugin, ask the user to run \`agenthub hooks uninstall ${format}\` (with --scope project for a repo's settings).
+`
+            );
+          return 0;
+        }
+      }
+      const out = await notifyHook({ format, event, payload }, { store: credentialStore(), version: version2() });
+      if (out.stdout) process.stdout.write(out.stdout + "\n");
+      if (out.stderr) process.stderr.write(out.stderr + "\n");
+      return out.code ?? 0;
     } catch {
     }
     return 0;
@@ -56584,20 +57130,25 @@ async function main(argv) {
     return watch2({ json: json2, agentName, signal: ac.signal }, { store: credentialStore(), write: (l) => console.log(l) });
   }
   if (cmd === "wake") {
-    const { wakeSetting: wakeSetting2 } = await Promise.resolve().then(() => (init_wait(), wait_exports));
+    const { actSetting: actSetting2, wakeSetting: wakeSetting2 } = await Promise.resolve().then(() => (init_wait(), wait_exports));
     const { gitRemotes: gitRemotes2 } = await Promise.resolve().then(() => (init_notify(), notify_exports));
     const perProject = args.includes("--project");
     const value = args.filter((a) => a !== "--project").shift();
     const origin = gitRemotes2(process.cwd()).origin;
     const key = origin ? projectKey(origin) : void 0;
     const describe3 = (mode) => mode === "off" ? "off: idle agents aren't woken" : mode === "all" ? "all: idle agents are woken for every message, fyi too" : "on: idle agents are woken for requests and replies, not fyi";
+    const describeAct = (mode) => mode === "ask" ? "ask: a woken agent tells you what came in and asks before acting on it" : "auto: a woken agent handles messages by itself, within the Agent Hub rules";
+    const sources = (name) => ({ env: ` (from ${name})`, project: ` (this repo's setting, ${key})`, user: " (your setting for every repo)", default: " (the default)" });
+    const noEnv = { ...process.env, AGENTHUB_WAKE: void 0, AGENTHUB_WAKE_ACT: void 0 };
     if (value === void 0) {
-      const { mode, from } = wakeSetting2(process.env, origin);
-      const source = { env: " (from AGENTHUB_WAKE)", project: ` (this repo's setting, ${key})`, user: " (your setting for every repo)", default: " (the default)" }[from];
-      console.log(describe3(mode) + source);
+      const wake = wakeSetting2(process.env, origin);
+      const act = actSetting2(process.env, origin);
+      console.log(describe3(wake.mode) + sources("AGENTHUB_WAKE")[wake.from]);
+      console.log(describeAct(act.mode) + sources("AGENTHUB_WAKE_ACT")[act.from]);
       return 0;
     }
-    if (!["on", "off", "all", ...perProject ? ["default"] : []].includes(value)) {
+    const isAct = value === "ask" || value === "auto";
+    if (!["on", "off", "all", "ask", "auto", ...perProject ? ["default"] : []].includes(value)) {
       console.error(commandHelp("wake"));
       return 2;
     }
@@ -56608,28 +57159,56 @@ async function main(argv) {
         return 1;
       }
       const projects = { ...settings.wake_projects };
-      if (value === "default") delete projects[key];
+      const actProjects = { ...settings.wake_act_projects };
+      if (value === "default") {
+        delete projects[key];
+        delete actProjects[key];
+      } else if (isAct) actProjects[key] = value;
       else projects[key] = value;
-      writeSettings({ ...settings, wake_projects: projects });
+      writeSettings({ ...settings, wake_projects: projects, wake_act_projects: actProjects });
+    } else if (isAct) {
+      writeSettings({ ...settings, wake_act: value });
     } else {
       writeSettings({ ...settings, wake: value });
     }
     const where = perProject ? `in ${key}` : "in every repo without its own setting";
-    if (value === "default") console.log(`${key} now follows your setting for every repo: ${describe3(wakeSetting2({ ...process.env, AGENTHUB_WAKE: void 0 }, origin).mode)}.`);
+    if (value === "default") {
+      console.log(`${key} now follows your settings for every repo:`);
+      console.log(`  ${describe3(wakeSetting2(noEnv, origin).mode)}`);
+      console.log(`  ${describeAct(actSetting2(noEnv, origin).mode)}`);
+    } else if (value === "ask") console.log(`A woken agent will tell you what came in and ask before acting on it, ${where}. This also applies when a Stop hook keeps a turn going for a new message.`);
+    else if (value === "auto") console.log(`A woken agent will handle hub messages by itself, within the Agent Hub rules, ${where}. Handoffs and anything that runs commands, pushes or merges still wait for you.`);
     else if (value === "off") console.log(`Idle agents won't be woken for hub messages ${where}. They still see them on their next turn.`);
-    else console.log(`Idle agents will be woken for ${value === "all" ? "every hub message, fyi too" : "requests and replies"} ${where}, in Claude Code, OpenCode and pi.`);
-    if (process.env.AGENTHUB_WAKE !== void 0) console.log(`AGENTHUB_WAKE=${process.env.AGENTHUB_WAKE} is set in this shell and wins over this setting.`);
+    else console.log(`Idle agents will be woken for ${value === "all" ? "every hub message, fyi too" : "requests and replies"} ${where}, in Claude Code, OpenCode, Amp, pi, Roo Code and Kimi Code (kimi web).`);
+    const envName = isAct ? "AGENTHUB_WAKE_ACT" : "AGENTHUB_WAKE";
+    if (value !== "default" && process.env[envName] !== void 0) console.log(`${envName}=${process.env[envName]} is set in this shell and wins over this setting.`);
     return 0;
   }
   if (cmd === "wait") {
     try {
       const max = Number(flag(args, "--max"));
-      const payload = await readStdin(500);
+      const deliver = flag(args, "--deliver");
+      const fromEnv = process.env.AGENTHUB_WAIT_PAYLOAD;
+      let payload;
+      try {
+        payload = fromEnv ? JSON.parse(fromEnv) : await readStdin(500);
+      } catch {
+        payload = void 0;
+      }
+      if (args.includes("--plugin")) {
+        const { cliHooksFile: cliHooksFile2 } = await Promise.resolve().then(() => (init_hooks(), hooks_exports));
+        if (cliHooksFile2("claude-code", process.cwd())) return 0;
+      }
       const { wait: wait2 } = await Promise.resolve().then(() => (init_wait(), wait_exports));
       const ac = new AbortController();
       process.once("SIGINT", () => ac.abort());
       process.once("SIGTERM", () => ac.abort());
       const result = await wait2({ payload, signal: ac.signal, ...max > 0 ? { maxMs: max * 1e3 } : {} }, { store: credentialStore() });
+      if (deliver === "kimi") {
+        const { deliverToKimi: deliverToKimi2 } = await Promise.resolve().then(() => (init_kimi(), kimi_exports));
+        if (result.code === 2 && result.text && typeof payload?.session_id === "string") await deliverToKimi2(payload.session_id, result.text);
+        return 0;
+      }
       if (result.code === 2 && result.text) {
         process.stdout.write(result.text + "\n");
         return 2;
@@ -56707,13 +57286,22 @@ version: ${version2()}${newer}`);
       return 2;
     }
     const h = harness;
+    if (scope === "project" && USER_SCOPE_ONLY.has(h)) {
+      console.error(`${h} reads hooks only from your own config, so it has no --scope project.`);
+      return 2;
+    }
     const file2 = hookFile(h, scope, process.cwd());
     if (action === "install") {
       const events = installHooks(h, file2);
       console.log(`Added agenthub notify to ${events.join(", ")} in ${file2}`);
       if (h === "codex") console.log("Codex skips new hooks until you trust them: open /hooks in Codex and review them.");
       if (h === "opencode") console.log("OpenCode loads the plugin when it next starts.");
+      if (h === "amp") console.log("Amp loads the plugin in new sessions, or now with plugins: reload from the command palette.");
       if (h === "copilot" && scope === "project") console.log("This file is in the repo: commit it only if everyone has agenthub, or add it to .git/info/exclude.");
+      if (scope === "project" && h !== "copilot" && h !== "claude-code") console.log("This file is in the repo: commit it only if everyone has agenthub, or add it to .git/info/exclude.");
+      if (h === "qwen" && scope === "project") console.log("Qwen Code runs a repo's hooks only in a trusted folder.");
+      if (h === "goose") console.log("Goose loads the plugin when it next starts. Its hooks can't add context, so it gets a request that arrives during a turn before it stops, and presence; run agenthub watch beside it for the rest.");
+      if (h === "cursor" || h === "antigravity" || h === "kimi") console.log(`${h === "cursor" ? "Cursor" : h === "kimi" ? "Kimi Code" : "Antigravity"} picks up the hooks in new sessions.`);
     } else {
       console.log(uninstallHooks(h, file2) ? `Removed agenthub hooks from ${file2}` : `No agenthub hooks in ${file2}`);
     }