codemax-cli 0.1.4 → 0.1.5

package/src/engines/acp.ts

@@ -1,8 +1,9 @@
 import { ClientSideConnection, ndJsonStream, type Client, type Stream } from "@agentclientprotocol/sdk";
 import type { AgentId } from "../adapters/types.ts";
-import type { Engine, EngineEvent, EngineInfo, EngineOption, EngineSessionRef, EngineStartOptions, PermissionRequest, PlanLimit, StopReason } from "./types.ts";
+import type { Engine, EngineEvent, EngineInfo, EngineOption, EngineSessionRef, EngineStartOptions, PermissionRequest, PlanLimit, QuestionAnswer, StopReason } from "./types.ts";
+import { elicitationResponse, parseElicitation } from "./elicitation.ts";
 import { agentEnv } from "./env.ts";
-import { platformArgv } from "../core/spawn.ts";
+import { IS_WINDOWS, platformArgv } from "../core/spawn.ts";
 import { classifyError } from "./errors.ts";
 
 export interface UsageSample {
@@ -22,6 +23,16 @@ export interface AcpEngineOptions {
   env?: Record<string, string>;
   /** Pre-built stream (tests inject an in-process agent). When set, `cmd` is not spawned. */
   stream?: Stream;
+  /**
+   * Run the agent behind plain pipes (`cat | agent | cat`, macOS/Linux). Bun gives a child
+   * socket stdio; Antigravity's Python ACP server never answers on a socket.
+   */
+  plainPipes?: boolean;
+  /**
+   * Sign-in methods codemax may use when the agent says "Authentication required" (its
+   * subscription login only, never an API-key method). A browser may open the first time.
+   */
+  signIn?: string[];
   /** False when the agent is known to auto-approve tools over ACP (surfaced to the user). */
   permissionPrompts?: boolean;
   /**
@@ -33,7 +44,7 @@ export interface AcpEngineOptions {
 
 /**
  * Generic Agent Client Protocol engine. Works for any agent that speaks ACP
- * over stdio: Claude Code (via the Zed adapter), OpenCode, Grok, Gemini CLI.
+ * over stdio: Claude Code (via the Zed adapter), OpenCode, Grok, Cursor, Antigravity.
  */
 export class AcpEngine implements Engine {
   readonly agent: AgentId;
@@ -43,6 +54,9 @@ export class AcpEngine implements Engine {
   private conn: ClientSideConnection | null = null;
   private proc: Bun.Subprocess | null = null;
   private pendingPermissions = new Map<string, (optionId: string | null) => void>();
+  private pendingQuestions = new Map<string, (answer: QuestionAnswer) => void>();
+  /** cancel() was called during the current turn. */
+  private cancelled = false;
   private permSeq = 0;
   private turnActive = false;
   private tail: { read(): UsageSample[] } | null = null;
@@ -69,7 +83,18 @@ export class AcpEngine implements Engine {
     const stream = this.opts.stream ?? this.spawn(o.cwd);
     const client: Client = {
       requestPermission: (p) => this.onPermission(p),
-      sessionUpdate: ({ update }) => this.onUpdate(update as any),
+      // Form questions only: codemax shows them in its own dialog. URL elicitations are not advertised.
+      createElicitation: (p) => this.onElicitation(p) as any,
+      sessionUpdate: ({ sessionId, update }) => {
+        // Another session on this connection is a spawned agent (Cursor, Grok): its steps
+        // are its activity, never part of the main transcript.
+        if (sessionId && this.session && sessionId !== this.session.id) return this.onChildSession(sessionId, update as any);
+        this.onUpdate(update as any);
+      },
+      // Cursor reports a finished Task subagent with its own notification.
+      extNotification: async (method: string, params: any) => {
+        if (method === "cursor/task" && params?.toolCallId) this.emit({ type: "subagent", id: params.toolCallId, name: params.subagentType, task: params.description, status: "done" });
+      },
       readTextFile: async (p) => ({ content: await Bun.file(p.path).text() }),
       writeTextFile: async (p) => {
         await Bun.write(p.path, p.content);
@@ -77,7 +102,7 @@ export class AcpEngine implements Engine {
       },
     };
     this.conn = new ClientSideConnection(() => client, stream);
-    const init = await this.conn.initialize({ protocolVersion: 1, clientCapabilities: { fs: { readTextFile: true, writeTextFile: true }, terminal: false } });
+    const init = await this.conn.initialize({ protocolVersion: 1, clientCapabilities: { fs: { readTextFile: true, writeTextFile: true }, terminal: false, ...(o.questions === false ? {} : { elicitation: { form: {} } }) } });
 
     let sessionId: string;
     let modes: any;
@@ -85,21 +110,21 @@ export class AcpEngine implements Engine {
     let config: any;
     if (o.resume) {
       try {
-        const r: any = await this.conn.loadSession({ sessionId: o.resume.id, cwd: o.cwd, mcpServers: [] });
+        const r: any = await this.signedIn(init, () => this.conn!.loadSession({ sessionId: o.resume!.id, cwd: o.cwd, mcpServers: [] }));
         sessionId = o.resume.id;
         modes = r?.modes;
         models = r?.models;
         config = r?.configOptions;
       } catch (e: any) {
         this.emit({ type: "log", level: "warn", message: `resume failed (${e?.message ?? e}); starting a new session` });
-        const s: any = await this.conn.newSession({ cwd: o.cwd, mcpServers: [] });
+        const s: any = await this.signedIn(init, () => this.conn!.newSession({ cwd: o.cwd, mcpServers: [] }));
         sessionId = s.sessionId;
         config = s.configOptions;
         modes = s.modes;
         models = s.models;
       }
     } else {
-      const s: any = await this.conn.newSession({ cwd: o.cwd, mcpServers: [] });
+      const s: any = await this.signedIn(init, () => this.conn!.newSession({ cwd: o.cwd, mcpServers: [] }));
       sessionId = s.sessionId;
       modes = s.modes;
       models = s.models;
@@ -134,8 +159,28 @@ export class AcpEngine implements Engine {
     return this.info;
   }
 
+  /** Run `fn`; if the agent wants a sign-in first, sign in with an allowed method and run it again. */
+  private async signedIn<T>(init: any, fn: () => Promise<T>): Promise<T> {
+    try {
+      return await fn();
+    } catch (e: any) {
+      // -32000 is ACP's "auth required"; some agents send it as an internal error with the reason in data.
+      const needsAuth = e?.code === -32000 || /authenticat|auth required|sign.?in|log.?in/i.test(`${e?.message ?? ""} ${JSON.stringify(e?.data ?? "")}`);
+      const method = (init?.authMethods ?? []).map((m: any) => m.id).find((id: string) => this.opts.signIn?.includes(id));
+      if (!needsAuth || !this.conn) throw e;
+      if (!method) {
+        const offered = (init?.authMethods ?? []).map((m: any) => m.name ?? m.id).join(", ") || "none";
+        throw new Error(`${this.opts.name} needs you to sign in, and offers no subscription sign-in codemax may use (offered: ${offered}). codemax never uses API keys.`);
+      }
+      this.emit({ type: "log", level: "warn", message: `signing in to ${this.opts.name} with your subscription (${method}); a browser window may open the first time` });
+      await this.conn.authenticate({ methodId: method } as any);
+      return fn();
+    }
+  }
+
   private spawn(cwd: string): Stream {
-    const proc = Bun.spawn(platformArgv(this.opts.cmd), { cwd, env: agentEnv(this.opts.env), stdin: "pipe", stdout: "pipe", stderr: "pipe" });
+    const argv = this.opts.plainPipes && !IS_WINDOWS ? ["/bin/sh", "-c", 'cat | "$@" | cat', "sh", ...this.opts.cmd] : platformArgv(this.opts.cmd);
+    const proc = Bun.spawn(argv, { cwd, env: agentEnv(this.opts.env), stdin: "pipe", stdout: "pipe", stderr: "pipe" });
     this.proc = proc;
     void (async () => {
       for await (const chunk of proc.stderr as ReadableStream<Uint8Array>) {
@@ -182,9 +227,11 @@ export class AcpEngine implements Engine {
         if (u.content?.type === "text") this.emit({ type: "thought_delta", text: u.content.text, messageId: u.messageId });
         break;
       case "tool_call":
+        this.trackSubagent(u, true);
         this.emit({ type: "tool_call", id: u.toolCallId, title: u.title ?? u.toolCallId, kind: u.kind, status: mapStatus(u.status), detail: summarize(u), input: u.rawInput, files: paths(u), ...full(u) });
         break;
       case "tool_call_update":
+        this.trackSubagent(u, false);
         this.emit({ type: "tool_update", id: u.toolCallId, status: u.status ? mapStatus(u.status) : undefined, title: u.title, detail: summarize(u), input: u.rawInput, files: paths(u), ...full(u) });
         break;
       case "plan":
@@ -215,13 +262,15 @@ export class AcpEngine implements Engine {
   async prompt(text: string): Promise<StopReason> {
     if (!this.conn || !this.session) throw new Error("engine not started");
     this.turnActive = true;
+    this.cancelled = false;
     this.turnContext = 0;
     try {
       const res: any = await this.conn.prompt({ sessionId: this.session.id, prompt: [{ type: "text", text }] });
       this.session.lastUsedAt = Date.now();
       this.flushUsage();
       this.emitTurnUsage(res?.usage);
-      const reason = mapStop(res.stopReason);
+      // Some agents (Antigravity) end an interrupted turn with "end_turn": it was still cancelled.
+      const reason = this.cancelled ? "cancelled" : mapStop(res.stopReason);
       this.emit({ type: "turn_end", stopReason: reason });
       return reason;
     } catch (e: any) {
@@ -240,6 +289,61 @@ export class AcpEngine implements Engine {
     this.pendingPermissions.get(requestId)?.(optionId);
   }
 
+  answerQuestion(requestId: string, answer: QuestionAnswer) {
+    this.pendingQuestions.get(requestId)?.(answer);
+  }
+
+  /** Launch tool call id → whether it runs in the background (its "completed" only means launched). */
+  private subagentLaunches = new Map<string, { background: boolean }>();
+
+  /**
+   * Subagents from tool calls. A launch is Claude's Agent/Task tool, OpenCode's task tool or
+   * Cursor's "Task: …" (all carry subagent_type / description / prompt). Claude stamps each of
+   * the subagent's own tool calls with `_meta.claudeCode.parentToolUseId`: that is its activity.
+   */
+  private trackSubagent(u: any, isNew: boolean) {
+    const id = u.toolCallId;
+    const meta = u._meta?.claudeCode ?? {};
+    const parent = meta.parentToolUseId;
+    if (parent && this.subagentLaunches.has(parent)) {
+      if (isNew && u.title) this.emit({ type: "subagent", id: parent, activity: String(u.title) });
+      return;
+    }
+    const launch = this.subagentLaunches.get(id);
+    if (launch) {
+      const st = u.status;
+      if (st === "failed") this.emit({ type: "subagent", id, status: "failed" });
+      else if (st === "completed" && !launch.background) this.emit({ type: "subagent", id, status: "done" });
+      return;
+    }
+    if (!isNew) return;
+    const input = u.rawInput ?? {};
+    const tool = String(meta.toolName ?? input._toolName ?? "");
+    const type = input.subagent_type ?? input.subagentType;
+    const isLaunch = /^(agent|task)$/i.test(tool) || typeof type === "string" || /^Task: /.test(String(u.title ?? ""));
+    if (!isLaunch || !(input.prompt || input.description || type)) return;
+    this.subagentLaunches.set(id, { background: !!(input.run_in_background ?? input.background) });
+    this.emit({ type: "subagent", id, name: typeof type === "string" && type ? type : input.name ?? "agent", task: input.description ?? String(u.title ?? "").replace(/^Task: /, ""), status: "running" });
+  }
+
+  /** A spawned agent's own session (agents that run subagents as sessions). */
+  private onChildSession(sessionId: string, u: any) {
+    if (u?.sessionUpdate === "tool_call" && u.title) this.emit({ type: "subagent", id: sessionId, activity: String(u.title) });
+  }
+
+  private async onElicitation(p: any) {
+    if (p?.mode && p.mode !== "form") return { action: "decline" };
+    const id = `ask-${++this.permSeq}`;
+    const request = parseElicitation(id, p);
+    if (!request.fields.length) return { action: "decline" };
+    const answer = await new Promise<QuestionAnswer>((resolve) => {
+      this.pendingQuestions.set(id, resolve);
+      this.emit({ type: "question_request", request });
+    });
+    this.pendingQuestions.delete(id);
+    return elicitationResponse(answer);
+  }
+
   private currentModelName(): string {
     const id = this.info?.currentModel;
     return id ?? `${this.opts.name.toLowerCase()} default model`;
@@ -278,7 +382,9 @@ export class AcpEngine implements Engine {
 
   async cancel() {
     if (!this.conn || !this.session || !this.turnActive) return;
+    this.cancelled = true;
     for (const resolve of this.pendingPermissions.values()) resolve(null);
+    for (const resolve of this.pendingQuestions.values()) resolve({ action: "cancel" });
     await this.conn.cancel({ sessionId: this.session.id }).catch(() => {});
   }
 
@@ -312,8 +418,15 @@ export class AcpEngine implements Engine {
     const conn = this.conn;
     this.conn = null;
     for (const resolve of this.pendingPermissions.values()) resolve(null);
+    for (const resolve of this.pendingQuestions.values()) resolve({ action: "cancel" });
     if (conn && this.session) await conn.closeSession?.({ sessionId: this.session.id }).catch(() => {});
     if (this.proc) {
+      try {
+        // End of input first: an agent behind plain pipes (and its `cat`s) exits on EOF.
+        (this.proc.stdin as any)?.end?.();
+      } catch {
+        /* already closed */
+      }
       try {
         this.proc.kill();
       } catch {

package/src/engines/antigravity.ts

@@ -0,0 +1,95 @@
+import { chmodSync, existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { CODEMAX_HOME } from "../core/paths.ts";
+import { IS_WINDOWS } from "../core/spawn.ts";
+
+/**
+ * Antigravity CLI (`agy`, Google's successor to Gemini CLI) has no ACP mode of
+ * its own. Google publishes a separate ACP server for it in the ACP agent
+ * registry (the one Zed installs): `agy_acp_server`. codemax drives that, over
+ * plain pipes, signed in with the user's Google account (`oauth-personal`).
+ *
+ * The server is not bundled (it is proprietary and ~110 MB): codemax offers to
+ * download it from the registry's own link, only from dl.google.com, into
+ * ~/.codemax/agents/antigravity-acp/<version>/.
+ */
+export const REGISTRY_URL = "https://raw.githubusercontent.com/agentclientprotocol/registry/main/antigravity-acp/agent.json";
+const DIR = () => join(CODEMAX_HOME, "agents", "antigravity-acp");
+const BIN = IS_WINDOWS ? "agy_acp_server.exe" : "agy_acp_server.par";
+
+export interface ServerSpec {
+  cmd: string[];
+  version: string;
+}
+
+/** The installed ACP server (newest version first), or one on PATH; null when none. */
+export function antigravityServer(): ServerSpec | null {
+  const onPath = Bun.which("agy_acp_server") ?? Bun.which("agy-acp-server");
+  if (onPath) return { cmd: [onPath, ...linuxArgs()], version: "PATH" };
+  const dir = DIR();
+  if (!existsSync(dir)) return null;
+  const versions = readdirSync(dir)
+    .filter((v) => existsSync(join(dir, v, BIN)))
+    .sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
+  return versions[0] ? { cmd: [join(dir, versions[0], BIN), ...linuxArgs()], version: versions[0] } : null;
+}
+
+/** The registry asks Linux builds to run with `--uid=`. */
+function linuxArgs(): string[] {
+  return process.platform === "linux" ? ["--uid="] : [];
+}
+
+/** The registry key for this machine ("darwin-aarch64", "windows-x86_64"…). */
+export function platformKey(platform = process.platform, arch = process.arch): string {
+  const os = platform === "win32" ? "windows" : platform;
+  return `${os}-${arch === "arm64" ? "aarch64" : arch === "x64" ? "x86_64" : arch}`;
+}
+
+export interface InstallPlan {
+  version: string;
+  url: string;
+  bytes?: number;
+}
+
+/** What would be downloaded: the registry's latest version for this machine, and its size. */
+export async function antigravityInstallPlan(fetchImpl: typeof fetch = fetch): Promise<InstallPlan> {
+  const res = await fetchImpl(REGISTRY_URL, { signal: AbortSignal.timeout(10_000) });
+  if (!res.ok) throw new Error(`the ACP registry answered ${res.status}`);
+  const entry: any = await res.json();
+  const bin = entry?.distribution?.binary?.[platformKey()];
+  if (!bin?.archive) throw new Error(`Google publishes no Antigravity ACP server for ${platformKey()}`);
+  const url = String(bin.archive);
+  // Only Google's own download host: a changed registry entry can't point codemax elsewhere.
+  if (!/^https:\/\/dl\.google\.com\//.test(url)) throw new Error(`refusing to download the ACP server from ${new URL(url).host} (expected dl.google.com)`);
+  let bytes: number | undefined;
+  try {
+    const head = await fetchImpl(url, { method: "HEAD", signal: AbortSignal.timeout(10_000) });
+    bytes = Number(head.headers.get("content-length")) || undefined;
+  } catch {
+    /* size unknown */
+  }
+  return { version: String(entry.version ?? "latest"), url, bytes };
+}
+
+/** Download and unpack the server. Returns its command. */
+export async function installAntigravityServer(plan: InstallPlan, onProgress: (msg: string) => void = () => {}): Promise<ServerSpec> {
+  const dest = join(DIR(), plan.version);
+  const zip = join(DIR(), `agy-acp-${plan.version}.zip`);
+  mkdirSync(dest, { recursive: true });
+  onProgress(`downloading ${plan.url}${plan.bytes ? ` (${Math.round(plan.bytes / 1e6)} MB)` : ""}`);
+  const res = await fetch(plan.url);
+  if (!res.ok || !res.body) throw new Error(`download failed: ${res.status}`);
+  await Bun.write(zip, res);
+  onProgress("unpacking");
+  const unzip = IS_WINDOWS
+    ? ["powershell", "-NoProfile", "-Command", `Expand-Archive -LiteralPath '${zip.replace(/'/g, "''")}' -DestinationPath '${dest.replace(/'/g, "''")}' -Force`]
+    : ["unzip", "-q", "-o", zip, "-d", dest];
+  const p = Bun.spawn(unzip, { stdout: "pipe", stderr: "pipe" });
+  const code = await p.exited;
+  rmSync(zip, { force: true });
+  if (code !== 0) throw new Error(`could not unpack the archive: ${(await new Response(p.stderr).text()).trim().slice(0, 200)}`);
+  const bin = join(dest, BIN);
+  if (!existsSync(bin)) throw new Error(`the archive has no ${BIN}`);
+  if (!IS_WINDOWS) chmodSync(bin, 0o755);
+  return { cmd: [bin, ...linuxArgs()], version: plan.version };
+}

package/src/engines/codex.ts

@@ -37,7 +37,8 @@ export class CodexEngine implements Engine {
   private threadId: string | null = null;
   private cwd = "";
   private model: string | undefined;
-  private lastTotals = { inputTokens: 0, cachedInputTokens: 0, cacheWriteInputTokens: 0, outputTokens: 0 };
+  /** Cumulative token totals per thread (the main one and each spawned agent's), to emit deltas. */
+  private lastTotals = new Map<string, { inputTokens: number; cachedInputTokens: number; cacheWriteInputTokens: number; outputTokens: number }>();
 
   constructor(private opts: CodexEngineOptions = {}) {}
 
@@ -192,7 +193,63 @@ export class CodexEngine implements Engine {
     this.transport!.send(JSON.stringify({ jsonrpc: "2.0", id: m.id, error: { code: -32601, message: `codemax does not handle ${method}` } }));
   }
 
+  /**
+   * Token usage of one thread. Totals are cumulative per thread; the delta is emitted. A spawned
+   * agent's thread counts too: it runs on the same Codex plan, so /usage and budgets include it.
+   * Codex's inputTokens include cached ones.
+   */
+  private usageFrom(p: any, thread: string) {
+    const rl = p.rateLimits ?? p.tokenUsage?.rateLimits;
+    const used = rl?.primary?.usedPercent ?? rl?.primary?.used_percent;
+    const t = p.tokenUsage?.total;
+    const main = thread === (this.threadId ?? "main");
+    if (!t) {
+      if (typeof used === "number") this.emit({ type: "usage", usedPercent: used });
+      return;
+    }
+    const last = this.lastTotals.get(thread) ?? { inputTokens: 0, cachedInputTokens: 0, cacheWriteInputTokens: 0, outputTokens: 0 };
+    const d = {
+      inputTokens: Math.max(0, (t.inputTokens ?? 0) - last.inputTokens),
+      cachedInputTokens: Math.max(0, (t.cachedInputTokens ?? 0) - last.cachedInputTokens),
+      cacheWriteInputTokens: Math.max(0, (t.cacheWriteInputTokens ?? 0) - last.cacheWriteInputTokens),
+      outputTokens: Math.max(0, (t.outputTokens ?? 0) - last.outputTokens),
+    };
+    this.lastTotals.set(thread, { inputTokens: t.inputTokens ?? 0, cachedInputTokens: t.cachedInputTokens ?? 0, cacheWriteInputTokens: t.cacheWriteInputTokens ?? 0, outputTokens: t.outputTokens ?? 0 });
+    if (!d.inputTokens && !d.outputTokens) return;
+    this.emit({
+      type: "usage",
+      inputTokens: Math.max(0, d.inputTokens - d.cachedInputTokens),
+      cacheReadTokens: d.cachedInputTokens,
+      cacheWriteTokens: d.cacheWriteInputTokens,
+      outputTokens: d.outputTokens,
+      model: main ? this.model : (p.tokenUsage?.model ?? this.model),
+      usedPercent: typeof used === "number" ? used : undefined,
+      // Context fill is the main thread's; a helper's window says nothing about it.
+      contextSize: main ? p.tokenUsage?.modelContextWindow : undefined,
+    });
+  }
+
+  /** Notifications from a spawned agent's thread: start, latest step, usage, end. */
+  private onChildThread(method: string, p: any, id: string) {
+    if (method === "thread/tokenUsage/updated" || method === "turn/tokenUsage/updated") return this.usageFrom(p, id);
+    if (method === "thread/started") {
+      const t = p.thread ?? {};
+      this.emit({ type: "subagent", id, name: t.agentRole ?? t.agentNickname, task: t.agentNickname && t.agentRole ? t.agentNickname : undefined, status: "running" });
+    } else if (method === "item/started") {
+      const it = p.item ?? {};
+      const step = it.type === "commandExecution" ? `$ ${Array.isArray(it.command) ? it.command.join(" ") : it.command ?? ""}` : it.type === "fileChange" ? `edit ${(it.changes ?? []).map((c: any) => c.path).join(", ")}` : it.type === "mcpToolCall" ? `${it.server}/${it.tool}` : undefined;
+      if (step) this.emit({ type: "subagent", id, activity: step });
+    } else if (method === "turn/completed") {
+      const status = p.turn?.status;
+      this.emit({ type: "subagent", id, status: status === "failed" || p.turn?.error ? "failed" : "done" });
+    }
+  }
+
   private onNotification(method: string, p: any) {
+    // A spawned agent runs on its own thread over this connection: its messages, tools and
+    // turn end must never land in (or end) the main turn. They become subagent activity.
+    const thread = p?.threadId ?? p?.turn?.threadId ?? (method === "thread/started" ? p?.thread?.id : undefined);
+    if (thread && this.threadId && thread !== this.threadId) return this.onChildThread(method, p, thread);
     switch (method) {
       case "item/agentMessage/delta":
         this.emit({ type: "text_delta", text: p.delta ?? "" });
@@ -207,6 +264,10 @@ export class CodexEngine implements Engine {
       case "item/updated": {
         const it = p.item ?? {};
         if (it.type === "agentMessage" || it.type === "userMessage" || it.type === "reasoning") break;
+        if (it.type === "subAgentActivity") {
+          if (it.agentThreadId) this.emit({ type: "subagent", id: it.agentThreadId, name: agentName(it.agentPath), status: it.kind === "completed" ? "done" : it.kind === "failed" ? "failed" : "running" });
+          break;
+        }
         const status: ToolStatus = method === "item/started" ? "in_progress" : it.status === "failed" || it.status === "declined" ? "failed" : method === "item/completed" ? "completed" : "in_progress";
         const title = it.type === "commandExecution" ? `$ ${Array.isArray(it.command) ? it.command.join(" ") : it.command ?? ""}` : it.type === "fileChange" ? `edit ${(it.changes ?? []).map((c: any) => c.path).join(", ")}` : it.type === "mcpToolCall" ? `${it.server}/${it.tool}` : it.type ?? "tool";
         const detail = it.aggregatedOutput ? String(it.aggregatedOutput).slice(-800) : undefined;
@@ -226,34 +287,9 @@ export class CodexEngine implements Engine {
         this.emit({ type: "plan", entries: (p.plan ?? p.entries ?? []).map((e: any) => ({ content: e.step ?? e.content, status: e.status })) });
         break;
       case "thread/tokenUsage/updated":
-      case "turn/tokenUsage/updated": {
-        const rl = p.rateLimits ?? p.tokenUsage?.rateLimits;
-        const used = rl?.primary?.usedPercent ?? rl?.primary?.used_percent;
-        const t = p.tokenUsage?.total;
-        if (t) {
-          // Totals are cumulative for the thread; emit the delta. Codex's inputTokens include cached ones.
-          const d = {
-            inputTokens: Math.max(0, (t.inputTokens ?? 0) - this.lastTotals.inputTokens),
-            cachedInputTokens: Math.max(0, (t.cachedInputTokens ?? 0) - this.lastTotals.cachedInputTokens),
-            cacheWriteInputTokens: Math.max(0, (t.cacheWriteInputTokens ?? 0) - this.lastTotals.cacheWriteInputTokens),
-            outputTokens: Math.max(0, (t.outputTokens ?? 0) - this.lastTotals.outputTokens),
-          };
-          this.lastTotals = { inputTokens: t.inputTokens ?? 0, cachedInputTokens: t.cachedInputTokens ?? 0, cacheWriteInputTokens: t.cacheWriteInputTokens ?? 0, outputTokens: t.outputTokens ?? 0 };
-          if (d.inputTokens || d.outputTokens) {
-            this.emit({
-              type: "usage",
-              inputTokens: Math.max(0, d.inputTokens - d.cachedInputTokens),
-              cacheReadTokens: d.cachedInputTokens,
-              cacheWriteTokens: d.cacheWriteInputTokens,
-              outputTokens: d.outputTokens,
-              model: this.model,
-              usedPercent: typeof used === "number" ? used : undefined,
-              contextSize: p.tokenUsage?.modelContextWindow,
-            });
-          }
-        } else if (typeof used === "number") this.emit({ type: "usage", usedPercent: used });
+      case "turn/tokenUsage/updated":
+        this.usageFrom(p, this.threadId ?? "main");
         break;
-      }
       case "turn/completed": {
         const status = p.turn?.status;
         const err = p.turn?.error;
@@ -377,3 +413,8 @@ export class CodexEngine implements Engine {
 function classify(msg: string) {
   return classifyError(msg);
 }
+
+/** "/root/explorer" → "explorer". */
+function agentName(path: unknown): string | undefined {
+  return typeof path === "string" && path ? path.split("/").filter(Boolean).pop() : undefined;
+}

package/src/engines/elicitation.ts

@@ -0,0 +1,60 @@
+import type { QuestionAnswer, QuestionField, QuestionRequest } from "./types.ts";
+
+/**
+ * ACP form elicitations → questions codemax can ask in its own dialog.
+ *
+ * Agents ask through a JSON-schema form (`requestedSchema`). The Claude
+ * adapter uses it for AskUserQuestion: one `question_<n>` field per question
+ * (a `oneOf` pick, or an array of `anyOf` picks for multi-select) followed by
+ * a free-text `question_<n>_custom` "Other" field. MCP servers and other
+ * agents may send any flat schema, so every property type is handled; an
+ * unknown one is asked as text.
+ */
+export function parseElicitation(id: string, p: any): QuestionRequest {
+  const schema = p?.requestedSchema ?? {};
+  const props: Record<string, any> = schema.properties ?? {};
+  const required = new Set<string>(Array.isArray(schema.required) ? schema.required : []);
+  const keys = Object.keys(props);
+  const isSelect = (k: string) => !!props[k] && (opts(props[k]).length > 0 || props[k].type === "boolean");
+  // `<key>_custom` (the adapter's per-question "Other" box) folds into its question.
+  const companion = (k: string) => k.endsWith("_custom") && isSelect(k.slice(0, -"_custom".length)) && (props[k]?.type ?? "string") === "string";
+  const fields: QuestionField[] = [];
+  for (const key of keys) {
+    if (companion(key)) continue;
+    const s = props[key] ?? {};
+    const options = opts(s);
+    const kind: QuestionField["kind"] = s.type === "array" ? "multi" : s.type === "boolean" ? "boolean" : options.length ? "single" : s.type === "number" || s.type === "integer" ? "number" : "text";
+    const other = keys.find((k) => k === `${key}_custom`);
+    fields.push({
+      key,
+      title: str(s.title),
+      question: str(s.description) ?? (keys.filter((k) => !companion(k)).length === 1 ? String(p?.message ?? "") : str(s.title) ?? key),
+      kind,
+      options: kind === "boolean" ? [{ value: "true", label: "Yes" }, { value: "false", label: "No" }] : options,
+      otherKey: other && kind !== "boolean" ? other : undefined,
+      required: required.has(key),
+      integer: s.type === "integer" || undefined,
+    });
+  }
+  return { id, message: String(p?.message ?? ""), fields, toolCallId: p?.toolCallId };
+}
+
+/** The ACP response for an answer (`content` keys are the schema's property names). */
+export function elicitationResponse(a: QuestionAnswer): { action: string; content?: Record<string, unknown> } {
+  return a.action === "accept" ? { action: "accept", content: a.content } : { action: a.action };
+}
+
+function opts(s: any): { value: string; label: string; description?: string }[] {
+  const list = s?.oneOf ?? s?.anyOf ?? s?.items?.oneOf ?? s?.items?.anyOf;
+  if (Array.isArray(list)) return list.filter((o) => o && o.const !== undefined).map((o) => ({ value: String(o.const), label: str(o.title) ?? String(o.const), description: str(o.description) }));
+  const en = s?.enum ?? s?.items?.enum;
+  if (Array.isArray(en)) {
+    const names = s?.enumNames ?? s?.items?.enumNames;
+    return en.map((v: unknown, i: number) => ({ value: String(v), label: Array.isArray(names) && names[i] ? String(names[i]) : String(v) }));
+  }
+  return [];
+}
+
+function str(v: unknown): string | undefined {
+  return typeof v === "string" && v.trim() ? v : undefined;
+}

package/src/engines/index.ts

@@ -6,6 +6,7 @@ import type { Engine, EngineFactory } from "./types.ts";
 import { AcpEngine, type UsageSample } from "./acp.ts";
 import { CodexEngine } from "./codex.ts";
 import { ClaudeUsageTail } from "../transcripts/claude-usage.ts";
+import { antigravityServer } from "./antigravity.ts";
 
 /** Grok writes ~/.grok/sessions/<encoded cwd>/<session>/usage.json with per-turn totals. */
 function grokUsageTail(cwd: string, sessionId: string): { read(): UsageSample[] } {
@@ -115,9 +116,11 @@ const factories: EngineFactory[] = [
     create: () => new AcpEngine({ agent: "cursor", name: "Cursor Agent", cmd: ["cursor-agent", "acp"] }),
   },
   {
-    agent: "gemini",
-    available: async () => !!Bun.which("gemini"),
-    create: () => new AcpEngine({ agent: "gemini", name: "Gemini CLI", cmd: ["gemini", "--experimental-acp"] }),
+    agent: "antigravity",
+    // Google's ACP server for Antigravity (installed on request, see antigravity.ts), driven over
+    // plain pipes and signed in with the user's Google account only, never an API key.
+    available: async () => !!Bun.which("agy") && !!antigravityServer(),
+    create: () => new AcpEngine({ agent: "antigravity", name: "Antigravity CLI", cmd: antigravityServer()!.cmd, plainPipes: true, signIn: ["oauth-personal", "oauth-business"] }),
   },
 ];
 

package/src/engines/types.ts

@@ -12,6 +12,10 @@ export type EngineEvent =
   | { type: "tool_call"; id: string; title: string; kind?: string; status: ToolStatus; detail?: string; input?: unknown; output?: string; files?: string[] }
   | { type: "tool_update"; id: string; status?: ToolStatus; title?: string; detail?: string; input?: unknown; output?: string; files?: string[] }
   | { type: "permission_request"; request: PermissionRequest }
+  /** A subagent the main agent spawned (Task/Agent tool…): started, doing something, or finished. */
+  | SubagentEvent
+  /** The agent asks the user something (Claude's AskUserQuestion, MCP forms). Answer with `answerQuestion`. */
+  | { type: "question_request"; request: QuestionRequest }
   | { type: "plan"; entries: { content: string; status: string; priority?: string }[] }
   | { type: "mode"; modeId: string }
   | { type: "commands"; commands: { name: string; description?: string }[] }
@@ -68,6 +72,43 @@ export interface PermissionRequest {
   options: PermissionOption[];
 }
 
+export interface SubagentEvent {
+  type: "subagent";
+  /** Stable id (the launching tool call's id). */
+  id: string;
+  /** Agent type or name ("Explore", "general-purpose"). */
+  name?: string;
+  /** What it was asked to do (short description). */
+  task?: string;
+  /** Its latest step ("Grep(requireAuth)"). */
+  activity?: string;
+  status?: "running" | "done" | "failed";
+}
+
+export interface QuestionField {
+  /** Property name in the agent's form; the answer is keyed by it. */
+  key: string;
+  /** Short label ("Database"), when the agent gives one. */
+  title?: string;
+  question: string;
+  kind: "single" | "multi" | "text" | "number" | "boolean";
+  options: { value: string; label: string; description?: string }[];
+  /** Companion free-text field the agent accepts as "Other". */
+  otherKey?: string;
+  required?: boolean;
+  integer?: boolean;
+}
+
+export interface QuestionRequest {
+  id: string;
+  message: string;
+  fields: QuestionField[];
+  toolCallId?: string;
+}
+
+/** accept = answered; decline = the user skipped (the agent carries on); cancel = abort the request. */
+export type QuestionAnswer = { action: "accept"; content: Record<string, string | number | boolean | string[]> } | { action: "decline" } | { action: "cancel" };
+
 export interface EngineSessionRef {
   agent: AgentId;
   /** Vendor session / thread id, used to resume. */
@@ -84,6 +125,8 @@ export interface EngineMode {
 }
 
 export interface EngineStartOptions {
+  /** Let the agent ask the user questions (form elicitation). Off: the agent decides on its own. */
+  questions?: boolean;
   cwd: string;
   /** Resume a previous session instead of starting a new one. */
   resume?: EngineSessionRef;
@@ -126,6 +169,8 @@ export interface Engine {
   /** Send one user turn. Resolves when the turn ends (turn_end has been emitted). */
   prompt(text: string): Promise<StopReason>;
   answerPermission(requestId: string, optionId: string): void;
+  /** Engines that can ask the user questions (`question_request`) answer them here. */
+  answerQuestion?(requestId: string, answer: QuestionAnswer): void;
   cancel(): Promise<void>;
   setMode?(modeId: string): Promise<void>;
   setModel?(modelId: string): Promise<void>;