@agentex/agent 0.0.37 → 0.0.39

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## 0.0.39 — Antigravity provider (Google's successor to Gemini CLI)
+
+Gemini CLI stopped serving free, Google AI Pro, and Google AI Ultra sign-ins on 2026-06-18 ("This client is no longer supported for Gemini Code Assist for individuals"). Google moved those accounts to the Antigravity CLI, `agy`. This release adds it as a first-class provider. Wire behavior follows the documented headless protocol and was checked against `agy` 1.2.14.
+
+### Added
+
+- **`antigravity` provider** (`getProvider("antigravity")`). Drives `agy --input-format stream-json --output-format stream-json`.
+  - **Sessions.** One `agy` process per session. Each `send()` writes one NDJSON user message and resolves on that turn's `result`. Sessions resume with `--conversation`. `sessionParams` are `{ sessionId, cwd }`, because Antigravity scopes conversations to a directory. Params saved for another directory start a new conversation instead of resuming the wrong one.
+  - **One-shot `execute()`.** Writes the prompt over stdin and closes it, so prompts are never argv-limited or visible in `ps`. It waits for the process to exit.
+  - **Interrupts.** The CLI has no control protocol, so `interrupt()`, timeouts, and abort signals SIGINT the process group (Ctrl+C). If `agy` exits instead of reporting `INTERRUPTED`, the next `send()` resumes the conversation in a new process. A message sent to a process that exits without acknowledging it is re-run once on a fresh one.
+  - **Events.** `system/init`, `assistant` (with `assistant_delta` under `includePartialMessages`), `thinking`, correlated `tool_call`/`tool_result` (`toolCallId` = `<conversationId>:<stepIndex>`, subagent steps included), `result`, `turn_start`/`turn_end`, `auth_required`, and `unknown` for future step types.
+  - **Usage.** agy reports cumulative usage per process. agentex reports each turn's share, with `cachedInputTokens` from `cache_read_tokens`.
+  - **Config mapping.** `model` → `--model`. `effort` → `--effort` (`low|medium|high|max`). `modeId`/`mode` → `--mode` (`default`, `accept-edits`, `plan`). `planMode` → `--mode plan`, which wins over `skipPermissions` → `--dangerously-skip-permissions`. `sandbox` → `--sandbox`. `instructionsFile` is prepended to a new conversation's first message. `skillDirs` are linked into `~/.gemini/antigravity-cli/skills`.
+  - **Permissions.** Headless agy cannot ask. Tools needing approval are soft-denied by policy and surface on `ExecutionResult.permissionDenials`. `capabilities.permissionRequests` is `false`.
+  - **Errors.** `AGY_ERROR` stderr reports map to `rate_limited`, `invalid_model`, `waiting_for_input` (status `blocked`), or `agent_error`.
+  - **Discovery.** `listModels()` reads `agy models`. `listModes()` is static and spawns nothing. `probeCapabilities()` checks `--help` for the stream-json flags (profile `agy-stream-json-v1`) and reports "not signed in" as `missing` rather than `upgrade_required`.
+- **Fast sign-in failure.** An unsigned headless `agy` prints a login URL and blocks for 60 seconds waiting for a pasted code. agentex stops it as soon as the prompt appears, emits `auth_required` with `loginCommand: "agy"`, and fails with `errorCode: "auth_required"`. Against the real CLI this takes about 0.5s instead of 60.
+- **Auth.** `resolveAuthForProvider("antigravity")` reports the sign-in from `agy models` (there is no status subcommand). `GEMINI_API_KEY` counts only when `~/.gemini/antigravity-cli/settings.json` sets `"modelProvider": "gemini"`, because the CLI ignores the variable otherwise. `detectAuth` and `loginCommandFor` (`"agy"`) follow the same rules.
+- **`SkillRuntime` gains `"antigravity"`.** Workspace skills use the standard `.agents/skills` channel. Global skills go to `~/.gemini/antigravity-cli/skills`. Instructions use `AGENTS.md`, and the global native file is the `~/.gemini/GEMINI.md` it shares with Gemini CLI.
+- `findBinary("agy")` also checks `~/.local/bin/agy`, where the official installer puts it and which GUI apps usually lack on `PATH`. It also checks `/usr/local/bin`, `/opt/homebrew/bin`, and on Windows `%LOCALAPPDATA%\agy\bin`.
+
+### Changed
+
+- `installSkills`/`removeSkills`/`listInstalledSkills` with `includeNativeDirs` skip a runtime folder that is already a standard channel, so nothing is installed or reported twice.
+- Global `resolveInstructionTargets`/`installInstructions` merge runtimes that share a file. Gemini CLI and Antigravity both read `~/.gemini/GEMINI.md`, so it becomes one target serving both.
+- The `gemini` provider documents the personal-account retirement and points to `antigravity`. It still works with paid API keys and Gemini Code Assist Standard/Enterprise.
+- The barrel-import module budget in `tests/packaging/lazy-graph.test.ts` is re-pinned from 51 to 53. The new provider adds the same light `index` + `codec` pair every provider ships, and no heavy modules.
+
+## 0.0.38 — AGENTS.md is the workspace instruction file for every runtime
+
+Claude Code reads `AGENTS.md` since 2.1.277, loaded exactly where `CLAUDE.md` would be, but only in a folder with no `CLAUDE.md`. A `CLAUDE.md`, a `CLAUDE.local.md`, or one in a parent folder hides `AGENTS.md` completely (verified against 2.1.281). Not yet on Bedrock, Vertex or Foundry.
+
+### Changed (breaking)
+
+- **`installInstructions` writes `AGENTS.md` only by default.** Claude's workspace file is now `AGENTS.md`, like every other runtime. `CLAUDE.md` is Claude's native file, written only with `includeNativeFiles: true`, and then as a one-line `@AGENTS.md` pointer in the managed region instead of a second copy of the brief. A copy would have made anything the user writes in `AGENTS.md` invisible to Claude. Opt in for Claude Code before 2.1.277 or on a third-party API provider. `includeNativeFiles` still writes Gemini's `GEMINI.md` as a copy.
+- **An existing workspace `CLAUDE.md` is reconciled** whenever `claude` is among the runtimes and the opt-in is off, because it would hide `AGENTS.md`: one holding nothing but this installer's managed region (for example the full brief 0.0.37 and earlier wrote) is deleted, and one the user wrote keeps their content and gains `@AGENTS.md` in the managed region. `managed: false` leaves it alone.
+- **`removeInstructions` always checks native files** (`CLAUDE.md`, `GEMINI.md`), so an opt-in install is fully removable. It still only strips the managed region.
+
+### Added
+
+- `InstructionStatus` gains `"removed"`, and `InstructionInstallResult` a `removed` count.
+- `InstructionTarget.importsFile` marks a pointer file (`"AGENTS.md"` on an opt-in `CLAUDE.md`).
+
+### Migration
+
+A host that relied on the default `CLAUDE.md` gets `AGENTS.md` only. Nothing else is needed on Claude Code 2.1.277+ with first-party auth: the next install deletes the old managed-only `CLAUDE.md`. Elsewhere, pass `includeNativeFiles: true`.
+
 ## 0.0.37 — Turn liveness and background-task identity (Claude)
 
 Claude Code starts turns by itself. When a background task finishes, the CLI

package/README.md

@@ -1,6 +1,6 @@
 # @agentex/agent
 
-Programmatic execution of AI coding agents. Spawn and manage Claude Code, Codex, Gemini, Cursor, OpenCode, Pi, OpenClaw, or any CLI-based agent as a child process with streaming output, multi-turn sessions, auth detection, isolated workspaces, skill installation, and a unified interface.
+Programmatic execution of AI coding agents. Spawn and manage Claude Code, Codex, Antigravity, Gemini, Cursor, OpenCode, Pi, OpenClaw, or any CLI-based agent as a child process with streaming output, multi-turn sessions, auth detection, isolated workspaces, skill installation, and a unified interface.
 
 ## Install
 
@@ -48,7 +48,7 @@ Providers fall into three tiers:
 
 - **Tier 1 — deep native:** `claude`, `codex`. Hand-built adapters over each CLI's richest protocol (Claude's stream-json, Codex's `app-server` JSON-RPC). Subscription-native, fullest feature set.
 - **Tier 2 — ACP:** `gemini`, `copilot`, plus any agent registered via [`acpProvider`](#custom--byok-providers) or `extends: "acp"` config. One shared, tested base over the open [Agent Client Protocol](https://agentclientprotocol.com) (JSON-RPC over stdio).
-- **Tier 3 — bespoke escape hatches:** `opencode` (authenticated HTTP/SSE daemon), `pi` (persistent RPC), `cursor` (exec-backed resume), `openclaw` (HTTP gateway), `process` (any executable).
+- **Tier 3 — bespoke escape hatches:** `opencode` (authenticated HTTP/SSE daemon), `pi` (persistent RPC), `antigravity` (persistent stream-json), `cursor` (exec-backed resume), `openclaw` (HTTP gateway), `process` (any executable).
 
 | Provider   | Transport                              | Tier | Sessions  | Modes | Permissions |
 | ---------- | -------------------------------------- | ---- | --------- | ----- | ----------- |
@@ -58,12 +58,41 @@ Providers fall into three tiers:
 | `copilot`  | `copilot --acp` (ACP)                  | 2    | ✅        | ✅    | ✅          |
 | `opencode` | authenticated `opencode serve` HTTP + SSE | 3 | ✅ resume | ✅ | ✅ |
 | `pi`       | persistent `pi --mode rpc`             | 3    | ✅ resume | —     | —           |
+| `antigravity` | persistent `agy` stream-json (stdin + stdout) | 3 | ✅ resume | ✅ | policy |
 | `cursor`   | `cursor-agent` stream-json per turn    | 3    | ✅ resume | probed | —          |
 | `openclaw` | HTTP gateway                           | 3    | —         | —     | —           |
 | `process`  | any executable                         | 3    | —         | —     | —           |
 
 Cursor sessions are exec-backed. Each `send()` starts one CLI process and promotes the returned Cursor session ID into `--resume` for the next turn. `probeCapabilities()` verifies the selected binary's model catalog and advertised modes. Each execution independently validates the supported stream-json acceptance marker before releasing output. Older Cursor CLIs report `upgrade_required` instead of silently advertising discovery features they do not expose.
 
+### Antigravity (Google)
+
+Google moved personal accounts (Free, Google AI Pro, Google AI Ultra) from Gemini CLI to the [Antigravity CLI](https://antigravity.google/docs/cli/overview) on 2026-06-18. Signing in to Gemini CLI with one of those accounts now fails with "This client is no longer supported for Gemini Code Assist for individuals". Use the `antigravity` provider for them. The `gemini` provider still works with a paid API key or Gemini Code Assist Standard/Enterprise.
+
+```bash
+curl -fsSL https://antigravity.google/cli/install.sh | bash   # installs ~/.local/bin/agy
+agy                                                            # once, to sign in through the browser
+```
+
+```typescript
+const agy = getProvider("antigravity");
+const session = await agy.createSession!({
+  cwd,
+  config: { model: "gemini-3.1-pro-high", effort: "high", modeId: "accept-edits" },
+  onEvent: (e) => { if (e.type === "assistant") console.log(e.text); },
+});
+await (await session.send("Summarize this repo")).result;
+await (await session.send("Now list its entry points")).result; // same agy process, same conversation
+```
+
+- **Transport.** A session is one `agy --input-format stream-json --output-format stream-json` process. Each `send()` writes one NDJSON user message and resolves on that turn's `result` event. `execute()` writes one message and closes stdin, so prompts never travel through argv. Saved `sessionParams` are `{ sessionId, cwd }` and resume with `--conversation`. Antigravity scopes conversations to a directory, so params saved for another `cwd` start a new conversation instead of resuming.
+- **Interrupts.** The CLI has no control protocol, so `interrupt()`, timeouts, and abort signals send SIGINT to the process group, like Ctrl+C. If agy exits instead of reporting the turn as `INTERRUPTED`, the next `send()` starts a new process on the same conversation.
+- **Permissions.** Headless agy cannot ask. `skipPermissions` maps to `--dangerously-skip-permissions`. Without it, actions that would need approval (shell commands by default) are soft-denied and listed in `ExecutionResult.permissionDenials`, and the run still succeeds. Grant specific actions with `permissions.allow` rules in `~/.gemini/antigravity-cli/settings.json`. `permissionRequests` is therefore `false`.
+- **Modes, effort, models.** `listModes()` returns `default`, `accept-edits`, and `plan` (`--mode`). `planMode` maps to `--mode plan`. `config.effort` maps to `--effort` (`low`, `medium`, `high`, `max`). `listModels()` reads `agy models`, which needs a signed-in account.
+- **Sign-in.** An unsigned headless agy prints a login URL and waits a minute for a code. agentex stops it as soon as the prompt appears, emits `auth_required` with `loginCommand: "agy"`, and fails the turn with `errorCode: "auth_required"`.
+- **Usage.** agy reports cumulative usage per process. agentex reports each turn's share, keyed by the pinned model (or `"default"`). `cachedInputTokens` comes from `cache_read_tokens`.
+- **Not yet wired.** `config.mcpServers` (agy reads `~/.gemini/config/mcp_config.json` and `.agents/mcp_config.json` itself), and history import.
+
 OpenCode sessions use a password-authenticated loopback server, SSE events, permission and question reconciliation, durable service-backed history, saved-session discovery and import, runtime model and agent discovery, and upstream provider authentication. `config.mcpServers` remains unsupported for OpenCode because strict isolation from ambient OpenCode MCP configuration is not yet proven.
 
 ### OpenCode and Cursor discovery
@@ -256,7 +285,7 @@ interface ProviderConfig {
   command?: string;                 // Override CLI binary path
   model?: string;
   modelVariant?: string;            // OpenCode provider-native variant, separate from effort
-  effort?: string;
+  effort?: string;                  // claude/antigravity: --effort; codex: turn effort override
   unattendedPermissionPolicy?: "allow" | "deny";
   inputRequestTimeoutSec?: number;  // OpenCode permission/question response deadline, default 300
   maxTurns?: number;
@@ -269,14 +298,14 @@ interface ProviderConfig {
   strictMcpConfig?: boolean;        // claude: --strict-mcp-config — MCP surface is exactly what you attach
   allowedTools?: string[];          // claude: --allowed-tools (patterns verbatim; codex ignores)
   disallowedTools?: string[];       // claude: --disallowed-tools (deny wins; codex ignores)
-  includePartialMessages?: boolean; // claude: emit assistant_delta/thinking_delta typewriter events
+  includePartialMessages?: boolean; // claude, antigravity: emit assistant_delta/thinking_delta typewriter events
   extraArgs?: string[];             // always appended LAST — hosts can override any generated flag
   search?: boolean;
-  sandbox?: boolean;
+  sandbox?: boolean;                // antigravity: --sandbox (terminal sandbox)
   thinking?: string;
-  mode?: string;                    // cursor: --mode <mode>; not for plan mode
-  modeId?: string;                  // select an operating mode from listModes() (codex/ACP)
-  planMode?: boolean;               // read-only "plan" mode (claude/codex)
+  mode?: string;                    // cursor, antigravity: --mode <mode>; not for plan mode
+  modeId?: string;                  // select an operating mode from listModes() (codex/ACP/antigravity)
+  planMode?: boolean;               // read-only "plan" mode (claude/codex/cursor/opencode/antigravity)
   workspace?: { strategy: "worktree"; baseBranch?: string; branchName?: string };
 }
 ```
@@ -434,7 +463,7 @@ When in doubt, `raw` is the verbatim provider event — parse it yourself for an
 
 ### Other providers
 
-`gemini` and `copilot` (ACP) and the session-backed `opencode` and `pi` emit real, correlated `StreamEvent`s — assistant text, thinking, and tool_call/tool_result with proper tool-call ids (ACP and Codex have no per-event/message ids, so those stay `null`). `cursor` and `openclaw` still emit the same `StreamEvent` shape with most ids stubbed to `null`; their `raw` field is populated. `cursor` will gain full fidelity when it moves to the ACP tier.
+`gemini` and `copilot` (ACP), `antigravity`, and the session-backed `opencode` and `pi` emit real, correlated `StreamEvent`s — assistant text, thinking, and tool_call/tool_result with proper tool-call ids (ACP and Codex have no per-event/message ids, so those stay `null`). `cursor` and `openclaw` still emit the same `StreamEvent` shape with most ids stubbed to `null`; their `raw` field is populated. `cursor` will gain full fidelity when it moves to the ACP tier. `antigravity` has no per-call tool ids, so `toolCallId` is `<conversationId>:<stepIndex>`, and `messageId` uses the same key for a response step's `assistant` and `assistant_delta` events.
 
 ## Sessions (multi-turn)
 
@@ -797,6 +826,7 @@ const executeRun = await claude.execute({
 | -------- | -------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
 | `claude` | `--permission-mode plan` (CLI-native plan UX)                        | Agent calls the `ExitPlanMode` tool with the plan as a permission request. Host extracts via `parseExitPlanMode(req)` from `onUserInputRequest`. The plan is **not** in the persisted transcript — capture it live. |
 | `codex`  | `--sandbox read-only` **plus** an injected planning system preamble  | Plain text in the agent's final assistant message (i.e. `result.summary`). |
+| `antigravity` | `--mode plan` (CLI-native: read-only tools, then a plan)        | Plain text in the turn's response (`result.summary`). Headless runs proceed through plan review automatically. |
 
 The mechanism difference matters:
 
@@ -905,6 +935,7 @@ await claude.execute({ prompt: "Respond with 'hello'.", config: { timeoutSec: 15
 | `codex`   | `codex login status` · fallback: `$CODEX_HOME/auth.json`        | `OPENAI_API_KEY`                           | —                                                                            |
 | `gemini`  | `$GEMINI_CONFIG_DIR/oauth_creds.json`                           | `GEMINI_API_KEY`, `GOOGLE_API_KEY`         | —                                                                            |
 | `cursor`  | selected CLI's `status` command                                 | `CURSOR_API_KEY`                           | `OPENAI_API_KEY` is intentionally ignored                                   |
+| `antigravity` | `agy models` exit status (keyring sign-in)                  | `GEMINI_API_KEY`, only with `"modelProvider": "gemini"` in `~/.gemini/antigravity-cli/settings.json` | The CLI ignores `GEMINI_API_KEY` otherwise |
 | `opencode`| —                                                               | `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`      | —                                                                            |
 | `pi`      | —                                                               | `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`      | —                                                                            |
 
@@ -917,6 +948,7 @@ The library reflects real CLI behavior rather than imposing its own:
 | Claude    | API key wins (documented). Set `hasApiKey` + show a billing warning.    |
 | Codex     | Subscription wins (current CLI; see openai/codex#2733, #3286).          |
 | Gemini    | API key wins in non-interactive mode.                                   |
+| Antigravity | `settings.json` decides: `modelProvider: "gemini"` uses the API key, otherwise the signed-in account. |
 
 ### Caching
 
@@ -1024,7 +1056,7 @@ const skillDirs = ["/path/to/code-review", "/path/to/testing"];
 await installSkills(skillDirs, {
   location: "workspace",              // or "global"
   cwd: process.cwd(),                 // required for workspace installs
-  includeNativeDirs: false,           // true also installs into ~/.gemini/skills/, etc.
+  includeNativeDirs: false,           // true also installs into ~/.gemini/skills/, ~/.gemini/antigravity-cli/skills/, etc.
 });
 
 const installed = await listInstalledSkills({ location: "workspace", cwd: process.cwd() });
@@ -1041,11 +1073,11 @@ Channels and locations follow the emerging `.agents/skills/` + `.claude/skills/`
 import { installInstructions, removeInstructions } from "@agentex/agent";
 
 // Workspace (repo-root) install — the common case.
-// Writes the brief into {cwd}/CLAUDE.md and {cwd}/AGENTS.md (deduped by filename).
+// Writes the brief into {cwd}/AGENTS.md, which every runtime reads.
 await installInstructions(brief, {
   location: "workspace",      // or "global"
   cwd: process.cwd(),         // required for workspace installs
-  includeNativeFiles: false,  // true also writes Gemini's native GEMINI.md
+  includeNativeFiles: false,  // true also writes CLAUDE.md (an @AGENTS.md pointer) and GEMINI.md
   managed: true,              // wrap in markers + merge (default); false overwrites the file
   managedTag: "agentex",      // marker tag → <!-- agentex:managed:start -->
 });
@@ -1058,7 +1090,12 @@ await installInstructions(brief, { location: "global" });
 await removeInstructions({ location: "workspace", cwd: process.cwd() });
 ```
 
-Every runtime except Claude reads `AGENTS.md`; Claude reads `CLAUDE.md`. Gemini reads `GEMINI.md` by default (only reads `AGENTS.md` when configured), so it gets a native escape hatch via `includeNativeFiles`. Re-installing unchanged content is idempotent (reported as `skipped`). Use `resolveInstructionTargets(opts)` to see which files *would* be written without touching disk, and `upsertManagedBlock` / `stripManagedBlock` for the low-level merge.
+Every runtime reads `AGENTS.md` at a workspace root. Claude Code does since 2.1.277, but only where the folder has no `CLAUDE.md`: a `CLAUDE.md`, a `CLAUDE.local.md`, or one in a parent folder hides `AGENTS.md` completely. So a workspace `CLAUDE.md` is only ever a one-line `@AGENTS.md` pointer, never a second copy of the brief:
+
+- `includeNativeFiles: true` writes the pointer. Use it for Claude Code before 2.1.277, or on Bedrock, Vertex or Foundry, where Claude doesn't read `AGENTS.md` on its own. It also writes Gemini's native `GEMINI.md` (a copy), since Gemini reads `AGENTS.md` only when configured.
+- With the opt-in off, an existing `CLAUDE.md` is reconciled whenever Claude is among the runtimes: one holding nothing but the managed region is removed (reported `removed`), and one the user wrote gets `@AGENTS.md` in its managed region, so the brief still reaches Claude.
+
+Re-installing unchanged content is idempotent (reported as `skipped`). Use `resolveInstructionTargets(opts)` to see which files *would* be written without touching disk, and `upsertManagedBlock` / `stripManagedBlock` for the low-level merge.
 
 ### Discover Slash-Invokable Skills
 
@@ -1242,7 +1279,7 @@ registerProvider(myProvider);
 - `ensureCommandResolvable(command)` — like `findBinary` but accepts an absolute path too.
 - `clearBinaryCache()` — invalidate the binary-resolution cache.
 - `provider.checkQuota?(ctx)` — rate-limit / quota status (when `capabilities.quotaProbing`).
-- `provider.listModels?(opts?)` — enumerate models the binary can drive. Currently no built-in provider implements this: none of the Claude / Codex / Gemini CLIs expose a non-interactive model-listing subcommand yet (run `pnpm list-models` to re-probe). Pass the model you want directly via `ExecutionContext.model` or `ProviderConfig.model`.
+- `provider.listModels?(opts?)` — enumerate models the binary can drive, where the CLI exposes a catalog (for example `cursor`, `opencode`, and `antigravity` via `agy models`). Otherwise pass the model you want directly via `ExecutionContext.model` or `ProviderConfig.model`.
 
 ### Workspace
 - `prepareWorkspace({ strategy, baseBranch?, branchName?, targetDir? })` → `PreparedWorkspace` with `cwd`, `diff()`, `cleanup()`.
@@ -1268,7 +1305,7 @@ registerProvider(myProvider);
 - `renderTemplate(template, ctx)` — `{{var}}` interpolation.
 - `redactEnvForLogs(env)` — redact sensitive values before logging.
 - `resolveInstructions(path?)` — read an instructions file, or `null` if no path.
-- `installInstructions(content, opts?)` / `removeInstructions(opts?)` — write/remove a managed instruction brief across per-runtime files (`CLAUDE.md` / `AGENTS.md` / native `GEMINI.md`), workspace or global.
+- `installInstructions(content, opts?)` / `removeInstructions(opts?)` — write/remove a managed instruction brief across per-runtime files (`AGENTS.md`, plus opt-in native `CLAUDE.md` pointer / `GEMINI.md`), workspace or global.
 - `resolveInstructionTargets(opts?)` — list which instruction files would be written, without touching disk.
 - `upsertManagedBlock(existing, content, opts?)` / `stripManagedBlock(existing, opts?)` — low-level managed-region merge/strip (preserves content outside the markers).
 - `getDefaultRuntimeHome(runtime, homeDir?)` — pass `homeDir` to resolve against a sandboxed base instead of `os.homedir()`.
@@ -1278,8 +1315,8 @@ registerProvider(myProvider);
 ## Requirements
 
 - Node.js >= 18
-- Each provider's CLI installed and resolvable on `$PATH` (`claude`, `codex`, `gemini`, `agent` for Cursor, `opencode`, `pi`, or a reachable OpenClaw gateway)
-- For subscription auth, the relevant CLI must already be logged in (`codex login`, `claude login`, `gemini auth login`, etc.)
+- Each provider's CLI installed and resolvable on `$PATH` (`claude`, `codex`, `agy` for Antigravity, `gemini`, `agent` for Cursor, `opencode`, `pi`, or a reachable OpenClaw gateway). `agy` is also found at `~/.local/bin/agy` when that folder is not on `$PATH`.
+- For subscription auth, the relevant CLI must already be logged in (`codex login`, `claude login`, `agy` once for Antigravity, etc.)
 
 ## License
 

package/dist/providers/antigravity/codec.d.ts

@@ -0,0 +1,4 @@
+import type { SessionCodec } from "../../types.js";
+/** Antigravity session params: the conversation id plus the directory it is scoped to. */
+export declare const antigravitySessionCodec: SessionCodec;
+//# sourceMappingURL=codec.d.ts.map

package/dist/providers/antigravity/codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../../src/providers/antigravity/codec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAqBnD,0FAA0F;AAC1F,eAAO,MAAM,uBAAuB,EAAE,YAMrC,CAAC"}

package/dist/providers/antigravity/codec.js

@@ -0,0 +1,27 @@
+function readNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function readSessionId(obj) {
+    return readNonEmptyString(obj["sessionId"])
+        ?? readNonEmptyString(obj["session_id"])
+        ?? readNonEmptyString(obj["conversationId"]);
+}
+function normalize(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+        return null;
+    const obj = raw;
+    const sessionId = readSessionId(obj);
+    if (!sessionId)
+        return null;
+    const cwd = readNonEmptyString(obj["cwd"]);
+    return { sessionId, ...(cwd ? { cwd } : {}) };
+}
+/** Antigravity session params: the conversation id plus the directory it is scoped to. */
+export const antigravitySessionCodec = {
+    deserialize: normalize,
+    serialize: (params) => normalize(params),
+    getDisplayId(params) {
+        return params ? readSessionId(params) : null;
+    },
+};
+//# sourceMappingURL=codec.js.map

package/dist/providers/antigravity/codec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.js","sourceRoot":"","sources":["../../../src/providers/antigravity/codec.ts"],"names":[],"mappings":"AAEA,SAAS,kBAAkB,CAAC,KAAc;IACxC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AACpF,CAAC;AAED,SAAS,aAAa,CAAC,GAA4B;IACjD,OAAO,kBAAkB,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;WACtC,kBAAkB,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;WACrC,kBAAkB,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC,CAAC;AACjD,CAAC;AAED,SAAS,SAAS,CAAC,GAAY;IAC7B,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IAC/E,MAAM,GAAG,GAAG,GAA8B,CAAC;IAC3C,MAAM,SAAS,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;IACrC,IAAI,CAAC,SAAS;QAAE,OAAO,IAAI,CAAC;IAC5B,MAAM,GAAG,GAAG,kBAAkB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;IAC3C,OAAO,EAAE,SAAS,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;AAChD,CAAC;AAED,0FAA0F;AAC1F,MAAM,CAAC,MAAM,uBAAuB,GAAiB;IACnD,WAAW,EAAE,SAAS;IACtB,SAAS,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC;IACxC,YAAY,CAAC,MAAM;QACjB,OAAO,MAAM,CAAC,CAAC,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC/C,CAAC;CACF,CAAC"}

package/dist/providers/antigravity/connection.d.ts

@@ -0,0 +1,100 @@
+import type { StreamEvent } from "../../types.js";
+import { type AgyErrorReport, type AgyResult, type AgyStreamParser } from "./parse.js";
+export interface AgyConnectionOptions {
+    command: string;
+    args: string[];
+    cwd: string;
+    env: Record<string, string>;
+    parser: AgyStreamParser;
+    onEvent?: (event: StreamEvent) => void | Promise<void>;
+    onOutput?: (stream: "stdout" | "stderr", chunk: string) => void | Promise<void>;
+}
+/** How a turn (or the whole process) ended, as seen by the host. */
+export interface AgyTurnOutcome {
+    /** The turn's `result` event, or null when the process exited first. */
+    result: AgyResult | null;
+    /** The process has exited. */
+    exited: boolean;
+    exitCode: number | null;
+    signal: string | null;
+    /** The CLI asked for a sign-in, which a headless run can never complete. */
+    authRequired: boolean;
+    agyError: AgyErrorReport | null;
+    /** Last ~16KB of stderr, for error messages. */
+    stderr: string;
+}
+/**
+ * One headless `agy` process speaking `stream-json` in both directions.
+ *
+ * Every stdout line is parsed and dispatched through a single promise chain,
+ * so `onEvent` handlers run strictly in wire order and a turn's waiter
+ * resolves only after the handler for its `result` event has settled.
+ */
+export declare class AgyConnection {
+    private readonly options;
+    readonly pid: number | null;
+    authRequired: boolean;
+    agyError: AgyErrorReport | null;
+    private readonly child;
+    private chain;
+    private stdoutBuffer;
+    private stderrLineBuffer;
+    private stderrTail;
+    private exitInfo;
+    private finalized;
+    private readonly waiters;
+    private readonly exitWaiters;
+    constructor(options: AgyConnectionOptions);
+    get alive(): boolean;
+    /** Exit status, or null while the process runs. */
+    get exit(): {
+        code: number | null;
+        signal: string | null;
+    } | null;
+    /** Last ~16KB of stderr. */
+    get stderr(): string;
+    /** Resolves once the process has exited and every queued event was dispatched. */
+    exited(): Promise<void>;
+    /** Send one user message. Resolve it with `nextTurn()`. */
+    write(text: string): void;
+    /** Close stdin. `agy` finishes the current turn and exits. */
+    endInput(): void;
+    /** Resolves with the next `result` event, or with the exit when no result comes. */
+    nextTurn(): Promise<AgyTurnOutcome>;
+    /** Signal the whole process group. */
+    signal(signal: NodeJS.Signals): void;
+    /** True when the process exited within `ms`. */
+    waitForExit(ms: number): Promise<boolean>;
+    /**
+     * Stop the process: close stdin and give it a moment to exit on its own
+     * (an idle `agy` flushes its conversation history and exits), then
+     * SIGTERM, then SIGKILL after `graceSec`.
+     */
+    terminate(graceSec?: number, idleWaitMs?: number): Promise<void>;
+    private onStdout;
+    private enqueueLine;
+    private onStderr;
+    private inspectStderrLine;
+    /**
+     * A headless run without a cached sign-in prints a login URL and waits a
+     * full minute for a code nobody can paste. Fail fast instead: report it
+     * and stop the process.
+     */
+    private onAuthRequired;
+    private appendStderrTail;
+    private finalize;
+    private outcome;
+    private emitEvent;
+    private emitOutput;
+}
+/** First meaningful stderr line, skipping the sign-in URL noise. */
+export declare function firstAgyErrorLine(stderr: string): string | null;
+/** Waits for `promise` up to `ms`; resolves null on timeout. */
+export declare function within<T>(promise: Promise<T>, ms: number): Promise<T | null>;
+/**
+ * Interrupt the running turn like Ctrl+C would: SIGINT the process group,
+ * give agy a moment to report the turn as INTERRUPTED, and stop the process
+ * if it does not. Resolves with whatever outcome arrived.
+ */
+export declare function interruptAgyTurn(connection: AgyConnection, pending: Promise<AgyTurnOutcome>, graceSec?: number): Promise<AgyTurnOutcome | null>;
+//# sourceMappingURL=connection.d.ts.map

package/dist/providers/antigravity/connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../../src/providers/antigravity/connection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,SAAS,EACd,KAAK,eAAe,EACrB,MAAM,YAAY,CAAC;AAKpB,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,MAAM,EAAE,eAAe,CAAC;IACxB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvD,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACjF;AAED,oEAAoE;AACpE,MAAM,WAAW,cAAc;IAC7B,wEAAwE;IACxE,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IACzB,8BAA8B;IAC9B,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,4EAA4E;IAC5E,YAAY,EAAE,OAAO,CAAC;IACtB,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAC;IAChC,gDAAgD;IAChD,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,qBAAa,aAAa;IAeZ,OAAO,CAAC,QAAQ,CAAC,OAAO;IAdpC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,YAAY,UAAS;IACrB,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAQ;IAEvC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,KAAK,CAAoC;IACjD,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,gBAAgB,CAAM;IAC9B,OAAO,CAAC,UAAU,CAAM;IACxB,OAAO,CAAC,QAAQ,CAA+D;IAC/E,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgD;IACxE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyB;gBAExB,OAAO,EAAE,oBAAoB;IAuB1D,IAAI,KAAK,IAAI,OAAO,CAEnB;IAED,mDAAmD;IACnD,IAAI,IAAI,IAAI;QAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI,CAEhE;IAED,4BAA4B;IAC5B,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,kFAAkF;IAClF,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAKvB,2DAA2D;IAC3D,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAKzB,8DAA8D;IAC9D,QAAQ,IAAI,IAAI;IAQhB,oFAAoF;IACpF,QAAQ,IAAI,OAAO,CAAC,cAAc,CAAC;IAKnC,sCAAsC;IACtC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI;IAIpC,gDAAgD;IAC1C,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAI/C;;;;OAIG;IACG,SAAS,CAAC,QAAQ,SAAI,EAAE,UAAU,SAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAU/D,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,WAAW;IAWnB,OAAO,CAAC,QAAQ;IAWhB,OAAO,CAAC,iBAAiB;IAMzB;;;;OAIG;IACH,OAAO,CAAC,cAAc;IAqBtB,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,QAAQ;IAchB,OAAO,CAAC,OAAO;YAYD,SAAS;YAST,UAAU;CAQzB;AAED,oEAAoE;AACpE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAO/D;AAED,gEAAgE;AAChE,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAc5E;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,UAAU,EAAE,aAAa,EACzB,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,EAChC,QAAQ,SAAI,GACX,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAMhC"}