codemax-cli 0.1.3 → 0.1.5

package/src/config.ts

@@ -36,12 +36,22 @@ export interface Config {
   /**
    * Side agent: another agent that reviews the main agent's work after each turn and
    * leaves a note when something needs attention. `forward: "auto"` sends notes to the
-   * main agent by itself; "ask" waits for /forward.
+   * main agent by itself; "ask" shows them above the prompt (1 expand · 2 discuss · 0 dismiss).
    */
-  /** `every`: review every Nth working turn (1 = each turn, 0 = only on /review). Each review is a request on the side agent's plan. */
-  sideAgent: { agent: AgentId | null; forward: "ask" | "auto"; model?: string; every?: number };
+  /** `every`: review every Nth working turn (1 = each turn, 0 = paused). Each review is a request on the side agent's plan. */
+  /** `samePlan`: the user chose to let the side agent review on the main agent's own plan (off unless picked explicitly). */
+  sideAgent: { agent: AgentId | null; forward: "ask" | "auto"; model?: string; every?: number; samePlan?: boolean };
   /** Check npm for a newer codemax at most every 12 hours and offer /update. */
   updateCheck: boolean;
+  /**
+   * Agent questions (Claude's AskUserQuestion, MCP forms): "ask" shows them and waits,
+   * "timeout" skips one left unanswered for 5 minutes (unattended runs), "off" never lets agents ask.
+   */
+  questions?: "ask" | "timeout" | "off";
+  /** Tell the terminal what codemax is doing: Warp's agent badge and status, OSC 7501 elsewhere. */
+  terminalStatus?: boolean;
+  /** Desktop notification when an agent waits for you, or a turn longer than bellAfterSeconds ends, while the terminal is not focused. */
+  notifications?: boolean;
   /** Colour theme: "auto" follows the terminal's background, or force "dark" / "light". */
   theme: "auto" | "dark" | "light";
   /**
@@ -52,7 +62,7 @@ export interface Config {
 }
 
 export const DEFAULT_CONFIG: Config = {
-  order: ["claude", "codex", "opencode", "cursor", "grok", "gemini", "copilot"],
+  order: ["claude", "codex", "opencode", "cursor", "grok", "antigravity", "copilot"],
   hotkeys: ["ctrl+/", "ctrl+^"],
   autoSwitch: true,
   agentArgs: {},
@@ -65,6 +75,9 @@ export const DEFAULT_CONFIG: Config = {
   theme: "auto",
   awake: "off",
   updateCheck: true,
+  questions: "ask",
+  terminalStatus: true,
+  notifications: true,
   sideAgent: { agent: null, forward: "ask" },
   brief: { turns: 10, maxChars: 8000, turnChars: 1200, resumeChars: 24000 },
 };

package/src/core/brief.ts

@@ -4,6 +4,7 @@ import { diffStat, headLine, recentCommits } from "./git.ts";
 import { checkpointDiff } from "./checkpoint.ts";
 import { BRIEF_MARKER, type Ledger } from "./ledger.ts";
 import type { Step, StepOf } from "./journal.ts";
+import { fmtTime12 } from "./time.ts";
 
 export interface BriefInput {
   ledger: Ledger;
@@ -161,7 +162,7 @@ export async function buildCatchup(input: BriefInput): Promise<string | null> {
 function whereItStopped(steps: Step[], end: StepOf<"end"> | undefined): string[] {
   const out: string[] = [];
   if (!end) return ["The last agent had not finished its first turn."];
-  const when = new Date(end.ts).toLocaleTimeString([], { hour: "numeric", minute: "2-digit" });
+  const when = fmtTime12(end.ts);
   const why =
     end.outcome === "limit" ? `ran out of its usage limit${end.detail ? ` ("${oneLine(end.detail, 140)}")` : ""}`
     : end.outcome === "cancelled" ? "was interrupted by the user"

package/src/core/quota.ts

@@ -1,5 +1,6 @@
 import type { AgentId, QuotaStatus } from "../adapters/types.ts";
 import { stripAnsi } from "./terminal.ts";
+import { fmtTime12 } from "./time.ts";
 
 /**
  * Vendor-neutral phrases. Deliberately narrow: "rate limit" or "429" alone
@@ -47,7 +48,7 @@ export class OutputScanner {
 export function quotaLabel(q?: QuotaStatus): string {
   if (!q) return "";
   if (isExhausted(q)) {
-    const reset = q.resetsAt ? ` until ${new Date(q.resetsAt).toLocaleTimeString()}` : "";
+    const reset = q.resetsAt ? ` until ${fmtTime12(q.resetsAt)}` : "";
     return q.source === "output" ? `exhausted? (text match)${reset}` : `EXHAUSTED${reset}`;
   }
   if (typeof q.usedPercent === "number") return `${Math.round(q.usedPercent)}% used`;

package/src/core/termstatus.ts

@@ -0,0 +1,124 @@
+import { basename } from "node:path";
+import type { AgentId } from "../adapters/types.ts";
+
+/**
+ * What the terminal around codemax shows about it: the tab's agent badge and
+ * running / waiting / done status, and a notification when you are needed.
+ *
+ * - Warp: its "cli-agent" channel (OSC 777 with the title `warp://cli-agent`
+ *   and a JSON body). Warp only has built-in logos, so the tab shows the agent
+ *   codemax is driving (Claude Code, Codex, OpenCode, Cursor, Copilot, and
+ *   Antigravity under Warp's Gemini badge, Google's closest logo there);
+ *   other agents get status without a badge. Warp raises its own notifications
+ *   from these events, so codemax sends none of its own there.
+ * - Other terminals: OSC 7501 program status (working / blocked / done), which
+ *   terminals that lack it ignore, and a desktop notification when an agent
+ *   waits for you or a long turn ends while the terminal is not focused.
+ *
+ * Every write goes through the renderer (`TerminalSink`), never straight to
+ * stdout, so it can never land inside a frame.
+ */
+export interface TerminalSink {
+  status(s: { state: "idle" | "working" | "blocked" | "done" | "error" | "clear" }): void;
+  notify(message: string, title?: string): void;
+}
+
+/** Agent names Warp has a logo for (checked against Warp 2026.09). */
+export const WARP_AGENTS: Partial<Record<AgentId, string>> = { claude: "claude", codex: "codex", antigravity: "gemini", opencode: "opencode", cursor: "cursor", copilot: "copilot" };
+
+// Warp builds that advertise the protocol but drop it (from Warp's own adapters).
+const WARP_BROKEN: Record<string, string> = { stable: "v0.2026.03.25.08.24.stable_05", preview: "v0.2026.03.25.08.24.preview_05" };
+
+export function warpSupported(env: Record<string, string | undefined> = process.env): boolean {
+  if (!env.WARP_CLI_AGENT_PROTOCOL_VERSION || !env.WARP_CLIENT_VERSION) return false;
+  const channel = Object.keys(WARP_BROKEN).find((c) => env.WARP_CLIENT_VERSION!.includes(c));
+  return !channel || env.WARP_CLIENT_VERSION > WARP_BROKEN[channel]!;
+}
+
+const cut = (s: string, n: number) => (s.length > n ? s.slice(0, n - 3) + "..." : s);
+
+export class TerminalStatus {
+  private agent: { id: AgentId; name: string; session: string } | null = null;
+  private lastQuery = "";
+  private readonly warp: boolean;
+  /** True/false once the terminal reports focus; null when it never has. */
+  focused: boolean | null = null;
+
+  constructor(
+    private sink: TerminalSink,
+    private o: { cwd: string; env?: Record<string, string | undefined>; enabled: () => boolean; notify: () => boolean },
+  ) {
+    this.warp = warpSupported(o.env ?? process.env);
+  }
+
+  /** An agent's session is ready (start, switch, handoff). */
+  started(id: AgentId, name: string, session = "") {
+    this.agent = { id, name, session };
+    this.warpEvent("session_start");
+    this.status("idle");
+  }
+
+  prompt(text: string) {
+    this.lastQuery = text;
+    this.warpEvent("prompt_submit", { query: cut(text, 200) });
+    this.status("working");
+  }
+
+  toolDone(tool: string) {
+    this.warpEvent("tool_complete", { tool_name: tool });
+  }
+
+  /** The agent waits for you: a permission prompt or a question. */
+  waiting(kind: "permission" | "question", summary: string, tool?: string, input?: unknown) {
+    if (kind === "question") this.warpEvent("question_asked", { tool_name: tool ?? "question", summary: cut(summary, 200) });
+    else this.warpEvent("permission_request", { summary: cut(summary, 200), tool_name: tool ?? "tool", tool_input: input ?? {} });
+    this.status("blocked");
+    this.desktop(`${this.agent?.name ?? "The agent"} ${kind === "question" ? "has a question" : "needs your approval"}: ${cut(summary, 120)}`);
+  }
+
+  answered(allowed: boolean) {
+    if (allowed) this.warpEvent("permission_replied");
+    this.status("working");
+  }
+
+  turnEnded(o: { reply: string; ms: number; error?: boolean; longMs: number }) {
+    this.warpEvent("stop", { query: cut(this.lastQuery, 200), response: cut(o.reply, 200), transcript_path: "" });
+    this.status(o.error ? "error" : "done");
+    if (o.ms >= o.longMs) this.desktop(`${this.agent?.name ?? "The agent"} finished: ${cut(o.reply.replace(/\s+/g, " ").trim() || "done", 120)}`);
+  }
+
+  close() {
+    this.status("clear");
+  }
+
+  private status(state: Parameters<TerminalSink["status"]>[0]["state"]) {
+    if (!this.o.enabled()) return;
+    try {
+      this.sink.status({ state });
+    } catch {
+      /* a terminal that refuses it must never break codemax */
+    }
+  }
+
+  private warpEvent(event: string, extra: Record<string, unknown> = {}) {
+    const slug = this.agent && WARP_AGENTS[this.agent.id];
+    if (!this.warp || !slug || !this.o.enabled()) return;
+    const body = { v: 1, agent: slug, event, session_id: this.agent!.session, cwd: this.o.cwd, project: basename(this.o.cwd), ...extra };
+    try {
+      this.sink.notify(JSON.stringify(body), "warp://cli-agent");
+    } catch {
+      /* ignore */
+    }
+  }
+
+  /** A plain desktop notification, only when you are not looking (Warp sends its own). */
+  private desktop(message: string) {
+    if (this.focused === true || !this.o.notify()) return;
+    if (this.warp && this.agent && WARP_AGENTS[this.agent.id] && this.o.enabled()) return;
+    try {
+      this.sink.notify(message, "codemax");
+    } catch {
+      /* ignore */
+    }
+  }
+}

package/src/core/time.ts

@@ -0,0 +1,9 @@
+/** Every time codemax shows is 12-hour, whatever the system locale: "7:25 PM", "Oct 18, 7:25 PM". */
+export function fmtTime12(ts: number): string {
+  return new Date(ts).toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit", hour12: true });
+}
+
+export function fmtDateTime12(ts: number): string {
+  const d = new Date(ts);
+  return `${d.toLocaleDateString("en-US", { month: "short", day: "numeric" })}, ${fmtTime12(ts)}`;
+}

package/src/core/usage.ts

@@ -1,5 +1,6 @@
 import type { AgentId } from "../adapters/types.ts";
 import { estimateCost, fmtTokens, fmtUsd, priceFor, priceProvenance } from "./pricing.ts";
+import { displayModelName } from "../chat/models.ts";
 
 /** One usage sample: a model call, a turn, or a delta reported by the agent. */
 export interface UsageRecord {
@@ -89,7 +90,7 @@ export function renderUsageTable(records: UsageRecord[], opts: { title: string;
   }
   const head = ["agent", "calls", "input", "output", "cache read", "cache write", "est. cost"];
   const data = rows.map((t) => [
-    t.agent + (t.models.size ? ` (${[...t.models].map(shortModel).join(", ")})` : ""),
+    t.agent + (t.models.size ? ` (${[...new Set([...t.models].map(shortModel))].join(", ")})` : ""),
     String(t.calls),
     fmtTokens(t.input),
     fmtTokens(t.output),
@@ -111,6 +112,7 @@ export function renderUsageTable(records: UsageRecord[], opts: { title: string;
   return lines;
 }
 
+/** Display name for a recorded model id ("claude-opus-5-5" → "Opus 5.5"), as everywhere else. */
 export function shortModel(m: string): string {
-  return m.replace(/^claude-/, "").replace(/^(anthropic|openai|xai|google|opencode)\//, "");
+  return displayModelName(m);
 }

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, 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":
@@ -204,7 +251,7 @@ export class AcpEngine implements Engine {
         // `used` is how full the context window is, not tokens spent: it feeds the context meter.
         // Token counts come from the prompt response (or session files) at turn end.
         if (typeof u.used === "number") this.turnContext = u.used;
-        this.emit({ type: "usage", contextUsed: u.used, contextSize: u.size, costUsd: delta, model: this.currentModelName() });
+        this.emit({ type: "usage", contextUsed: u.used, contextSize: u.size, costUsd: delta, model: this.currentModelName(), planLimits: planLimitsOf(u) });
         break;
       }
       default:
@@ -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 {
@@ -339,6 +452,15 @@ function extraOptions(config: unknown): EngineOption[] {
     }));
 }
 
+/** Claude's plan limits ride on usage updates as `_meta["_claude/rateLimit"]` (SDKRateLimitInfo). */
+function planLimitsOf(u: any): PlanLimit[] | undefined {
+  const rl = u?._meta?.["_claude/rateLimit"];
+  if (!rl || typeof rl !== "object") return undefined;
+  const util = typeof rl.utilization === "number" ? (rl.utilization <= 1 ? rl.utilization * 100 : rl.utilization) : undefined;
+  const reset = typeof rl.resetsAt === "number" ? (rl.resetsAt < 1e12 ? rl.resetsAt * 1000 : rl.resetsAt) : undefined;
+  return [{ window: String(rl.rateLimitType ?? "plan"), usedPercent: util, resetsAt: reset, status: rl.status }];
+}
+
 function mapStatus(s: string | undefined): "pending" | "in_progress" | "completed" | "failed" {
   if (s === "in_progress" || s === "completed" || s === "failed") return s;
   return "pending";

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 };
+}