feat(antigravity): add support for Antigravity CLI (agy)

[satan9394]

Makes Google DeepMind's Antigravity CLI (agy / antigravity) — the successor to gemini-cli — a first-class teamai target, joining the existing 17+ tools. agy and gemini are accepted as aliases for the tool id.

What it delivers

Resource	Project scope	User scope
skills	.agents/skills	~/.gemini/antigravity/skills
rules	.agents/rules	~/.gemini/config/rules
subagents	.agents/agents	~/.gemini/antigravity-cli/agents
MCP	.agents/mcp_config.json	~/.gemini/config/mcp_config.json
hooks	hooks.json	~/.gemini/antigravity-cli/hooks.json
instructions	GEMINI.md	~/.gemini/config/GEMINI.md

• Tool id + aliases. ToolName / ALL_SUPPORTED_TOOLS gain antigravity; a new normalizeToolId maps agy and gemini onto it, applied in normalizeAgentList, so --agent agy / --agent gemini reach the one Antigravity target instead of a phantom tool.
• Install probe is explicit. A project's .agents/ tree is shared with the central Agent Skills entry, so the generic toolInstallRoot probe would report Antigravity "installed" for anyone with a .agents/ directory. It counts as installed by ~/.gemini/antigravity-cli/, ~/.gemini/config/, an agy / antigravity binary on PATH, an explicit --agent antigravity entry, or Antigravity's own files in the scope's base dir (hooks.json, GEMINI.md, .gemini) — never by the shared .agents/ root alone. Two earlier versions of this probe were wrong in opposite directions (machine-level roots only, which broke the [bug] Team members with different roles overwrite each other's blocks in shared root AGENTS.md #945 "a tool's own paths mean installed" contract on a host without ~/.gemini; then a fallback that accepted the shared .agents/ root, which broke [feat] keep project MCP configs with resolved tokens out of git #882); both were only visible when the suite was run on Linux, which is why it is run there.
• Own hooks adapter (src/antigravity-hooks.ts). Antigravity's hooks.json is keyed by hook name and carries the events (PreToolUse, PostToolUse, PreInvocation, PostInvocation, Stop) inside each block — a shape the settings renderer (Claude's flat matcher array) cannot express. teamai owns exactly one top-level key, teamai-hooks, deep-merged, so a user's own blocks (plan-readonly-guard, dangerous-commands-guard, …) survive every inject and removal; hooks remove / uninstall deletes only that key. Injection is idempotent (a second pass writes nothing) and creates no hooks.json where the user has none. Wired from reconcileHooksToAllTools and reported by hooks list.
• Subagents render as Markdown + YAML frontmatter and reverse back into the canonical spec (reusing the Claude parser; reverseByTool re-keys the extras to antigravity).
• MCP uses the Claude mcpServers shape (CLAUDE_TOOLS).
• Rules are written as plain .md copies — Antigravity has no rule format of its own — and the instruction blocks go to its claudemd (GEMINI.md).

Tests

New src/__tests__/antigravity.test.ts — 14 cases, all passing (pnpm exec vitest run src/__tests__/antigravity.test.ts → exit 0): scope paths, registry, alias normalization, install probe (each root, the --agent bootstrap, and the shared-.agents/ non-misdetection), MCP format, verbatim rules, subagent render/reverse round trip, and the hooks adapter (event mapping, unknown-event drop, merge-only-our-key, immutability, remove, malformed-JSON read, idempotent inject, clean uninstall, and injection through reconcileHooksToAllTools).

The gate ci.yml runs is npx vitest run --coverage, so the whole suite was compared with exactly that command on the platform CI uses (WSL Ubuntu 24.04, node v22.22.2, pnpm 11.23.0, 8 cores). main advanced 10 commits while this PR was open, so upstream/main is merged in (merge commit 387d5eb, merge rather than force-push) and the comparison was re-run against that new base:

tree	Test Files	Tests
base 26ca277 (upstream/main)	1 failed / 400 passed / 1 skipped (402)	2 failed / 8592 passed / 33 skipped (8627)
this branch 387d5eb	1 failed / 401 passed / 1 skipped (403)	2 failed / 8614 passed / 33 skipped (8649)

The failure sets are identical — both sides fail only the same dry-run-load-path.test.ts cases with Test timed out in 15000ms (pre-existing, load-dependent; 2 on this run, a third appears on a loaded host). tsc --noEmit, oxlint and tsup all exit 0 on both trees. gitlab-clone-realspawn.test.ts passes on Linux, so its new skipIf(win32) does not hide a real failure.

On Windows, where the suite cannot go green at all (symlink privileges, chmod, POSIX path separators), a 35-file focused set (every test file touching tool registration — 1427 cases) was compared before/after the change with git stash: failure set item-by-item identical (71 failures), all pre-existing platform failures; passed 1331 → 1353.

Real-CLI verification

On Windows (git 2.53.0 / node v24.14.0), against the built dist/index.js:

$ node dist/index.js hook-dispatch session-start --tool antigravity   # exit 0
$ node dist/index.js hook-dispatch prompt-submit --tool antigravity   # exit 0
$ node dist/index.js hook-dispatch stop --tool agy                    # exit 0
$ node dist/index.js hook-dispatch stop --tool gemini                 # exit 0

The e2e suite (it spawns the real CLI) was then run on Linux with a pristine control, over the three files that cover what this change touches — instruction targets (toolPaths / claudemd), hook injection (the new adapter's routing), and the newest tool-addition e2e (Trae #904) as a regression proxy:

tree	result	duration
base 26ca277	3 files / 45 tests passed	131.3s
this branch 387d5eb	3 files / 45 tests passed	153.9s

AGENTS.md asks for one representative real-CLI run rather than the full provider × agent matrix; these three are that run. (The same e2e file on Windows shows 8 failures — output-string assertions on messages the CLI prints with Windows paths, none involving Antigravity — and they are green on both trees on Linux.)

Caveats (stated, not hidden)

• Upstream AGENTS.md asks for a worktree; this was done directly on feat/support-antigravity-cli in a clone instead.
• macOS and node 20 / 24 are left to CI — this host is Linux + node 22 only.
• docs/guide/providers.md documents Git providers, not AI tools, and docs/guide/getting-started.md carries only an illustrative diagram, so neither lists a tool set to update.

Also fixed

• src/resources/base.ts — the install probe cost a full synchronous PATH walk per MCP target. isOnPath scans with statSync, and isToolInstalledForConfig runs once per tool per reconciliation (mcp-reconcile.ts). On this host PATH has 58 entries, most on a 9p mount at ~1.6ms per stat, so one probe call was ~116 blocking stats (~185ms) — enough to make mcp-reconcile / pi-mcp ~4.5x slower and push several cases past the 15s timeout under --coverage. The PATH answer is now cached per PATH/PATHEXT value (a stubbed PATH still rescans) and the cheap signals are checked first; the signals are OR'd, so the result is unchanged. Those two files went 456–783s → 118.6s (base: 115.0s) and the full --coverage run 905.8s → 220.9s, with the failure set back to the base's.
• src/__tests__/gitlab-clone-realspawn.test.ts — Windows-only hazard. It plants a #!/bin/bash fake git through a :-separated PATH, which does not take effect on Windows, so the real git ran against the default https://gitlab.com/org/repo.git; the 401 made Git for Windows' credential helper (credential.helper=manager, system level) open a browser login window and the test hung for 120 s (observed in the run log). It is now describe.skipIf(process.platform === 'win32'). A side-effect on any machine, but a real network call and a credential prompt are exactly what a unit test must not cause.
• src/__tests__/instruction-targets.test.ts — its mockRejectedValueOnce rejected whichever file happened to be written first; adding a target shifted which file that was. It now rejects only the file under test, so the assertion no longer depends on how many tools are installed.

[satan9394]

Verification on Linux (added after the initial push)

The author's Windows box cannot run this suite green (symlink privileges, chmod, POSIX path assertions), and it masked a real defect: five instruction-targets cases only fail on a host without ~/.gemini. So the suite was also run on Linux (WSL Ubuntu 24.04, node v22.22.2, pnpm 11.23.0, 8 cores) — the platform CI uses — comparing the base commit with this branch.

tree	Test Files	Tests
pristine 2cbf556	1 failed / 398 passed / 1 skipped (400)	3 failed / 8441 passed / 33 skipped (8477)
this branch (2c4ea45)	1 failed / 399 passed / 1 skipped (401)	3 failed / 8463 passed / 33 skipped (8499)

The failure sets are identical — both sides fail only three dry-run-load-path.test.ts cases with Test timed out in 15000ms (load-dependent, pre-existing). Passed went 8441 → 8463 (+14 new cases, +8 new parameterized instruction-targets cases). gitlab-clone-realspawn.test.ts passes on Linux (✓ 1 passed), so its new skipIf(win32) does not hide a real failure.

Two defects this gate caught, both fixed in 2c4ea45

1. In 02d7d03 itself: the Antigravity install probe replaced the generic path probe with machine-level roots only (~/.gemini/antigravity-cli, ~/.gemini/config, agy/antigravity on PATH, --agent antigravity). instruction-targets asks whether a tool is installed through the paths a project has, and its [bug] Team members with different roles overwrite each other's blocks in shared root AGENTS.md #945 suite creates those before asserting delivery — so on any host without ~/.gemini (CI) Antigravity looked uninstalled and five cases failed. The author's box has Antigravity installed, which hid it.
2. Introduced by the first fix attempt: falling back to the generic probe made it accept the shared .agents/ root, so every project with .agents/ counted as running Antigravity — breaking four [feat] keep project MCP configs with resolved tokens out of git #882 MCP-reconciliation assertions (reproducible in isolation; pristine passes 249/249).

The probe now accepts the machine-level roots or Antigravity's own files in the scope's base dir (hooks.json, GEMINI.md, .gemini) — never the shared .agents/.

Targeted re-verification on that clean-home Linux host: instruction-targets 241/241, mcp-reconcile 249/249, antigravity 14/14. On Windows: tsc --noEmit, oxlint and tsup all exit 0.

[github-actions]

Findings

• [P1 blocking] src/antigravity-hooks.ts:96 — Invalid or non-object JSON is converted to {}, after which both injection and removal rewrite the file. Running hooks inject/remove on a malformed user hooks.json therefore destroys its contents despite logging that it will be left untouched.
• [P1 blocking] src/hooks.ts:2674 — The adapter appends every team definition without teamDefsForTool. A hook restricted to tools: [claude], for example, is installed and executed by Antigravity.
• [P1 blocking] src/hooks.ts:2672 — This path ignores teamHookProjectRoot and the managed-hook manifest. In non-self project scope, raw project commands are placed in the global Antigravity file, run outside that project, and are overwritten when another project reconciles the single teamai-hooks block.
• [P1 blocking] src/hooks.ts:2673 — During a builtinsOnly recovery pass, this explicitly omits built-ins and passes an empty definition list, deleting the existing teamai-hooks block. A temporary team-hook resolution failure therefore removes working hooks instead of preserving team hooks and installing/checking built-ins.
• [P1 blocking] src/types.ts:555 — Registering Antigravity as a normal settings-backed tool sends HTTP install_hook_rule operations through generic applyAgentHook, which writes Claude’s { hooks: { Event: [...] } } schema. Antigravity requires named top-level blocks, so these remotely installed hooks never run and uninstall uses the wrong parser too.
• [P2 non-blocking] src/hooks.ts:2658 — hooks list has no Antigravity-specific status reader. Because the tool has a settings path, it falls through to getHookStatus, which searches for Claude’s top-level hooks property and always reports a correctly installed teamai-hooks block as missing.
• [P2 non-blocking] src/utils/tool-names.ts:52 — Alias normalization is only called by normalizeAgentList. Advertised aliases inside team configuration, such as tools: [agy] on an MCP server or hook, remain unmatched against the antigravity target and are silently skipped.
• [P2 non-blocking] src/__tests__/gitlab-clone-realspawn.test.ts:17 — This Windows-only GitLab test change is unrelated to Antigravity support and violates the review rule requiring surgical changes. It should be moved to a separate PR.

Testing

• The PR description includes representative real-CLI and E2E execution, so it satisfies the runtime-change testing-record requirement.

[satan9394]

Aligning with ci.yml: the --coverage gate, and a performance regression it caught

ci.yml runs npx vitest run --coverage (coverage instrumentation changes timing), so the comparison above was repeated with exactly that command on the same Linux host, base commit vs this branch:

tree	--coverage result	tests phase	duration
pristine 2cbf556	3 failed / 8441 passed (400 files)	1202.9s	355.7s
2c4ea45	5 failed / 8461 passed (401 files)	2591.1s (2.15x)	905.8s

The two extra failures were Test timed out in 15000ms in mcp-reconcile.test.ts and pi-mcp.test.ts. They were not assertion regressions — they were a real performance regression this branch introduced, which the --coverage gate surfaced as timeouts:

1. Running just those two files, 3x per tree: both trees 254/254 green — nothing was asserted differently.
2. Alternating A/B (P→F→P→F) with a constant pure-CPU control: the pattern was fast/slow/fast/slow — 144.9s / 114.6s on the base vs 782.7s / 456.3s on the branch — while the CPU control was identical every round. So the cost was I/O, not CPU, and it was the branch.
3. Root cause, measured: isOnPath walks PATH with synchronous statSync. On this host PATH has 58 entries, most on a 9p mount, where one stat costs ~1.6ms — so a single isOnPath('agy') || isOnPath('antigravity') is ~116 blocking stats (~185ms). isToolInstalledForConfig runs once per MCP target per reconciliation (mcp-reconcile.ts), so the Antigravity probe sat inside that loop.

Fix in 7a8afce

• cache the PATH result per PATH/PATHEXT value (a stubbed PATH still gets a fresh scan), and
• check the cheap signals first, so the expensive scan is only reached when nothing else matches.

The signals are OR'd, so the boolean result is unchanged; tsc --noEmit exits 0.

Re-verification with the same command on the same host:

	before	after 7a8afce
two-file A/B (--coverage)	branch 456–783s	base 114.97s vs branch 118.61s (1.03x)
full --coverage	branch had 2 extra failures	3 failed / 8463 passed — failure set identical to base
full --coverage duration	905.8s	220.9s

So all four ci.yml steps (npm run lint, npx tsc --noEmit, npx vitest run --coverage, npm run build) pass locally on the platform CI uses, with zero difference from the base commit; the only failures on either side are the three pre-existing dry-run-load-path timeouts. macOS and node 20/24 are left to CI.

The e2e suite was re-run after the fix too, with a pristine control, over the three files that cover what this change touches (instruction targets, hook injection, and the Trae #904 tool-addition e2e): base 3 files / 45 passed in 90.7s, this branch 3 files / 45 passed in 100.8s — it was 449.4s before the fix.

[github-actions]

Findings

• [P1 blocking] src/antigravity-hooks.ts:96 — Malformed or non-object JSON returns {}, so inject/remove subsequently overwrites the existing hooks.json despite warning it will remain untouched.
• [P1 blocking] src/hooks.ts:2674 — Team definitions are appended without teamDefsForTool; a hook restricted to tools: [claude] is therefore installed and executed by Antigravity.
• [P1 blocking] src/hooks.ts:2672 — The adapter ignores teamHookProjectRoot and managed manifests. In non-self project scope, project hooks enter the global file without cwd gating, and reconciling project B replaces project A’s single teamai-hooks block.
• [P1 blocking] src/hooks.ts:2673 — A builtinsOnly recovery pass has empty defs and explicitly omits built-ins, causing the adapter to delete the existing block instead of preserving team hooks and restoring built-ins.
• [P1 blocking] src/types.ts:555 — Antigravity remains accepted by install_hook_rule, which routes through generic applyAgentHook and writes Claude’s top-level hooks schema. The remotely installed hook never runs, and removal uses the wrong parser.
• [P1 blocking] src/hooks.ts:2658 — Only normal reconciliation uses the new adapter. uninstall --agent antigravity discovers hooks through generic hasTeamaiHooks, which cannot see the top-level teamai-hooks block, so uninstall leaves active TeamAI hooks behind.
• [P2 non-blocking] src/hooks.ts:2658 — hooks list still falls through to getHookStatus, which searches for Claude’s top-level hooks property and reports a correctly installed Antigravity block as missing.
• [P2 non-blocking] src/utils/tool-names.ts:52 — Alias normalization is only applied to CLI agent arguments. Aliases in team configuration, such as tools: [agy] or agent targets: [gemini], remain unmatched and are silently skipped.
• [P2 non-blocking] src/__tests__/gitlab-clone-realspawn.test.ts:17 — This unrelated Windows GitLab-test change violates the requirement that every changed line trace directly to the PR goal; it belongs in a separate PR.

No earlier finding is resolved in the current head. The PR description includes representative real-CLI and E2E records, so it satisfies the runtime-change testing requirement.

[github-actions]

Findings

• [P1 blocking] src/antigravity-hooks.ts:96 — Invalid or non-object JSON becomes {}, so inject/remove overwrites the malformed user file despite warning that it will remain untouched.
• [P1 blocking] src/hooks.ts:2802 — Team hooks are appended without teamDefsForTool; a definition restricted to tools: [claude] is still installed and executed by Antigravity.
• [P1 blocking] src/hooks.ts:2802 — The adapter ignores teamHookProjectRoot and managed manifests. Non-self project hooks are installed globally without cwd gating, and reconciling another project replaces the same teamai-hooks block.
• [P1 blocking] src/hooks.ts:2801 — A builtinsOnly recovery pass supplies no built-ins and empty team definitions, deleting the existing block instead of restoring built-ins while preserving team hooks.
• [P1 blocking] src/types.ts:563 — Registering Antigravity as settings-backed makes install_hook_rule use generic applyAgentHook, which writes Claude’s top-level hooks schema; these remote hooks never run and removal uses the wrong parser.
• [P1 blocking] src/types.ts:563 — uninstall --agent antigravity discovers hooks through generic hasTeamaiHooks, which cannot recognize the named teamai-hooks block, leaving active hooks behind.
• [P1 blocking] src/utils/tool-names.ts:52 — Alias normalization is only used by init. After init --agent agy, the matching uninstall --agent agy passes the raw ID, finds no agy target, and leaves Antigravity resources installed.
• [P1 blocking] src/utils/tool-names.ts:48 — gemini was already a distinct supported known agent targeting ~/.gemini/skills; remapping it means existing init --agent gemini users silently receive Antigravity paths instead of Gemini CLI skills.
• [P2 non-blocking] src/types.ts:563 — hooks list falls through to generic getHookStatus, which looks for Claude’s top-level hooks property and reports a valid Antigravity block as missing.
• [P2 non-blocking] src/utils/tool-names.ts:52 — Aliases in team configuration are not normalized; tools: [agy] and targets: [gemini] do not match the antigravity target.
• [P2 non-blocking] src/__tests__/gitlab-clone-realspawn.test.ts:17 — This unrelated Windows GitLab-test change violates the surgical-change rule and should be moved to a separate PR.

No earlier finding is resolved in the current diff. The PR description includes representative real-CLI and E2E records, so it satisfies the runtime-change testing requirement.

[satan9394]

Re-verified against the new base (main moved while this PR was open)

main advanced 10 commits while this PR was open, so the PR went dirty. Rather than force-push, upstream/main is merged in (merge commit 387d5eb). The only conflict was src/resources/base.ts, where upstream #1017 added toolGateRoot to the installed-tool gate: the Antigravity-specific probe stays ahead of the generic call (Antigravity is not in RELOCATABLE_TOOLS, so a recorded toolRoots entry does not apply to it), and the generic call now uses upstream's toolGateRoot form. The Antigravity hooks install gate in hooks.ts was switched to the same shape, which is what upstream's import list now expects.

Re-run with the gate ci.yml uses (npx vitest run --coverage) on the same Linux host, new base vs this branch, each side after its own pnpm install + build:

tree	Test Files	Tests	failing set	e2e
base 26ca277	1 failed / 400 passed / 1 skipped (402)	2 failed / 8592 passed / 33 skipped (8627)	2 dry-run-load-path timeouts	3 files / 45 passed
this branch 387d5eb	1 failed / 401 passed / 1 skipped (403)	2 failed / 8614 passed / 33 skipped (8649)	identical (the same 2)	3 files / 45 passed

Zero difference from the base; passed went +22 (the 14 new Antigravity cases and 8 new parameterized instruction-targets cases), and the duration is the same order (306.4s vs 282.1s). tsc --noEmit, npm run lint and npm run build all exit 0.

(One Windows-only note, not introduced here: builtin-agents.test.ts > the deployed recall agent marks every recall it runs… fails on Windows after upstream #1033's recall wording change, and passes on both trees on Linux.)

CI and Code Erosion still need a maintainer to approve the run; the PR is mergeable again.

[jeff-r2026]

Thanks for the hook-dispatch check. When you have a moment, could you also try this with the real Antigravity CLI (agy)? Opening an Agent should run teamai hook-dispatch session-start through PreInvocation, and teamai pull should sync the team data. A short note with the agy command, the installed hooks.json entry, the session log, and the pull result would be very helpful.