@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/acp/__tests__/session-manager-resume.test.ts

@@ -129,6 +129,14 @@ class FakeAcpAgentProcess {
 
   async cancel(): Promise<void> {}
 
+  markStderr(): number {
+    return 0;
+  }
+
+  stderrSince(): string {
+    return "";
+  }
+
   kill(): void {
     this.killed = true;
   }

package/src/acp/__tests__/session-manager-usage.test.ts

@@ -35,6 +35,12 @@ mock.module("../agent-process.js", () => ({
       return new Promise(() => {});
     }
     async cancel(): Promise<void> {}
+    markStderr(): number {
+      return 0;
+    }
+    stderrSince(): string {
+      return "";
+    }
     kill(): void {}
   },
 }));

package/src/acp/__tests__/session-manager.test.ts

@@ -37,6 +37,12 @@ mock.module("../agent-process.js", () => ({
     async cancel(sessionId: string): Promise<void> {
       cancelCalls.push(sessionId);
     }
+    markStderr(): number {
+      return 0;
+    }
+    stderrSince(): string {
+      return "";
+    }
     kill(): void {}
   },
 }));

package/src/acp/agent-process.test.ts

@@ -0,0 +1,116 @@
+import { describe, expect, test } from "bun:test";
+
+import { AcpAgentProcess } from "./agent-process.js";
+import type { AcpAgentConfig } from "./types.js";
+
+const config: AcpAgentConfig = { command: "noop", args: [] };
+
+// The client factory is never invoked in these tests (no spawn), so a stub is
+// sufficient.
+const clientFactory = (() => ({})) as never;
+
+function newProcess(): AcpAgentProcess {
+  return new AcpAgentProcess("test-agent", config, clientFactory);
+}
+
+// retainStderr is the private handler path the stderr "data" listener calls
+// after logging; feed it directly to keep the test deterministic (no real
+// child process or stream timing).
+function feed(proc: AcpAgentProcess, line: string): void {
+  (proc as unknown as { retainStderr(text: string): void }).retainStderr(line);
+}
+
+describe("AcpAgentProcess.stderrSince(0)", () => {
+  test("returns empty string before any stderr is captured", () => {
+    expect(newProcess().stderrSince(0)).toBe("");
+  });
+
+  test("retains captured lines joined by newlines, in order", () => {
+    const proc = newProcess();
+    feed(proc, "line 1");
+    feed(proc, "line 2");
+    feed(proc, "line 3");
+
+    expect(proc.stderrSince(0)).toBe("line 1\nline 2\nline 3");
+  });
+
+  test("evicts oldest lines once the byte cap is exceeded", () => {
+    const proc = newProcess();
+    // Each line is ~1 KB; a handful exceeds the ~4 KB cap and forces eviction
+    // of the earliest lines while preserving newest-line ordering.
+    const kb = "x".repeat(1024);
+    for (let i = 0; i < 8; i++) {
+      feed(proc, `${i}:${kb}`);
+    }
+
+    const retained = proc.stderrSince(0).split("\n");
+    // Oldest ("0:") evicted, newest ("7:") retained, still in insertion order.
+    expect(retained.at(0)).not.toContain("0:");
+    expect(retained.at(-1)).toContain("7:");
+    expect(Buffer.byteLength(proc.stderrSince(0))).toBeLessThanOrEqual(
+      4096 + kb.length,
+    );
+
+    const indices = retained.map((l) => Number(l.split(":")[0]));
+    const sorted = [...indices].sort((a, b) => a - b);
+    expect(indices).toEqual(sorted);
+  });
+
+  test("truncates an oversized line to the cap, keeping its tail (the diagnostic)", () => {
+    const proc = newProcess();
+    // The real adapter error sits at the END of the chunk; deriveFailureError
+    // reads from the tail, so truncation must drop the head, not the tail.
+    const huge = "H".repeat(6000) + "TAIL_DIAGNOSTIC";
+    feed(proc, huge);
+
+    const retained = proc.stderrSince(0);
+    expect(retained.length).toBe(4096);
+    expect(retained.endsWith("TAIL_DIAGNOSTIC")).toBe(true);
+  });
+
+  test("stderrSince(0) is pure: repeated reads do not clear the buffer", () => {
+    const proc = newProcess();
+    feed(proc, "only line");
+
+    expect(proc.stderrSince(0)).toBe("only line");
+    expect(proc.stderrSince(0)).toBe("only line");
+  });
+});
+
+describe("AcpAgentProcess.markStderr / stderrSince", () => {
+  test("stderrSince returns only lines produced after the mark", () => {
+    const proc = newProcess();
+    feed(proc, "before 1");
+    feed(proc, "before 2");
+
+    const mark = proc.markStderr();
+    feed(proc, "after 1");
+    feed(proc, "after 2");
+
+    expect(proc.stderrSince(mark)).toBe("after 1\nafter 2");
+  });
+
+  test("a mark taken after all lines excludes everything retained so far", () => {
+    const proc = newProcess();
+    feed(proc, "line 1");
+    feed(proc, "line 2");
+
+    const mark = proc.markStderr();
+    expect(proc.stderrSince(mark)).toBe("");
+  });
+
+  test("mark is monotonic across eviction: seq keeps counting evicted lines", () => {
+    const proc = newProcess();
+    // Overflow the byte cap so early lines are evicted, then mark and add one
+    // fresh line: only the post-mark line comes back, unaffected by eviction.
+    const kb = "z".repeat(1024);
+    for (let i = 0; i < 8; i++) {
+      feed(proc, `${i}:${kb}`);
+    }
+
+    const mark = proc.markStderr();
+    feed(proc, "fresh failure");
+
+    expect(proc.stderrSince(mark)).toBe("fresh failure");
+  });
+});

package/src/acp/agent-process.ts

@@ -30,6 +30,13 @@ const log = getLogger("acp");
  */
 const AUTH_REQUIRED_CODE = -32000;
 
+/**
+ * Rough byte cap for retained stderr. Oldest lines are evicted once the sum of
+ * retained line lengths exceeds this, so the stderr ring (read via stderrSince)
+ * stays bounded.
+ */
+const STDERR_RETENTION_BYTES = 4096;
+
 /**
  * Detects the ACP auth-required error. Checks the `code` property rather than
  * `instanceof acp.RequestError` so plain JSON-RPC error objects are also
@@ -69,6 +76,20 @@ export class AcpAgentProcess {
    */
   private spawnedEnv: NodeJS.ProcessEnv | null = null;
 
+  /**
+   * Ring of the most recent stderr lines, bounded to ~STDERR_RETENTION_BYTES.
+   * Read once on the failure path to surface the real adapter error. Each
+   * entry carries a monotonic `seq` so a caller can scope reads to lines
+   * produced after a checkpoint (see markStderr/stderrSince).
+   */
+  private stderrRing: { seq: number; text: string }[] = [];
+  private stderrRingBytes = 0;
+  /**
+   * Cumulative count of stderr lines ever retained, including ones later
+   * evicted. Assigned as each line's `seq`; markStderr() snapshots it.
+   */
+  private stderrSeq = 0;
+
   constructor(
     public readonly agentId: string,
     private readonly config: AcpAgentConfig,
@@ -108,6 +129,7 @@ export class AcpAgentProcess {
       const text = chunk.toString().trim();
       if (text) {
         log.error({ agentId: this.agentId, stderr: text }, "ACP agent stderr");
+        this.retainStderr(text);
       }
     });
 
@@ -124,6 +146,55 @@ export class AcpAgentProcess {
     });
   }
 
+  /**
+   * Appends a stderr line to the ring, evicting oldest lines once the retained
+   * total exceeds STDERR_RETENTION_BYTES. Always keeps at least the newest line
+   * so a single oversized line is not fully dropped.
+   */
+  private retainStderr(text: string): void {
+    // Cap a single oversized line: the "keep newest" rule below never evicts it,
+    // so an untruncated multi-MB chunk would blow the ring budget and make the
+    // failure-path stderr scan (deriveFailureError) super-linear on huge input.
+    // Keep the TAIL: the adapter's error JSON / last line sits at the end, and
+    // deriveFailureError reads from the end, so dropping the head is lossless.
+    const line =
+      text.length > STDERR_RETENTION_BYTES
+        ? text.slice(-STDERR_RETENTION_BYTES)
+        : text;
+    this.stderrSeq += 1;
+    this.stderrRing.push({ seq: this.stderrSeq, text: line });
+    this.stderrRingBytes += Buffer.byteLength(line);
+    while (
+      this.stderrRingBytes > STDERR_RETENTION_BYTES &&
+      this.stderrRing.length > 1
+    ) {
+      const evicted = this.stderrRing.shift()!;
+      this.stderrRingBytes -= Buffer.byteLength(evicted.text);
+    }
+  }
+
+  /**
+   * Snapshots the current cumulative stderr line count. Pair with
+   * stderrSince() to read only stderr produced after this checkpoint, so a
+   * prompt's failure derives from its own stderr rather than lines retained
+   * from startup, resume, or an earlier (possibly cancelled) prompt.
+   */
+  markStderr(): number {
+    return this.stderrSeq;
+  }
+
+  /**
+   * Returns retained stderr lines produced after `mark` (a markStderr()
+   * checkpoint), joined by newlines. Best-effort: lines pushed after the mark
+   * but since evicted are simply absent; returns "" when nothing newer remains.
+   */
+  stderrSince(mark: number): string {
+    return this.stderrRing
+      .filter((e) => e.seq > mark)
+      .map((e) => e.text)
+      .join("\n");
+  }
+
   /**
    * Initializes the ACP connection by negotiating protocol version and capabilities.
    */

package/src/acp/auto-install.ts

@@ -16,11 +16,12 @@
  *    never the untrusted task project dir. A clean cwd has no project-local
  *    `node_modules/.bin`, `bunfig.toml`, or `.npmrc`, so none of the
  *    cwd-based package-resolution hijacks apply.
- *  - The installer env is a SANITIZED copy of `process.env` with
- *    `CLAUDE_CODE_OAUTH_TOKEN` and `GEMINI_API_KEY` stripped, so the secret
- *    is never in scope during package resolution, and `BUN_CONFIG_REGISTRY`
- *    forced to the public npm registry so a redirected registry cannot serve
- *    a malicious package.
+ *  - The installer env is a SANITIZED copy of `process.env` with known
+ *    ambient secrets (`CLAUDE_CODE_OAUTH_TOKEN`, plus the `GEMINI_API_KEY`
+ *    used by the Gemini LLM provider) stripped, so no secret is ever in scope
+ *    during package resolution, and `BUN_CONFIG_REGISTRY` forced to the
+ *    public npm registry so a redirected registry cannot serve a malicious
+ *    package.
  *  - The token is injected ONLY later, at spawn time, on the real installed
  *    binary (see `prepare-agent-env.ts`). `prepareAgentEnv` is never called
  *    here.
@@ -99,9 +100,12 @@ function execFileWithTimeout(
 }
 
 /**
- * A copy of `process.env` safe to hand to the package installer: the ACP
- * secrets are stripped so they can never leak into a resolved package's
- * lifecycle/runtime, and the registry is pinned to the trusted public one.
+ * A copy of `process.env` safe to hand to the package installer: known
+ * ambient secrets are stripped so they can never leak into a resolved
+ * package's lifecycle/runtime, and the registry is pinned to the trusted
+ * public one. `CLAUDE_CODE_OAUTH_TOKEN` is the ACP adapter token;
+ * `GEMINI_API_KEY` belongs to the Gemini LLM provider but may be present in
+ * the daemon env, so it is stripped here as defense-in-depth.
  */
 function sanitizedInstallEnv(): NodeJS.ProcessEnv {
   const env: NodeJS.ProcessEnv = { ...process.env };

package/src/acp/failure-error.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, test } from "bun:test";
+
+import { deriveFailureError } from "./failure-error.js";
+
+const CODEX_MESSAGE =
+  "The 'gpt-5.3-codex' model is not supported when using Codex with a ChatGPT account.";
+
+const ESC = String.fromCharCode(27); // ANSI escape (0x1B)
+
+// A realistic codex-acp stderr line: a JSON error blob wrapped in a coloured
+// log prefix and a trailing reset code.
+const ansiCodexStderr =
+  `${ESC}[2m2026-06-30T12:00:00Z${ESC}[0m ${ESC}[31mERROR${ESC}[0m codex_core: ` +
+  `request failed {"type":"error","status":400,"error":` +
+  `{"type":"invalid_request_error","message":"${CODEX_MESSAGE}"}}${ESC}[0m`;
+
+describe("deriveFailureError", () => {
+  test("extracts the inner error.message from codex-acp JSON stderr", () => {
+    const stderr =
+      `{"type":"error","status":400,"error":` +
+      `{"type":"invalid_request_error","message":"${CODEX_MESSAGE}"}}`;
+    expect(deriveFailureError("Internal error", stderr)).toBe(CODEX_MESSAGE);
+  });
+
+  test("strips ANSI codes and extracts error.message from a real log line", () => {
+    const result = deriveFailureError("Internal error", ansiCodexStderr);
+    expect(result).toBe(CODEX_MESSAGE);
+    expect(result).not.toContain(ESC);
+  });
+
+  test("parses JSON embedded in surrounding log text", () => {
+    const stderr = `2026-06-30 fatal: the adapter said {"error":{"message":"boom"}} and gave up`;
+    expect(deriveFailureError("Internal error", stderr)).toBe("boom");
+  });
+
+  test("returns the LAST JSON error.message when several are present", () => {
+    const stderr =
+      `{"error":{"message":"first failure"}}\n` +
+      `{"error":{"message":"final failure"}}`;
+    expect(deriveFailureError("Internal error", stderr)).toBe("final failure");
+  });
+
+  test("empty stderr yields the ack message", () => {
+    expect(deriveFailureError("Internal error", "")).toBe("Internal error");
+  });
+
+  test("generic ack with informative non-JSON stderr yields the last stderr line, ANSI-stripped", () => {
+    const stderr = `starting up...\n${ESC}[31mfatal: could not connect to backend${ESC}[0m`;
+    expect(deriveFailureError("Internal error", stderr)).toBe(
+      "fatal: could not connect to backend",
+    );
+  });
+
+  test("already-specific ack is preserved when stderr is empty", () => {
+    expect(deriveFailureError(CODEX_MESSAGE, "")).toBe(CODEX_MESSAGE);
+  });
+
+  test("already-specific ack is preserved (not double-appended) when stderr duplicates it", () => {
+    // codex often echoes the same message to stderr; we must not repeat it.
+    expect(deriveFailureError(CODEX_MESSAGE, CODEX_MESSAGE)).toBe(
+      CODEX_MESSAGE,
+    );
+  });
+
+  test("structured error duplicating the generic ack yields the clean ack, not the raw JSON", () => {
+    // The adapter acked "Internal error" and also emitted it as a JSON blob;
+    // return the clean ack rather than echoing the raw JSON line.
+    const stderr = `{"error":{"message":"Internal error"}}`;
+    expect(deriveFailureError("Internal error", stderr)).toBe("Internal error");
+  });
+
+  test("falls back to the ack message when stderr has no JSON and no lines", () => {
+    expect(deriveFailureError("Internal error", "   \n  \n")).toBe(
+      "Internal error",
+    );
+  });
+
+  test("ignores malformed JSON braces and uses the last stderr line", () => {
+    const stderr = "noise {not: valid json} more noise\nreal failure detail";
+    expect(deriveFailureError("Internal error", stderr)).toBe(
+      "real failure detail",
+    );
+  });
+
+  test("a stray unmatched brace before the JSON does not block extraction", () => {
+    const stderr =
+      `some log { unmatched brace here\n` +
+      `... {"type":"error","error":{"message":"The real error"}} ...`;
+    expect(deriveFailureError("Internal error", stderr)).toBe("The real error");
+  });
+
+  test("braces inside a JSON string literal don't throw off the scan", () => {
+    const stderr = `{"error":{"message":"unexpected } brace {in} the text"}}`;
+    expect(deriveFailureError("Internal error", stderr)).toBe(
+      "unexpected } brace {in} the text",
+    );
+  });
+
+  test("prefers the outer adapter error over a nested error.message", () => {
+    // JSON-RPC style: the real failure is the top-level error.message; a nested
+    // error.data.error.message must not shadow it.
+    const stderr =
+      `{"error":{"message":"outer adapter failure",` +
+      `"data":{"error":{"message":"inner debug detail"}}}}`;
+    expect(deriveFailureError("Internal error", stderr)).toBe(
+      "outer adapter failure",
+    );
+  });
+});

package/src/acp/failure-error.ts

@@ -0,0 +1,111 @@
+/**
+ * Derives a human-meaningful failure message for a failed ACP prompt.
+ *
+ * ACP adapters (e.g. codex-acp) frequently ack a failure with a generic
+ * "Internal error" while printing the real cause to stderr as a JSON blob like
+ * `{"error":{"message":"..."}}`. This picks the most specific signal available:
+ * a structured stderr error, else the last stderr line, else the ack message.
+ *
+ * Pure and dependency-free.
+ */
+
+// CSI escape sequences (colour codes, cursor moves) that adapters interleave
+// with their log lines: ESC `[`, parameter/intermediate bytes, then final byte.
+const ANSI_ESCAPE = /\u001B\[[0-?]*[ -/]*[@-~]/g;
+
+export function deriveFailureError(ackMessage: string, stderr: string): string {
+  const clean = stderr.replace(ANSI_ESCAPE, "").trim();
+
+  // Most precise: a structured adapter error — prefer it over the ack.
+  const jsonMessage = lastJsonErrorMessage(clean);
+  if (jsonMessage) return jsonMessage;
+
+  // An already-specific ack is preserved when stderr has no better detail.
+  if (ackMessage.length > 0 && ackMessage !== "Internal error")
+    return ackMessage;
+
+  // Generic/empty ack: fall back to the last meaningful stderr line.
+  return lastNonEmptyLine(clean) ?? ackMessage;
+}
+
+/**
+ * Returns the `error.message` of the LAST JSON object embedded in `text` whose
+ * shape is `{"error":{"message":"..."}}`, or null. Objects may be surrounded by
+ * arbitrary log text.
+ *
+ * A candidate object is attempted at EACH `{`, so a stray unmatched `{` in the
+ * surrounding log text never balances and is skipped rather than swallowing a
+ * later valid object.
+ */
+function lastJsonErrorMessage(text: string): string | null {
+  let found: string | null = null;
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] !== "{") {
+      continue;
+    }
+    const candidate = balancedObjectAt(text, i);
+    if (candidate === null) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(candidate) as { error?: { message?: unknown } };
+      // A valid top-level object: skip past its end so we don't restart
+      // candidates at its nested braces. Otherwise a nested error.message
+      // (e.g. a JSON-RPC error.data payload) would shadow the outer adapter
+      // error. Only reached on a successful parse, so a stray unmatched brace
+      // that balances-but-fails-to-parse still lets inner objects be scanned.
+      i += candidate.length - 1;
+      const message = parsed.error?.message;
+      if (typeof message === "string" && message.length > 0) {
+        found = message;
+      }
+    } catch {
+      // Not valid JSON at this position; keep scanning later braces.
+    }
+  }
+  return found;
+}
+
+/**
+ * Returns the balanced `{...}` substring starting at `start`, tracking string
+ * literals so braces inside JSON strings don't throw off the depth count, or
+ * null if the braces never balance before the text ends.
+ */
+function balancedObjectAt(text: string, start: number): string | null {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === "{") {
+      depth++;
+    } else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        return text.slice(start, i + 1);
+      }
+    }
+  }
+  return null;
+}
+
+function lastNonEmptyLine(text: string): string | null {
+  const lines = text.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const trimmed = lines[i].trim();
+    if (trimmed.length > 0) return trimmed;
+  }
+  return null;
+}

package/src/acp/prepare-agent-env.ts

@@ -145,11 +145,6 @@ async function injectOptionalCredential(
  * `binary_not_found` preflight in `resolveAcpAgent` and strictly better
  * than a `warn` + zombie subprocess 10 seconds later.
  *
- * For `gemini` the env var is `GEMINI_API_KEY`, provisioned the same two
- * ways (config.json override wins, vault field `gemini_api_key` second),
- * but it is OPTIONAL: the Gemini CLI supports its own OAuth login, so a
- * vault miss proceeds without the key instead of failing the spawn.
- *
  * For `codex-acp` the env vars are `OPENAI_API_KEY` (vault field
  * `acp/openai_api_key`) and `CODEX_API_KEY` (vault field
  * `acp/codex_api_key`), provisioned the same two ways (config.json
@@ -182,13 +177,6 @@ export async function prepareAgentEnv(
           "(or set it under acp.agents.<id>.env in config.json).",
       );
     }
-  } else if (adapterCommand === "gemini") {
-    await injectOptionalCredential(
-      env,
-      "gemini_api_key",
-      "GEMINI_API_KEY",
-      "Gemini API key for ACP agent authentication",
-    );
   } else if (adapterCommand === "codex-acp") {
     // The two reads target independent vault fields and write disjoint env
     // keys, so running them concurrently is safe.

package/src/acp/resolve-agent.test.ts

@@ -65,17 +65,6 @@ describe("resolveAcpAgent", () => {
     expect(result.agent.command).toBe("claude-agent-acp");
   });
 
-  test("falls back to the gemini default profile when no user entry", () => {
-    config.setConfig({ agents: {} });
-
-    const result = resolveAcpAgent("gemini");
-
-    expect(result.ok).toBe(true);
-    if (!result.ok) return;
-    expect(result.agent.command).toBe("gemini");
-    expect(result.agent.args).toEqual(["--acp"]);
-  });
-
   test.each([
     ["claude code", "claude-agent-acp"],
     ["Claude Code", "claude-agent-acp"],
@@ -83,9 +72,6 @@ describe("resolveAcpAgent", () => {
     ["claude_code", "claude-agent-acp"],
     ["codex cli", "codex-acp"],
     ["OpenAI Codex", "codex-acp"],
-    ["gemini cli", "gemini"],
-    ["Gemini CLI", "gemini"],
-    ["google gemini", "gemini"],
   ])("alias %p resolves to the %p profile", (alias, command) => {
     config.setConfig({ agents: {} });
 
@@ -152,12 +138,7 @@ describe("resolveAcpAgent", () => {
     expect(result.reason).toBe("unknown_agent");
     if (result.reason !== "unknown_agent") return;
     // Defaults plus user-only ids, deduped, in stable order (defaults first).
-    expect(result.available).toEqual([
-      "claude",
-      "codex",
-      "gemini",
-      "user-only",
-    ]);
+    expect(result.available).toEqual(["claude", "codex", "user-only"]);
   });
 
   test("unknown_agent available list contains both defaults when user config is empty", () => {
@@ -171,7 +152,6 @@ describe("resolveAcpAgent", () => {
     if (result.reason !== "unknown_agent") return;
     expect(result.available).toContain("claude");
     expect(result.available).toContain("codex");
-    expect(result.available).toContain("gemini");
   });
 
   test("returns binary_not_found with the registered install hint", () => {
@@ -333,7 +313,7 @@ describe("listAcpAgents", () => {
     const result = listAcpAgents();
 
     const ids = result.agents.map((a) => a.id);
-    expect(ids).toEqual(["claude", "codex", "gemini"]);
+    expect(ids).toEqual(["claude", "codex"]);
     for (const entry of result.agents) {
       expect(entry.source).toBe("default");
       expect(entry.available).toBe(true);
@@ -355,7 +335,6 @@ describe("listAcpAgents", () => {
     which.setWhich({
       "my-claude": "/usr/bin/my-claude",
       "codex-acp": "/usr/bin/codex-acp",
-      gemini: "/usr/bin/gemini",
     });
 
     const result = listAcpAgents();
@@ -385,7 +364,6 @@ describe("listAcpAgents", () => {
     expect(result.agents.map((a) => a.command)).toEqual([
       "claude-agent-acp",
       "codex-acp",
-      "gemini",
     ]);
   });
 
@@ -401,30 +379,15 @@ describe("listAcpAgents", () => {
     expect(codex?.setupHint).toBe("bun add -g @zed-industries/codex-acp");
   });
 
-  test("unavailable gemini surfaces the @google/gemini-cli install hint", () => {
-    config.setConfig({ agents: {} });
-    which.setWhich({
-      "claude-agent-acp": "/usr/bin/claude-agent-acp",
-      "codex-acp": "/usr/bin/codex-acp",
-    });
-
-    const result = listAcpAgents();
-
-    const gemini = result.agents.find((a) => a.id === "gemini");
-    expect(gemini?.available).toBe(false);
-    expect(gemini?.unavailableReason).toBe("'gemini' is not on PATH");
-    expect(gemini?.setupHint).toBe("bun add -g @google/gemini-cli");
-  });
-
   test("aliases are resolution sugar, not catalog entries", () => {
     config.setConfig({ agents: {} });
 
-    // "gemini cli" resolves via the alias...
-    expect(resolveAcpAgent("gemini cli").ok).toBe(true);
+    // "codex cli" resolves via the alias...
+    expect(resolveAcpAgent("codex cli").ok).toBe(true);
 
     // ...but the catalog lists only canonical ids.
     const ids = listAcpAgents().agents.map((a) => a.id);
-    expect(ids).toEqual(["claude", "codex", "gemini"]);
+    expect(ids).toEqual(["claude", "codex"]);
   });
 
   test("user-only agent appended after defaults in stable order", () => {
@@ -440,7 +403,6 @@ describe("listAcpAgents", () => {
     which.setWhich({
       "claude-agent-acp": "/x",
       "codex-acp": "/x",
-      gemini: "/x",
       "my-binary": "/x",
     });
 
@@ -449,10 +411,9 @@ describe("listAcpAgents", () => {
     expect(result.agents.map((a) => a.id)).toEqual([
       "claude",
       "codex",
-      "gemini",
       "my-agent",
     ]);
-    const userOnly = result.agents[3];
+    const userOnly = result.agents[2];
     expect(userOnly.source).toBe("config");
     expect(userOnly.description).toBe("user-only");
   });