@theagenthub/cli 0.3.0 → 0.3.2

package/bin/agenthub.cjs

@@ -276,6 +276,15 @@ function writeSettings(s, env = process.env) {
   (0, import_node_fs4.mkdirSync)(dir, { recursive: true, mode: 448 });
   (0, import_node_fs4.writeFileSync)((0, import_node_path5.join)(dir, "config.json"), JSON.stringify(s, null, 2) + "\n");
 }
+function projectKey(origin) {
+  try {
+    const { host, path } = parseRemote(origin);
+    const p = path.replace(/^\/+|\/+$/g, "").replace(/\.git$/i, "").toLowerCase();
+    return p ? `${host}/${p}` : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function hubUrl(env = process.env) {
   const raw = env.AGENTHUB_URL ?? readSettings(env).hub;
   return raw?.replace(/\/+$/, "");
@@ -286,6 +295,7 @@ var init_settings = __esm({
     "use strict";
     import_node_fs4 = require("node:fs");
     import_node_path5 = require("node:path");
+    init_registry();
     init_paths();
   }
 });
@@ -453,22 +463,490 @@ 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, {
+  readEvents: () => readEvents,
+  watch: () => watch
+});
+async function watch(opts, deps) {
+  const env = deps.env ?? process.env;
+  const fetchFn = deps.fetch ?? fetch;
+  const sleep = deps.sleep ?? defaultSleep;
+  const hub = hubUrl(env);
+  if (!hub) {
+    deps.write("No hub configured. Run agenthub login --hub <url>.");
+    return 1;
+  }
+  const { origin, upstream } = (deps.remotes ?? gitRemotes)(deps.cwd ?? process.cwd());
+  if (!origin) {
+    deps.write("Not in a git repo with an origin remote.");
+    return 1;
+  }
+  const agentName = opts.agentName ?? env.AGENTHUB_AGENT_NAME;
+  const query = new URLSearchParams({ project: origin, ...upstream ? { upstream } : {}, ...agentName ? { agent_name: agentName } : {} });
+  let backoff = 1e3;
+  let saidWaiting = false;
+  let waitingApproval = false;
+  while (!opts.signal?.aborted) {
+    const token = await accessToken(hub, { store: deps.store, fetch: fetchFn, env });
+    if (!token) {
+      deps.write("Not signed in. Run agenthub login.");
+      return 1;
+    }
+    let res;
+    try {
+      res = await fetchFn(`${hub}/api/stream?${query}`, {
+        headers: { Authorization: `Bearer ${token}`, Accept: "text/event-stream" },
+        ...opts.signal ? { signal: opts.signal } : {}
+      });
+    } catch {
+      if (opts.signal?.aborted) break;
+      await sleep(backoff, opts.signal);
+      backoff = Math.min(backoff * 2, MAX_BACKOFF_MS);
+      continue;
+    }
+    if (res.status === 404) {
+      const { membership } = await res.json().catch(() => ({}));
+      if (membership === "pending") {
+        if (!waitingApproval) deps.write(opts.json ? JSON.stringify({ membership: "pending" }) : "Your request to join is waiting for a project admin's approval.");
+        waitingApproval = true;
+      } else {
+        if (waitingApproval) {
+          if (membership === "active") deps.write(opts.json ? JSON.stringify({ membership: "approved" }) : "A project admin approved you: ask your agent to call join_project.");
+          else deps.write(opts.json ? JSON.stringify({ membership: "declined" }) : "A project admin turned down your request to join.");
+          waitingApproval = false;
+          saidWaiting = true;
+        }
+        if (!saidWaiting) deps.write("No agent of yours has joined this project yet; waiting.");
+        saidWaiting = true;
+      }
+      await sleep(backoff, opts.signal);
+      backoff = Math.min(backoff * 2, MAX_BACKOFF_MS);
+      continue;
+    }
+    if (res.status === 403 || res.status === 409 || res.status === 410) {
+      const body = await res.json().catch(() => ({}));
+      deps.write(body.message ?? `The hub refused the stream (${res.status}).`);
+      return 1;
+    }
+    if (!res.ok || !res.body) {
+      await res.body?.cancel();
+      await sleep(backoff, opts.signal);
+      backoff = Math.min(backoff * 2, MAX_BACKOFF_MS);
+      continue;
+    }
+    backoff = 1e3;
+    saidWaiting = false;
+    let stop;
+    try {
+      for await (const ev of readEvents(res.body)) {
+        if (ev.event === "inbox") {
+          const data = JSON.parse(ev.data);
+          if (opts.json) deps.write(JSON.stringify(data));
+          else {
+            const text = formatInbox(data);
+            if (text) deps.write(text);
+          }
+        } else if (ev.event === "end") {
+          const { reason } = JSON.parse(ev.data);
+          if (reason === "replaced") {
+            deps.write("Another session joined with this agent name; stopping.");
+            stop = 1;
+          } else if (reason === "revoked") {
+            deps.write("This agent lost access to the project; stopping.");
+            stop = 1;
+          } else if (reason === "left") {
+            if (opts.json) deps.write(JSON.stringify({ left: true }));
+            else deps.write("The agent left the project; waiting for it to join again.");
+          }
+        }
+      }
+    } catch {
+    }
+    if (stop !== void 0) return stop;
+  }
+  return 0;
+}
+async function* readEvents(body) {
+  const decoder = new TextDecoder();
+  let buf = "";
+  for await (const chunk of body) {
+    buf += decoder.decode(chunk, { stream: true });
+    let i;
+    while ((i = buf.indexOf("\n\n")) >= 0) {
+      const block = buf.slice(0, i);
+      buf = buf.slice(i + 2);
+      let event = "message";
+      const data = [];
+      for (const line of block.split("\n")) {
+        if (line.startsWith("event:")) event = line.slice(6).trim();
+        else if (line.startsWith("data:")) data.push(line.slice(5).replace(/^ /, ""));
+      }
+      if (data.length) yield { event, data: data.join("\n") };
+    }
+  }
+}
+function defaultSleep(ms, signal) {
+  return new Promise((resolve) => {
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(t);
+      resolve();
+    }, { once: true });
+  });
+}
+var MAX_BACKOFF_MS;
+var init_watch = __esm({
+  "src/cli/watch.ts"() {
+    "use strict";
+    init_notify();
+    init_session();
+    init_settings();
+    MAX_BACKOFF_MS = 3e4;
+  }
+});
+
+// src/cli/wait.ts
+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,
+  wokenNotice: () => wokenNotice
+});
+function wakeSetting(env, origin) {
+  const settings = readSettings(env);
+  const key = origin ? projectKey(origin) : void 0;
+  const project = key ? settings.wake_projects?.[key] : void 0;
+  const [raw, from] = env.AGENTHUB_WAKE !== void 0 ? [env.AGENTHUB_WAKE, "env"] : project ? [project, "project"] : settings.wake ? [settings.wake, "user"] : ["", "default"];
+  const v = raw.trim().toLowerCase();
+  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_path8.join)(cacheDir(env), `wait-${key}.json`);
+}
+function pendingFile(env, key) {
+  return (0, import_node_path8.join)(cacheDir(env), `pending-${key}.json`);
+}
+function releaseWaiter(env, key) {
+  (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_fs7.readFileSync)(file2, "utf8"));
+    (0, import_node_fs7.rmSync)(file2, { force: true });
+    return pending;
+  } catch {
+    return void 0;
+  }
+}
+function addPending(env, key, inbox) {
+  if (!inbox.messages.length && !inbox.events.length) return;
+  const file2 = pendingFile(env, key);
+  let before;
+  try {
+    before = JSON.parse((0, import_node_fs7.readFileSync)(file2, "utf8"));
+  } catch {
+    before = void 0;
+  }
+  (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;
+  return {
+    ...later,
+    messages: [...earlier.messages, ...later.messages],
+    events: [...earlier.events, ...later.events]
+  };
+}
+async function wait(opts, deps) {
+  const env = deps.env ?? process.env;
+  const fetchFn = deps.fetch ?? fetch;
+  const now = deps.now ?? Date.now;
+  const sleep = deps.sleep ?? defaultSleep2;
+  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_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_fs7.readFileSync)(claim2, "utf8")).id === id;
+    } catch {
+      return false;
+    }
+  };
+  const ac = new AbortController();
+  const stop = () => ac.abort();
+  opts.signal?.addEventListener("abort", stop, { once: true });
+  const deadline = setTimeout(stop, opts.maxMs ?? DEFAULT_WAIT_MS);
+  const check2 = setInterval(() => {
+    if (!holds()) stop();
+  }, deps.claimCheckMs ?? 1e3);
+  const query = new URLSearchParams({ project: origin, ...upstream ? { upstream } : {}, ...agentName ? { agent_name: agentName } : {}, idle: "1" });
+  let backoff = 1e3;
+  try {
+    while (!ac.signal.aborted) {
+      const token = await accessToken(hub, { store: deps.store, fetch: fetchFn, env, now });
+      if (!token) return NOTHING;
+      let res;
+      try {
+        res = await fetchFn(`${hub}/api/stream?${query}`, {
+          headers: { Authorization: `Bearer ${token}`, Accept: "text/event-stream" },
+          signal: ac.signal
+        });
+      } catch {
+        if (ac.signal.aborted) break;
+        await sleep(backoff, ac.signal);
+        backoff = Math.min(backoff * 2, MAX_BACKOFF_MS2);
+        continue;
+      }
+      if ([401, 403, 404, 409, 410].includes(res.status)) {
+        await res.body?.cancel();
+        return NOTHING;
+      }
+      if (!res.ok || !res.body) {
+        await res.body?.cancel();
+        await sleep(res.status === 429 ? MAX_BACKOFF_MS2 : backoff, ac.signal);
+        backoff = Math.min(backoff * 2, MAX_BACKOFF_MS2);
+        continue;
+      }
+      backoff = 1e3;
+      try {
+        for await (const ev of readEvents(res.body)) {
+          if (ev.event === "inbox") {
+            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))}
+${wokenNotice(act)}` };
+            addPending(env, key, data);
+          } else if (ev.event === "end") {
+            const { reason } = JSON.parse(ev.data);
+            if (reason === "left" || reason === "replaced" || reason === "revoked") return NOTHING;
+          }
+        }
+      } catch {
+      }
+    }
+    return NOTHING;
+  } finally {
+    clearTimeout(deadline);
+    clearInterval(check2);
+    opts.signal?.removeEventListener("abort", stop);
+    ac.abort();
+    if (holds()) (0, import_node_fs7.rmSync)(claim2, { force: true });
+  }
+}
+function defaultSleep2(ms, signal) {
+  return new Promise((resolve) => {
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(t);
+      resolve();
+    }, { once: true });
+  });
+}
+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_fs7 = require("node:fs");
+    import_node_path8 = require("node:path");
+    init_paths();
+    init_notify();
+    init_session();
+    init_settings();
+    init_watch();
+    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.";
+  }
+});
+
 // src/cli/notify.ts
+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(() => "")]);
-    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 "";
@@ -476,14 +954,37 @@ async function run(opts, event, deps) {
   if (!origin) return "";
   if (!await onHub(hub, [origin, upstream], fetchFn, env, now)) return "";
   const agentName = hookAgentName(opts.payload, env);
-  const throttleKey = (0, import_node_crypto2.createHash)("sha256").update(`${hub}|${origin}|${agentName ?? ""}`).digest("hex").slice(0, 24);
-  const wait = THROTTLE_MS[event];
-  if (wait && !throttle((0, import_node_path7.join)(cacheDir(env), `notify-${throttleKey}.json`), wait, now())) return "";
+  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_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);
+  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 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`, {
       method: "POST",
@@ -498,28 +999,81 @@ async function run(opts, event, deps) {
     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_path7.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_fs6.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.");
     }
     if (event !== "session-start") return "";
-    return out(`Agent Hub: this repo is on the hub. To work with teammates' agents, call the agenthub join_project tool with ${args}.${keep}`);
+    const branch = (deps.branch ?? gitBranch)(cwd);
+    const card2 = ` Pass a card with description (what this session is for), task (what it's working on)${branch ? `, branch ${JSON.stringify(branch)}` : ""} and capabilities, and call update_card whenever the task changes.`;
+    return out(`Agent Hub: this repo is on the hub. To work with teammates' agents, call the agenthub join_project tool with ${args}.${keep}${card2}`);
   }
   if (!res.ok) return "";
-  return out(formatInbox(await res.json()));
+  const inbox = await res.json();
+  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_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(() => "");
+  return out([formatInbox(mergeInbox(takePending(env, throttleKey), inbox)), card].filter(Boolean).join("\n"));
+}
+async function keepCardCurrent(inbox, event, ctx) {
+  const card = inbox.card;
+  if (!card || card.kind === "bot") return "";
+  const lines = [];
+  const state = readState(ctx.stateFile);
+  const had = typeof card.branch === "string" ? card.branch : void 0;
+  if (ctx.branch && ctx.branch !== had) {
+    const res = await ctx.post({ branch: ctx.branch });
+    if (res.ok && had) lines.push(`Agent Hub: you switched to branch ${quote(ctx.branch)}, so your card says so now. If your task changed with it, call the agenthub update_card tool with the new task.`);
+  }
+  const missing = (inbox.card_missing ?? []).filter((k) => k === "description" || k === "task");
+  if (missing.length && (event === "session-start" || ctx.now - (state.nudged ?? 0) >= CARD_NUDGE_MS)) {
+    const list = missing.length > 1 ? missing.join(" or ") : missing[0];
+    lines.push(`Agent Hub: your card has no ${list}. Call the agenthub update_card tool with them, so teammates' agents know what this session is for and what it's working on.`);
+    state.nudged = ctx.now;
+  } else if (!missing.length && event === "prompt" && typeof card.task === "string" && ctx.now - (state.taskChecked ?? 0) >= TASK_CHECK_MS) {
+    lines.push(`Agent Hub: your card says you're working on ${quote(card.task)}. If this prompt starts something else, call the agenthub update_card tool with the new task.`);
+    state.taskChecked = ctx.now;
+  }
+  if (lines.length) writeState(ctx.stateFile, state);
+  return lines.join("\n");
+}
+function readState(path) {
+  try {
+    return JSON.parse((0, import_node_fs8.readFileSync)(path, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeState(path, 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_process5.execFileSync)("git", ["-C", cwd, "branch", "--show-current"], { stdio: ["ignore", "pipe", "ignore"], timeout: 1e3 }).toString().trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function sessionKey(hub, origin, agentName) {
+  return (0, import_node_crypto3.createHash)("sha256").update(`${hub}|${origin}|${agentName ?? ""}`).digest("hex").slice(0, 24);
 }
 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_crypto2.createHash)("sha256").update(session).digest("hex").slice(0, 8)}`;
+  return `s-${(0, import_node_crypto3.createHash)("sha256").update(session).digest("hex").slice(0, 8)}`;
 }
 function formatInbox(inbox) {
   const fresh = inbox.messages.filter((m) => m.new);
@@ -550,38 +1104,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_fs6.readFileSync)(path);
+    (0, import_node_fs8.readFileSync)(path);
     return true;
   } catch {
     return false;
   }
 }
 function writeFlag(path) {
-  (0, import_node_fs6.mkdirSync)((0, import_node_path7.join)(path, ".."), { recursive: true, mode: 448 });
-  (0, import_node_fs6.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_fs6.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_fs6.mkdirSync)((0, import_node_path7.join)(path, ".."), { recursive: true, mode: 448 });
-  (0, import_node_fs6.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_path7.join)(cacheDir(env), `providers-${(0, import_node_crypto2.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_fs6.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 {
   }
@@ -589,8 +1149,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_fs6.mkdirSync)((0, import_node_path7.join)(path, ".."), { recursive: true, mode: 448 });
-    (0, import_node_fs6.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) {
@@ -609,7 +1169,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;
     }
@@ -618,25 +1178,33 @@ function gitRemotes(cwd) {
   const upstream = origin ? get("upstream") : void 0;
   return { ...origin ? { origin } : {}, ...upstream ? { upstream } : {} };
 }
-var import_node_child_process4, import_node_crypto2, import_node_fs6, import_node_path7, HOOK_EVENTS, EVENT_NAMES, THROTTLE_MS, PROVIDERS_TTL_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_crypto2 = require("node:crypto");
-    import_node_fs6 = require("node:fs");
-    import_node_path7 = require("node:path");
+    import_node_child_process5 = require("node:child_process");
+    import_node_crypto3 = require("node:crypto");
+    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",
@@ -645,152 +1213,31 @@ 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;
-  }
-});
-
-// src/cli/watch.ts
-var watch_exports = {};
-__export(watch_exports, {
-  readEvents: () => readEvents,
-  watch: () => watch
-});
-async function watch(opts, deps) {
-  const env = deps.env ?? process.env;
-  const fetchFn = deps.fetch ?? fetch;
-  const sleep = deps.sleep ?? defaultSleep;
-  const hub = hubUrl(env);
-  if (!hub) {
-    deps.write("No hub configured. Run agenthub login --hub <url>.");
-    return 1;
-  }
-  const { origin, upstream } = (deps.remotes ?? gitRemotes)(deps.cwd ?? process.cwd());
-  if (!origin) {
-    deps.write("Not in a git repo with an origin remote.");
-    return 1;
-  }
-  const agentName = opts.agentName ?? env.AGENTHUB_AGENT_NAME;
-  const query = new URLSearchParams({ project: origin, ...upstream ? { upstream } : {}, ...agentName ? { agent_name: agentName } : {} });
-  let backoff = 1e3;
-  let saidWaiting = false;
-  let waitingApproval = false;
-  while (!opts.signal?.aborted) {
-    const token = await accessToken(hub, { store: deps.store, fetch: fetchFn, env });
-    if (!token) {
-      deps.write("Not signed in. Run agenthub login.");
-      return 1;
-    }
-    let res;
-    try {
-      res = await fetchFn(`${hub}/api/stream?${query}`, {
-        headers: { Authorization: `Bearer ${token}`, Accept: "text/event-stream" },
-        ...opts.signal ? { signal: opts.signal } : {}
-      });
-    } catch {
-      if (opts.signal?.aborted) break;
-      await sleep(backoff, opts.signal);
-      backoff = Math.min(backoff * 2, MAX_BACKOFF_MS);
-      continue;
-    }
-    if (res.status === 404) {
-      const { membership } = await res.json().catch(() => ({}));
-      if (membership === "pending") {
-        if (!waitingApproval) deps.write(opts.json ? JSON.stringify({ membership: "pending" }) : "Your request to join is waiting for a project admin's approval.");
-        waitingApproval = true;
-      } else {
-        if (waitingApproval) {
-          if (membership === "active") deps.write(opts.json ? JSON.stringify({ membership: "approved" }) : "A project admin approved you: ask your agent to call join_project.");
-          else deps.write(opts.json ? JSON.stringify({ membership: "declined" }) : "A project admin turned down your request to join.");
-          waitingApproval = false;
-          saidWaiting = true;
-        }
-        if (!saidWaiting) deps.write("No agent of yours has joined this project yet; waiting.");
-        saidWaiting = true;
-      }
-      await sleep(backoff, opts.signal);
-      backoff = Math.min(backoff * 2, MAX_BACKOFF_MS);
-      continue;
-    }
-    if (res.status === 403 || res.status === 409 || res.status === 410) {
-      const body = await res.json().catch(() => ({}));
-      deps.write(body.message ?? `The hub refused the stream (${res.status}).`);
-      return 1;
-    }
-    if (!res.ok || !res.body) {
-      await res.body?.cancel();
-      await sleep(backoff, opts.signal);
-      backoff = Math.min(backoff * 2, MAX_BACKOFF_MS);
-      continue;
-    }
-    backoff = 1e3;
-    saidWaiting = false;
-    let stop;
-    try {
-      for await (const ev of readEvents(res.body)) {
-        if (ev.event === "inbox") {
-          const data = JSON.parse(ev.data);
-          if (opts.json) deps.write(JSON.stringify(data));
-          else {
-            const text = formatInbox(data);
-            if (text) deps.write(text);
-          }
-        } else if (ev.event === "end") {
-          const { reason } = JSON.parse(ev.data);
-          if (reason === "replaced") {
-            deps.write("Another session joined with this agent name; stopping.");
-            stop = 1;
-          } else if (reason === "revoked") {
-            deps.write("This agent lost access to the project; stopping.");
-            stop = 1;
-          } else if (reason === "left") {
-            if (opts.json) deps.write(JSON.stringify({ left: true }));
-            else deps.write("The agent left the project; waiting for it to join again.");
-          }
-        }
-      }
-    } catch {
-    }
-    if (stop !== void 0) return stop;
-  }
-  return 0;
-}
-async function* readEvents(body) {
-  const decoder = new TextDecoder();
-  let buf = "";
-  for await (const chunk of body) {
-    buf += decoder.decode(chunk, { stream: true });
-    let i;
-    while ((i = buf.indexOf("\n\n")) >= 0) {
-      const block = buf.slice(0, i);
-      buf = buf.slice(i + 2);
-      let event = "message";
-      const data = [];
-      for (const line of block.split("\n")) {
-        if (line.startsWith("event:")) event = line.slice(6).trim();
-        else if (line.startsWith("data:")) data.push(line.slice(5).replace(/^ /, ""));
-      }
-      if (data.length) yield { event, data: data.join("\n") };
-    }
-  }
-}
-function defaultSleep(ms, signal) {
-  return new Promise((resolve) => {
-    const t = setTimeout(resolve, ms);
-    signal?.addEventListener("abort", () => {
-      clearTimeout(t);
-      resolve();
-    }, { once: true });
-  });
-}
-var MAX_BACKOFF_MS;
-var init_watch = __esm({
-  "src/cli/watch.ts"() {
-    "use strict";
-    init_notify();
-    init_session();
-    init_settings();
-    MAX_BACKOFF_MS = 3e4;
+    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;
   }
 });
 
@@ -3664,16 +4111,16 @@ var require_connect = __commonJS({
           }
         });
       }
-      get(sessionKey) {
-        const ref = this._sessionCache.get(sessionKey);
+      get(sessionKey2) {
+        const ref = this._sessionCache.get(sessionKey2);
         return ref ? ref.deref() : null;
       }
-      set(sessionKey, session) {
+      set(sessionKey2, session) {
         if (this._maxCachedSessions === 0) {
           return;
         }
-        if (this._sessionCache.has(sessionKey)) {
-          this._sessionCache.delete(sessionKey);
+        if (this._sessionCache.has(sessionKey2)) {
+          this._sessionCache.delete(sessionKey2);
         } else if (this._sessionCache.size >= this._maxCachedSessions) {
           let evicted = false;
           for (const [key, ref] of this._sessionCache) {
@@ -3690,8 +4137,8 @@ var require_connect = __commonJS({
             }
           }
         }
-        this._sessionCache.set(sessionKey, new WeakRef(session));
-        this._sessionRegistry.register(session, sessionKey);
+        this._sessionCache.set(sessionKey2, new WeakRef(session));
+        this._sessionRegistry.register(session, sessionKey2);
       }
     };
     function buildConnector({ allowH2, useH2c, maxCachedSessions, socketPath, timeout, session: customSession, ...opts }) {
@@ -3709,9 +4156,9 @@ var require_connect = __commonJS({
             tls = require("node:tls");
           }
           servername = servername || options.servername || util.getServerName(host) || null;
-          const sessionKey = servername || hostname3;
-          assert2(sessionKey);
-          const session = customSession || sessionCache.get(sessionKey) || null;
+          const sessionKey2 = servername || hostname3;
+          assert2(sessionKey2);
+          const session = customSession || sessionCache.get(sessionKey2) || null;
           port = port || 443;
           socket = tls.connect({
             highWaterMark: 16384,
@@ -3727,7 +4174,7 @@ var require_connect = __commonJS({
             host: hostname3
           });
           socket.on("session", function(session2) {
-            sessionCache.set(sessionKey, session2);
+            sessionCache.set(sessionKey2, session2);
           });
         } else {
           assert2(!httpSocket, "httpSocket can only be sent on TLS update");
@@ -10903,7 +11350,7 @@ var require_socks5_client = __commonJS({
       USERNAME_PASSWORD: 2,
       NO_ACCEPTABLE: 255
     };
-    var COMMANDS = {
+    var COMMANDS2 = {
       CONNECT: 1,
       BIND: 2,
       UDP_ASSOCIATE: 3
@@ -11105,7 +11552,7 @@ var require_socks5_client = __commonJS({
         }
         debug("connecting to", address, port);
         this.state = STATES.CONNECTING;
-        const request = this.buildConnectRequest(COMMANDS.CONNECT, address, port);
+        const request = this.buildConnectRequest(COMMANDS2.CONNECT, address, port);
         this.socket.write(request);
       }
       /**
@@ -11210,7 +11657,7 @@ var require_socks5_client = __commonJS({
     module2.exports = {
       Socks5Client,
       AUTH_METHODS,
-      COMMANDS,
+      COMMANDS: COMMANDS2,
       ADDRESS_TYPES,
       REPLY_CODES,
       STATES
@@ -27432,7 +27879,7 @@ function dispatcherFor(instance) {
   if (!instance.caBundlePath) return void 0;
   let d = dispatchers.get(instance.id);
   if (!d) {
-    const ca = (0, import_node_fs7.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);
   }
@@ -27449,11 +27896,11 @@ function fetchFor(instance, override) {
     signal: AbortSignal.timeout(1e4)
   });
 }
-var import_node_fs7, 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_fs7 = 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();
@@ -55332,7 +55779,7 @@ var init_types = __esm({
 
 // src/providers/config.ts
 function loadConfigFile(path, opts = {}) {
-  const read = opts.readFile ?? ((p) => (0, import_node_fs8.readFileSync)(p, "utf8"));
+  const read = opts.readFile ?? ((p) => (0, import_node_fs10.readFileSync)(p, "utf8"));
   let text;
   try {
     text = read(path);
@@ -55343,7 +55790,7 @@ function loadConfigFile(path, opts = {}) {
 }
 function buildConfig(raw, opts = {}) {
   const env = opts.env ?? process.env;
-  const read = opts.readFile ?? ((p) => (0, import_node_fs8.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(
@@ -55524,11 +55971,11 @@ function checkNoHostCollisions(instances) {
     for (const a of inst.remoteAliases) claim2(a.port ? `${a.host}:${a.port}` : a.host, inst.id);
   }
 }
-var import_node_fs8, 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_fs8 = require("node:fs");
+    import_node_fs10 = require("node:fs");
     import_yaml = __toESM(require_dist(), 1);
     init_zod();
     init_defaults();
@@ -55629,7 +56076,7 @@ var init_admin = __esm({
 });
 
 // src/cli/index.ts
-var import_node_fs9 = require("node:fs");
+var import_node_fs11 = require("node:fs");
 
 // src/cli/credentials.ts
 var import_node_child_process = require("node:child_process");
@@ -55735,11 +56182,133 @@ var import_node_fs2 = require("node:fs");
 var import_node_os2 = require("node:os");
 var import_node_path3 = require("node:path");
 
+// src/cli/amp-plugin.ts
+var AMP_MARKER = "// Agent Hub plugin for Amp, written by `agenthub hooks install amp`.";
+var 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`;
+var 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";`;
+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();
+  });
+}
+`;
+}
+
 // 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.
+var PACKAGE_HEADER2 = `// 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";
+var PACKAGE_COMMAND2 = `import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
@@ -55748,12 +56317,12 @@ const COMMAND =
   [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}
+  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_COMMAND : `const COMMAND = ${JSON.stringify(command)};`}
+${as === "package" ? PACKAGE_COMMAND2 : `const COMMAND = ${JSON.stringify(command)};`}
 const TIMEOUT_MS = 5000;
 
 function notify(event, sessionID, cwd) {
@@ -55788,15 +56357,52 @@ function notify(event, 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 }) => {
+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);
@@ -55811,8 +56417,15 @@ export const AgentHub = async ({ directory }) => {
     // 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") presence = presence.then(() => notify("stop", event.properties.sessionID, directory));
-      else if (event.type === "session.deleted") presence = presence.then(() => notify("session-end", event.properties.info.id, directory));
+      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));
+      }
     },
   };
 };
@@ -55824,11 +56437,23 @@ 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);
@@ -55848,11 +56473,21 @@ async function setup(ctx) {
       const sessionID = event.data?.sessionID;
       if (!sessionID) continue;
       const kind = event.type === "session.deleted" ? "session-end" : "stop";
-      if (kind === "session-end") started.delete(sessionID);
+      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();
+  return () => {
+    controller.abort();
+    for (const child of waiting.values()) child.kill();
+  };
 }
 
 export default { id: "agenthub", server: AgentHub, setup };
@@ -55860,92 +56495,248 @@ export default { id: "agenthub", server: AgentHub, setup };
 }
 
 // src/cli/hooks.ts
-var HARNESSES = ["claude-code", "codex", "copilot", "opencode"];
+var HARNESSES = ["claude-code", "codex", "copilot", "opencode", "droid", "gemini", "qwen", "cursor", "antigravity", "kimi", "goose", "amp", "crush"];
+var USER_SCOPE_ONLY = /* @__PURE__ */ new Set(["kimi"]);
 var EVENTS = ["SessionStart", "UserPromptSubmit", "PostToolUse", "Stop", "SessionEnd"];
-var COPILOT_EVENTS = [
-  ["sessionStart", "session-start"],
-  ["userPromptSubmitted", "prompt"],
-  ["postToolUse", "post-tool"],
-  ["agentStop", "stop"],
-  ["sessionEnd", "session-end"]
+var CLAUDE_PAIRS = [
+  ["SessionStart", "session-start"],
+  ["UserPromptSubmit", "prompt"],
+  ["PostToolUse", "post-tool"],
+  ["Stop", "stop"],
+  ["SessionEnd", "session-end"]
 ];
+var 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"]
+  ]
+};
+var WAIT_MAX_S = 12 * 3600;
+var WAIT_TIMEOUT_S = WAIT_MAX_S + 60;
 var TIMEOUT_S = { "claude-code": {}, codex: { SessionEnd: 3 } };
+var KIMI_BEGIN = "# >>> agenthub hooks: agenthub hooks uninstall kimi removes this block >>>";
+var KIMI_END = "# <<< agenthub hooks <<<";
+var GOOSE_PLUGIN = { name: "agenthub", version: "1.0.0", description: "Agent Hub: handle hub requests that arrive during a turn, and presence" };
 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 user ? (0, import_node_path3.join)(home, ".codex", "hooks.json") : (0, import_node_path3.join)(cwd, ".codex", "hooks.json");
+      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");
-  }
-}
-var OURS = [/^(?:\S*[\\/])?agenthub(?:\.js|\.exe)?\s+notify\b/i, /^"(?:[^"]*[\\/])?agenthub(?:\.js|\.exe)?"\s+notify\b/i];
-var isOurs = (h) => typeof h.command === "string" && OURS.some((r) => r.test(h.command));
+    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");
+  }
+}
+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 = "*";
-    hooks[event] = [...groups, entry];
-  }
-  writeJson(file2, config2);
-  return EVENTS;
+  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;
-  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];
+  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;
+    }
   }
-  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")) : {};
@@ -56007,34 +56798,197 @@ function openBrowser(url2) {
 
 // src/cli/index.ts
 init_notify();
+
+// src/cli/help.ts
+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",
+    usage: ["agenthub login [--hub <url>]"],
+    summary: "Sign in to a hub with the device flow.",
+    details: [
+      "Opens a code to enter in the browser, then keeps the token in the OS keychain (macOS Keychain or Secret Service), or in a 0600 file in ~/.config/agenthub when there's none.",
+      "The hub is remembered, so later commands and the hooks don't need --hub. Hooks refresh the token themselves."
+    ],
+    examples: [
+      ["agenthub login --hub https://hub.theagenthub.app", "sign in to the public hub"],
+      ["agenthub login --hub https://hub.example.com", "sign in to a self-hosted hub"],
+      ["agenthub login", "sign in again to the hub you used last"]
+    ]
+  },
+  logout: {
+    short: "forget this machine's token",
+    usage: ["agenthub logout"],
+    summary: "Forget this machine's token for the current hub.",
+    examples: [["agenthub logout", ""]]
+  },
+  status: {
+    short: "show the hub, sign-in and version",
+    usage: ["agenthub status"],
+    summary: "Show the hub, whether you're signed in, and the CLI version (and whether a newer one is out).",
+    examples: [["agenthub status", ""]]
+  },
+  token: {
+    short: "print a fresh hub access token",
+    usage: ["agenthub token [--json]"],
+    summary: "Print a fresh hub access token, for plugins that call the hub's MCP server (the pi extension uses it).",
+    examples: [
+      ["agenthub token", "just the token"],
+      ["agenthub token --json", '{"hub", "token", "expires_at"}']
+    ]
+  },
+  update: {
+    short: "update this CLI",
+    usage: ["agenthub update [--check] [--version <v>]"],
+    summary: "Replace this CLI with the latest release, after checking it against SHA256SUMS and that it runs.",
+    details: ["A CLI installed with npm can't replace itself; update it the way you installed it."],
+    examples: [
+      ["agenthub update", "install the latest release"],
+      ["agenthub update --check", "only say whether there's a newer one"],
+      ["agenthub update --version v0.3.0", "install a specific release"]
+    ]
+  },
+  hooks: {
+    short: "add or remove the hooks for a harness",
+    usage: [`agenthub hooks install <harness> [--scope user|project]`, `agenthub hooks uninstall <harness> [--scope user|project]`],
+    summary: `Add the hooks that bring hub messages into a harness's sessions, for ${HARNESS_LIST}. Not needed with a harness plugin.`,
+    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/. 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", ""]
+    ]
+  },
+  watch: {
+    short: "print new messages as they arrive",
+    usage: ["agenthub watch [--json] [--agent <name>]"],
+    summary: "Print this repo's agent's new hub messages as they arrive. For a terminal next to an agent that can't be woken (Codex, Copilot CLI), or a script.",
+    details: ["Waits for the agent to join, reconnects by itself, and stops when the agent is replaced or loses access."],
+    examples: [
+      ["agenthub watch", "your most recently active agent in this repo"],
+      ["agenthub watch --agent reviewer", "a named agent"],
+      ["agenthub watch --json | jq .messages", "JSON lines, for a script"]
+    ]
+  },
+  wake: {
+    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.",
+      "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 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 <harness|text> [--event <session-start|prompt|post-tool|stop|session-end>]"],
+    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: [
+      "--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."
+    ],
+    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>] [--deliver kimi]"],
+    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, 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."
+    ],
+    examples: [[`echo '{"session_id":"abc"}' | agenthub wait --max 60; echo $?`, "wait up to a minute; 2 means it would wake the agent"]]
+  },
+  admin: {
+    short: "check a hub's code host config",
+    usage: ["agenthub admin providers check [--config <file>]", "agenthub admin providers resolve <remote> [--config <file>]"],
+    summary: "For hub operators: test the code hosts in a providers.yaml, or show the project ID a git remote maps to.",
+    details: ["--config defaults to $AGENTHUB_CONFIG, else the built-in public hosts."],
+    examples: [
+      ["agenthub admin providers check --config providers.yaml", ""],
+      ["agenthub admin providers resolve git@github.com:acme/shop.git", ""]
+    ]
+  }
+};
+var GROUPS = [
+  ["Set up", ["login", "hooks", "status", "logout"]],
+  ["Day to day", ["watch", "wake", "update"]],
+  ["Used by hooks and plugins", ["notify", "wait", "token"]],
+  ["Hub operators", ["admin"]]
+];
+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
+  AGENTHUB_NO_UPDATE_CHECK=1  no daily "newer version" notice`;
+function overview() {
+  const width = Math.max(...Object.keys(COMMANDS).map((c) => c.length)) + 2;
+  const lines = ["agenthub: connects your coding agents to Agent Hub, so they can trade reviews, questions and handoffs with teammates' agents.", ""];
+  for (const [title, names] of GROUPS) {
+    lines.push(`${title}:`);
+    for (const n of names) lines.push(`  ${n.padEnd(width)}${COMMANDS[n].short}`);
+    lines.push("");
+  }
+  lines.push(
+    "Get started:",
+    "  agenthub login --hub https://hub.theagenthub.app",
+    "  agenthub hooks install claude-code     (or use the Claude Code, Codex, OpenCode or pi plugin instead)",
+    "  agenthub status",
+    "",
+    ENVIRONMENT,
+    "",
+    "agenthub help <command> (or agenthub <command> --help) shows its options and examples. agenthub --version prints the version."
+  );
+  return lines.join("\n");
+}
+function commandHelp(name) {
+  const c = COMMANDS[name];
+  if (!c) return void 0;
+  const lines = ["usage:", ...c.usage.map((u) => `  ${u}`), "", c.summary];
+  if (c.details?.length) lines.push("", ...c.details);
+  lines.push("", "examples:");
+  for (const [cmd, note] of c.examples) lines.push(`  ${cmd}${note ? `
+      ${note}` : ""}`);
+  return lines.join("\n");
+}
+
+// src/cli/index.ts
 init_settings();
 var import_meta = {};
 function version2() {
-  if (true) return "0.3.0";
+  if (true) return "0.3.2";
   try {
-    return JSON.parse((0, import_node_fs9.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";
   }
 }
-var USAGE = `usage:
-  agenthub login [--hub <url>]              sign in with the device flow; keeps the token in the OS keychain
-  agenthub logout                           forget this machine's hub token
-  agenthub status                           show the hub and whether you're signed in
-  agenthub token [--json]                   print a fresh hub access token, for plugins that call the hub's MCP server
-  agenthub --version                        print the CLI version
-  agenthub update [--check] [--version <v>] replace this CLI with the latest release (or <v>); --check only reports
-  agenthub notify --format <claude-code|codex|copilot|text> [--event <session-start|prompt|post-tool|stop|session-end>]
-                                            print new hub messages for a harness hook (reads the hook's JSON on stdin)
-  agenthub watch [--json] [--agent <name>]    print this repo's agent's new hub messages as they arrive
-  agenthub hooks install <claude-code|codex|copilot|opencode> [--scope user|project]
-  agenthub hooks uninstall <claude-code|codex|copilot|opencode> [--scope user|project]
-  agenthub admin providers check [--config <file>]           test every provider instance
-  agenthub admin providers resolve <remote> [--config <file>]  show the project ID a remote maps to
-
-Environment: AGENTHUB_URL (hub), AGENTHUB_AGENT_NAME (fixed agent name for hooks; default: one per harness session),
-AGENTHUB_CREDENTIAL_STORE=file|keychain|auto, AGENTHUB_HOME (config directory),
-AGENTHUB_DOWNLOAD_URL (where releases come from), AGENTHUB_NO_UPDATE_CHECK=1 (no daily "newer version" notice).`;
 function flag(args, name) {
   const i = args.indexOf(name);
   if (i < 0) return void 0;
@@ -56072,6 +57026,24 @@ async function readStdin(timeoutMs) {
 async function main(argv) {
   const args = [...argv];
   const cmd = args.shift();
+  if (cmd === void 0 || cmd === "help" || cmd === "--help" || cmd === "-h") {
+    const topic = cmd === "help" ? args[0] : void 0;
+    if (!topic) {
+      console.log(overview());
+      return 0;
+    }
+    const text = commandHelp(topic);
+    if (!text) {
+      console.error(`agenthub: no command "${topic}". Run agenthub help for the list.`);
+      return 2;
+    }
+    console.log(text);
+    return 0;
+  }
+  if (commandHelp(cmd) && (args.includes("--help") || args.includes("-h"))) {
+    console.log(commandHelp(cmd));
+    return 0;
+  }
   if (cmd === "--version" || cmd === "version") {
     console.log(version2());
     return 0;
@@ -56081,8 +57053,10 @@ 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");
+      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;
@@ -56096,6 +57070,90 @@ async function main(argv) {
     process.once("SIGTERM", () => ac.abort());
     return watch2({ json: json2, agentName, signal: ac.signal }, { store: credentialStore(), write: (l) => console.log(l) });
   }
+  if (cmd === "wake") {
+    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 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;
+    }
+    const isAct = value === "ask" || value === "auto";
+    if (!["on", "off", "all", "ask", "auto", ...perProject ? ["default"] : []].includes(value)) {
+      console.error(commandHelp("wake"));
+      return 2;
+    }
+    const settings = readSettings();
+    if (perProject) {
+      if (!key) {
+        console.error("Not in a git repo with an origin remote; run it in the repo, or leave out --project.");
+        return 1;
+      }
+      const projects = { ...settings.wake_projects };
+      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, 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 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, 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 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;
+      }
+      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;
+      }
+    } catch {
+    }
+    return 0;
+  }
   if (cmd === "update") {
     const { selfUpdate: selfUpdate2 } = await Promise.resolve().then(() => (init_update(), update_exports));
     const v = flag(args, "--version");
@@ -56161,17 +57219,26 @@ version: ${version2()}${newer}`);
     const harness = args.shift();
     const scope = flag(args, "--scope") ?? "user";
     if (action !== "install" && action !== "uninstall" || !HARNESSES.includes(harness) || scope !== "user" && scope !== "project") {
-      console.error(USAGE);
+      console.error(commandHelp("hooks"));
       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}`);
     }
@@ -56179,9 +57246,9 @@ version: ${version2()}${newer}`);
   }
   if (cmd === "admin") {
     const { admin: admin2 } = await Promise.resolve().then(() => (init_admin(), admin_exports));
-    return admin2(args, USAGE);
+    return admin2(args, commandHelp("admin"));
   }
-  console.error(USAGE);
+  console.error(`agenthub: no command "${cmd}". Run agenthub help for the list.`);
   return 2;
 }
 main(process.argv.slice(2)).then(