diff --git a/CHANGELOG.md b/CHANGELOG.md
index cb093f1..ff55289 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **Antigravity CLI sessions report to lich.** A sixth harness, and the first
+  whose packaging the plugin has to satisfy as well as its events: an Antigravity
+  plugin is a directory holding a `plugin.json`, whose `hooks.json` and `skills/`
+  are loaded from beside it. Both names are fixed, so those two files are the
+  ones in this repository that live at the root — `agy plugin validate .` passes
+  on the clone, and linking it into `plugins/` installs the hooks and the `theme`
+  skill in one step.
+
+  It reports the session id and `busy` on `PreInvocation`, the running tool on
+  `PreToolUse`, the git-status refresh on `PostToolUse`, and `done` plus the
+  title on `Stop` — the title being the transcript's first `USER_INPUT` line,
+  unwrapped from its `<USER_REQUEST>` tags. `waiting` and `idle` are not
+  reported: no event has been measured for either, and `Stop` ends one execution
+  loop rather than the conversation.
+
+  Two Antigravity rules the shared scripts had to learn. Its hooks are run
+  through `sh -c` with the working directory set to the plugin root and no
+  plugin-root variable of any kind, so the registration spells relative paths.
+  And a hook answers on stdout, where the answer is acted on — `decision` is
+  required before a tool call — so the registration appends the verdict each
+  event asks for, leaving the scripts silent for Codex, which reads their stdout
+  as an answer to a permission request.
+
+  The provider id is registered in lich (omartelo/lich#370), so the fixtures
+  enumerate `antigravity` like every other provider and the suite holds this
+  client to it.
+
 - **A waiting card says what the session is waiting for.** The `waiting` report
   now carries a `reason`, so the bell says *why* rather than only *that*. Each
   harness hands over something different to say it with: Claude Code's
diff --git a/CLAUDE.md b/CLAUDE.md
index a3e591c..c4a879d 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -1,6 +1,6 @@
 # lich-plugin
 
-The agent side of the integration with **lich** — a harness that orchestrates agent CLI sessions. This companion plugin is how lich observes and acts inside a running session. It ships hooks — each following a contract documented in `docs/` — plus skills for work that targets lich itself. One plugin, packaged for **Claude Code**, **OpenAI Codex**, **opencode**, **omp** (oh-my-pi) and **Crush** from the same repository root.
+The agent side of the integration with **lich** — a harness that orchestrates agent CLI sessions. This companion plugin is how lich observes and acts inside a running session. It ships hooks — each following a contract documented in `docs/` — plus skills for work that targets lich itself. One plugin, packaged for **Claude Code**, **OpenAI Codex**, **Antigravity CLI**, **opencode**, **omp** (oh-my-pi) and **Crush** from the same repository root.
 
 ## Structure
 
@@ -9,10 +9,12 @@ The agent side of the integration with **lich** — a harness that orchestrates
 .claude-plugin/marketplace.json   # marketplace, Claude Code
 .codex-plugin/plugin.json         # plugin manifest, Codex
 .agents/plugins/marketplace.json  # marketplace, Codex
+plugin.json                       # plugin manifest, Antigravity — name and place both fixed
+hooks.json                        # hook registration, Antigravity — likewise
 hooks/hooks.json                  # hook registration, Claude Code
 hooks/codex-hooks.json            # hook registration, Codex
 hooks/crush-hooks.json            # hook registration, Crush (hand-merged into crush.json)
-hooks/                            # hook scripts ($CLAUDE_PLUGIN_ROOT/hooks/<script>, all three)
+hooks/                            # hook scripts (all four run them; only how they are addressed differs)
 hooks/detail.jq                   # what a tool call acts on, shared by two of those scripts
 hooks/win-run.cmd                 # runs one of those scripts on Windows (Codex)
 opencode/lich.js                  # opencode client: a module, not a command
@@ -22,6 +24,17 @@ skills/                           # skills (skills/<name>/SKILL.md, all)
 tests/                            # hook payloads asserted against lich's fixtures
 ```
 
+**Antigravity** runs the scripts, but on its own terms, and both of them are in
+the file layout above. Its plugins are directories — `plugins/<name>/plugin.json`
+with `hooks.json` and `skills/` beside it — and neither filename is
+configurable, which is why those two sit at the repository root instead of in a
+namespaced folder: the root is the plugin directory once the clone is linked in.
+It also sets no plugin-root variable, running a hook through `sh -c` with the
+working directory set to that root, so its registration alone spells relative
+paths; and it reads a JSON verdict off the hook's stdout, so the registration
+appends one per event while the scripts stay silent. `agy plugin validate .`
+checks the bundle from a clone.
+
 Three harnesses do not fit the script model, each its own way. **opencode** runs
 no commands: a plugin there is a JavaScript module its server imports, so all
 four reports live in `opencode/lich.js`. **omp** has a `--hook` flag but merges
@@ -88,6 +101,9 @@ the network; CI diffs the copies against upstream and fails on drift.
 - One script per contract, shared by every provider that runs commands. Registration differs per harness, the report does not — extend a script to read a second transcript format before adding a second script. A harness that runs no commands at all is the one case for a client of its own, which is what `opencode/lich.js` and `omp/lich.js` are; they still send the same payloads to the same endpoints.
 - opencode and omp both await their plugin handlers, so neither `lich.js` ever awaits a report or throws — that is their version of "always exit 0". The omp one also subscribes to nothing outside lich: omp loads it on every run on the machine, so the gate has to be in the module.
 - **A module client names only events it was measured emitting.** A name read off a type declaration is a report that silently never fires, which is worse than an absent feature — the omp `waiting` state is left unreported for exactly this reason.
+- **The same goes for every other name a registration carries** — an event, a tool a matcher names, a payload field, a plugin-root variable. All of them fail the same way: quietly, on every event, with a green test suite, because a harness that never runs the hook reports nothing to disagree with.
+- **A name is measured off a real payload, or it is a guess.** Not from a harness you already support, and not from a symbol table or an enum either — those are the *implementation's* names, and something may map them before they reach a hook. Antigravity is the worked example in both directions: its guide says a tool name is the step type lowercased with `CORTEX_STEP_TYPE_` dropped, and the enum's `MCP_TOOL` still arrives as `call_mcp_tool`. Its write tools really are `write_to_file` and `replace_file_content`, which the enum does not contain. Run the turn, print the payload, read the name off it — a matcher built any other way matches nothing, and losing a report costs no error, only the report.
+- **A test that supplies what the harness supplies proves nothing.** The suite exports `$CLAUDE_PLUGIN_ROOT` because Claude Code and Codex do; running Antigravity's registration under it hid the fact that Antigravity does not. Each harness's registration is run the way *that* harness runs it — see `pluginRoot` in `tests/hooks.test.mjs`.
 
 ## Local testing
 
@@ -97,6 +113,11 @@ claude --plugin-dir .
 
 Codex has no equivalent one-shot flag; install the clone as a local marketplace instead (`codex plugin marketplace add .` then `codex plugin add lich@lich-plugin`), and trust the hooks once with `/hooks`.
 
+Antigravity has none either, but it does have a checker: `agy plugin validate .`
+reads the clone as a plugin and says what it loaded (`skills: 1`, `hooks: 1`) —
+a missing or misplaced `plugin.json` fails it outright. To run it for real,
+symlink the clone into `~/.gemini/config/plugins/lich`.
+
 ## Release
 
 Same standard as the `lich` repository (Keep a Changelog + SemVer). Releases are cut by tagging `vX.Y.Z`:
diff --git a/README.md b/README.md
index f6ad3d8..9a64cf9 100644
--- a/README.md
+++ b/README.md
@@ -1,13 +1,13 @@
 # lich-plugin
 
-The agent side of the [lich](https://github.com/omartelo/lich) integration. lich is a harness that orchestrates agent CLI sessions; this companion plugin gives it eyes and hands inside each session. It installs on **Claude Code**, **OpenAI Codex**, **opencode**, **omp** (oh-my-pi) and **Crush** from this same repository. Every hook implements a contract that is canonical in the lich repository (`docs/hooks/` there); the docs in `docs/` here point at each contract and describe the client side:
+The agent side of the [lich](https://github.com/omartelo/lich) integration. lich is a harness that orchestrates agent CLI sessions; this companion plugin gives it eyes and hands inside each session. It installs on **Claude Code**, **OpenAI Codex**, **Antigravity CLI**, **opencode**, **omp** (oh-my-pi) and **Crush** from this same repository. Every hook implements a contract that is canonical in the lich repository (`docs/hooks/` there); the docs in `docs/` here point at each contract and describe the client side:
 
-- **session state** — `busy`/`done` on the session card (`UserPromptSubmit`/`Stop`)
-- **session start** — persists the agent's session id on the lich session (`SessionStart`)
+- **session state** — `busy`/`done` on the session card (`UserPromptSubmit`/`PreInvocation`/`Stop`)
+- **session start** — persists the agent's session id on the lich session (`SessionStart`/`PreInvocation`)
 - **session title** — names the card after the session's own title (`Stop`)
 - **session touched** — refreshes the card's git status right after file-mutating tools (`PostToolUse`)
 
-The four are what Claude Code, Codex, opencode and omp report. **Crush reports two of them** — its session id and the git-status refresh — because `PreToolUse` is the only event it has, and a state nothing can end is worse on a card than no state. **omp reports all four minus the bell**: no event of its own for "your turn" has been measured yet, so its card shows a spinner while the agent waits on you. [docs/providers.md](docs/providers.md) has the event mapping per harness.
+The four are what Claude Code, Codex, Antigravity, opencode and omp report. **Crush reports two of them** — its session id and the git-status refresh — because `PreToolUse` is the only event it has, and a state nothing can end is worse on a card than no state. **omp reports all four minus the bell**: no event of its own for "your turn" has been measured yet, so its card shows a spinner while the agent waits on you. [docs/providers.md](docs/providers.md) has the event mapping per harness.
 
 On **opencode** it also carries the other direction: the seven operations lich
 offers a session for driving the sessions beside it — list, send, wait, reply,
@@ -19,7 +19,7 @@ two cases where they are deliberately absent.
 
 It also ships skills for the parts of lich you configure from inside a session:
 
-- **theme** (`/lich:theme` in Claude Code; on Codex the `theme` skill loads from its description) — write, port or fix a lich color theme: the app tokens, the xterm palette, where the file goes, and a validator for the rules that otherwise fail silently
+- **theme** (`/lich:theme` in Claude Code; on Codex and Antigravity the `theme` skill loads from its description) — write, port or fix a lich color theme: the app tokens, the xterm palette, where the file goes, and a validator for the rules that otherwise fail silently
 
 ## Structure
 
@@ -28,6 +28,8 @@ It also ships skills for the parts of lich you configure from inside a session:
 .claude-plugin/marketplace.json   # marketplace, Claude Code
 .codex-plugin/plugin.json         # plugin manifest, Codex
 .agents/plugins/marketplace.json  # marketplace, Codex
+plugin.json                       # plugin manifest, Antigravity (name fixed, must sit at the root)
+hooks.json                        # hook registration, Antigravity (likewise)
 hooks/hooks.json                  # hook registration, Claude Code
 hooks/codex-hooks.json            # hook registration, Codex
 hooks/crush-hooks.json            # hook registration, Crush (merged into crush.json by hand)
@@ -43,7 +45,7 @@ skills/theme/                     # theme skill: SKILL.md, template.json, valida
 tests/                            # hook payloads asserted against lich's fixtures
 ```
 
-One set of hook scripts serves Claude Code, Codex and Crush — they live in `hooks/` and are referenced via `$CLAUDE_PLUGIN_ROOT/hooks/<script>`, a variable Codex sets too. opencode and omp run no commands: in both, what gets loaded is a JavaScript module, so each has a single-file client — `opencode/lich.js` and `omp/lich.js` — sending the same payloads to the same endpoints. [docs/providers.md](docs/providers.md) maps the layout and every harness's event names.
+One set of hook scripts serves Claude Code, Codex, Antigravity and Crush — they live in `hooks/`. Claude Code and Codex reach them through `$CLAUDE_PLUGIN_ROOT/hooks/<script>`, a variable Codex sets too; Crush ships a placeholder the user replaces. Antigravity sets no such variable — it runs a hook with the working directory set to the plugin root, so its registration spells `hooks/<script>` relative to that, and it is the reason `plugin.json` and `hooks.json` sit at the root: Antigravity fixes both names and looks for them nowhere else. opencode and omp run no commands: in both, what gets loaded is a JavaScript module, so each has a single-file client — `opencode/lich.js` and `omp/lich.js` — sending the same payloads to the same endpoints. [docs/providers.md](docs/providers.md) maps the layout and every harness's event names.
 
 ## Installation
 
@@ -67,6 +69,19 @@ codex plugin add lich@lich-plugin
 
 Then start a new session and run `/hooks` to review and trust the plugin's hooks — Codex does not run a plugin's hooks until you do, so until then the plugin is installed but silent. Hooks themselves are stable and on by default in current Codex; on older versions set `[features] hooks = true` in `~/.codex/config.toml`.
 
+### Antigravity CLI
+
+A plugin is a directory holding a `plugin.json`, under a `plugins/` folder in a customization root. Symlink the clone into one — globally, or into a project's `.agents/` to share it with the team:
+
+```bash
+mkdir -p ~/.gemini/config/plugins
+ln -s "$PWD" ~/.gemini/config/plugins/lich
+```
+
+That is the whole install: the hooks come from `hooks.json` beside the manifest, and the `theme` skill from `skills/`. `agy plugin validate .` checks the bundle from the clone before you link it, `agy plugin list` shows it afterwards, and `agy plugin disable lich` turns it off again.
+
+Without the plugin, [`hooks.json`](hooks.json) can be merged into `~/.gemini/config/hooks.json` (global) or `.agents/hooks.json` (per project) — but a hook's working directory is the folder holding the `hooks.json` that declared it, so replace each `hooks/` prefix with the absolute path to this clone.
+
 ### opencode
 
 opencode has no marketplace: a plugin is a file in its plugin directory, so dropping it there is the install.
diff --git a/docs/providers.md b/docs/providers.md
index 7d7d28e..796db55 100644
--- a/docs/providers.md
+++ b/docs/providers.md
@@ -14,22 +14,35 @@ This repository is one plugin, packaged for each harness it supports:
 | `.claude-plugin/marketplace.json` | Claude Code | marketplace, points at `./` |
 | `.codex-plugin/plugin.json`     | Codex       | plugin manifest               |
 | `.agents/plugins/marketplace.json` | Codex    | marketplace, points at `./`   |
+| `plugin.json`                   | Antigravity | plugin manifest               |
 | `hooks/hooks.json`              | Claude Code | hook registration             |
 | `hooks/codex-hooks.json`        | Codex       | hook registration             |
+| `hooks.json`                    | Antigravity | hook registration, name and place both fixed |
 | `hooks/crush-hooks.json`        | Crush       | hook registration, merged by hand |
-| `hooks/*.sh`                    | the three   | the reports themselves        |
+| `hooks/*.sh`                    | the four    | the reports themselves        |
 | `hooks/win-run.cmd`             | Codex       | runs a script on Windows      |
 | `opencode/lich.js`              | opencode    | the whole client, as a module |
 | `omp/lich.js`                   | omp         | the whole client, as a module |
 | `skills/`                       | all         | skills, same layout           |
 
-The repository root is the plugin root for Claude Code and Codex, so a single
-clone installs on either CLI. The scripts are shared because those harnesses —
-and Crush — expose the same things a report needs: the payload arrives as JSON
-on stdin with `session_id` and `transcript_path` (and `tool_name` /
-`tool_input` / `cwd` on a pre-tool event), and `$CLAUDE_PLUGIN_ROOT` points at
-the installed plugin — Codex sets that same variable, so the command lines are
-identical.
+The repository root is the plugin root for Claude Code, Codex and Antigravity,
+so a single clone installs on any of the three. The scripts are shared because
+those harnesses — and Crush — expose the same things a report needs: the payload
+arrives as JSON on stdin naming the session (`session_id`, or `conversationId`
+on Antigravity), the transcript (`transcript_path` / `transcriptPath`) and, on a
+pre-tool event, the call (`tool_name` + `tool_input` + `cwd`, or `toolCall` +
+`workspacePaths`). Every script reads both spellings, so one script still serves
+every harness.
+
+**How the command finds the script is where Antigravity parts company.** Claude
+Code, Codex and Crush all give the command line a plugin root to start from:
+`$CLAUDE_PLUGIN_ROOT` for the first two, a `<lich-plugin>` placeholder the user
+replaces for Crush. Antigravity sets no such variable — it runs the command
+through `sh -c` with the working directory set to the folder holding
+`hooks.json`, which for a plugin is the plugin root. So its registration alone
+spells relative paths (`hooks/report-state.sh busy`), and a `${CLAUDE_PLUGIN_ROOT}`
+copied in from the Claude Code file expands to nothing there: every hook then
+runs `/hooks/<script>` and exits 127, silently, on every event.
 
 **opencode and omp are the exceptions, and both are packaging ones.** Neither
 has a notion of a hook command. In opencode a plugin is a JavaScript module the
@@ -44,16 +57,16 @@ swallows its own errors and never awaits a report.
 
 ## Event vocabulary
 
-| Report              | Claude Code                  | Codex                        | opencode                  | omp                      | Crush                       |
-|---------------------|------------------------------|------------------------------|---------------------------|--------------------------|-----------------------------|
-| session id          | `SessionStart`               | `SessionStart`               | `session.created`         | `session_start`          | `PreToolUse`                |
-| `busy`              | `UserPromptSubmit`, `PostToolUse` | `UserPromptSubmit`, `PostToolUse` | `session.status` (`busy`) | `input`, `turn_start` | —              |
-| `busy` + tool       | `PreToolUse`                 | `PreToolUse`                 | `tool.execute.before`     | `tool_call`              | —                           |
-| `waiting` + reason  | `Notification`               | `PermissionRequest`          | any `*.asked`             | — (see below)            | —                           |
-| `done`              | `Stop`                       | `Stop`                       | `session.status` (`idle`) | `session_stop`           | —                           |
-| title               | `Stop`                       | `Stop`                       | `session.updated`         | `session_stop`, `turn_start` | —                       |
-| `idle`              | `SessionEnd`                 | — (registered, never fires)  | — (nothing outlives it)   | — (nothing outlives it)  | —                           |
-| touched             | `PostToolUse` (write tools)  | `PostToolUse` (write tools)  | `file.edited`             | `tool_result` (write tools) | `PreToolUse` (write tools) |
+| Report              | Claude Code                  | Codex                        | Antigravity                  | opencode                  | omp                      | Crush                       |
+|---------------------|------------------------------|------------------------------|------------------------------|---------------------------|--------------------------|-----------------------------|
+| session id          | `SessionStart`               | `SessionStart`               | `PreInvocation`              | `session.created`         | `session_start`          | `PreToolUse`                |
+| `busy`              | `UserPromptSubmit`, `PostToolUse` | `UserPromptSubmit`, `PostToolUse` | `PreInvocation`        | `session.status` (`busy`) | `input`, `turn_start` | —              |
+| `busy` + tool       | `PreToolUse`                 | `PreToolUse`                 | `PreToolUse`                 | `tool.execute.before`     | `tool_call`              | —                           |
+| `waiting` + reason  | `Notification`               | `PermissionRequest`          | — (not measured)             | any `*.asked`             | — (see below)            | —                           |
+| `done`              | `Stop`                       | `Stop`                       | `Stop`                       | `session.status` (`idle`) | `session_stop`           | —                           |
+| title               | `Stop`                       | `Stop`                       | `Stop`                       | `session.updated`         | `session_stop`, `turn_start` | —                       |
+| `idle`              | `SessionEnd`                 | — (registered, never fires)  | — (never fires)              | — (nothing outlives it)   | — (nothing outlives it)  | —                           |
+| touched             | `PostToolUse` (write tools)  | `PostToolUse` (write tools)  | `PostToolUse` (write tools)  | `file.edited`             | `tool_result` (write tools) | `PreToolUse` (write tools) |
 
 Every cell above was taken off a real run of that harness against a stub
 listener, not off its documentation.
@@ -232,16 +245,97 @@ listener. 17.x moves fast — re-measure before trusting a name.
   `ls`, `grep`, `glob`, `mcp_*`. `view` is the read tool — the matcher for the
   touched report lists the writers only.
 
+## Antigravity specifics
+
+Antigravity is the one harness whose *packaging* the plugin has to satisfy as
+well as its events. Everything below comes off the guide the CLI itself ships
+(`~/.gemini/antigravity-cli/builtin/skills/agy-customizations/docs/`) and a run
+against a stub listener — not off a name that reads plausibly.
+
+- **A plugin is a directory, and both its files are named for it.** Antigravity
+  discovers `plugins/<name>/plugin.json` under a customization root and loads the
+  `hooks.json`, `skills/` and `rules/` sitting beside it. Neither name is
+  configurable: a `hooks/<harness>-hooks.json` named the way every other
+  registration here is would be discovered by nothing at all.
+  That is why the manifest and the registration are the two files in this
+  repository that live at the root rather than in a namespaced folder — the root
+  *is* the plugin directory once the clone is installed as one, and `skills/` is
+  picked up from there for free.
+- **The registration is keyed by hook name, not by `hooks`.** Every top-level key
+  in a `hooks.json` is one integration's name, so several merge into one file;
+  lich's is `lich`. `PreToolUse` and `PostToolUse` group handlers behind a
+  `matcher`; `PreInvocation` and `Stop` are flat lists of handlers.
+- **Commands are relative to the plugin root.** See above — no plugin-root
+  variable exists.
+- **A hook answers on stdout, and the answer is acted on.** Antigravity reads a
+  JSON object back: `PreToolUse` requires a `decision`, and `Stop` takes one too,
+  where `continue` refuses to let the loop end. Silence is not the neutral
+  answer it is on every other harness, so the registration appends the verdict
+  the event asks for — `{"decision":"allow"}` before a tool, `{"decision":""}` on
+  `Stop`, `{}` elsewhere. The scripts stay silent, because on Codex their stdout
+  would answer a permission request instead.
+- **Payloads are camelCase** (protojson): `conversationId` is the session id,
+  `workspacePaths[0]` the session's directory, `transcriptPath` the JSONL log.
+  Tool calls arrive as `toolCall.name` with PascalCase arguments under
+  `toolCall.args` (`CommandLine`, `TargetFile`, `AbsolutePath`, `Query`, `Url`).
+- **The title is the first `USER_INPUT` line of the transcript**, unwrapped from
+  its `<USER_REQUEST>` tags — the same shape Codex's first user message has, so
+  `report-title.sh` reads it in the same pass.
+- **`PreInvocation` fires before every model call, not once per turn.** Session
+  id and `busy` therefore go out several times a turn. Both are idempotent, so
+  the card is right either way, and it is what makes `busy` cheap enough to leave
+  on the same event as the session id.
+- **Tool names can only be measured, never derived.** The CLI's own guide says
+  a tool name is its step type lowercased with the `CORTEX_STEP_TYPE_` prefix
+  dropped — and that is not what arrives: the enum's `MCP_TOOL` reaches a hook
+  as `call_mcp_tool`, so something maps names on top of it. What a real turn
+  sends is `run_command`, `write_to_file`, `replace_file_content`, `view_file`,
+  `list_dir` and `call_mcp_tool`, with PascalCase arguments (`CommandLine`,
+  `TargetFile`, `AbsolutePath`, `DirectoryPath`, `ServerName`/`ToolName`). A
+  matcher built from the enum instead matches nothing at all, silently — which
+  is how the git-status refresh can stop firing on a write with the suite still
+  green.
+- **Every MCP tool arrives as the one tool `call_mcp_tool`**, the server and the
+  tool it called being arguments. `detail.jq` reads them, so the card can tell
+  two MCP calls apart — lich's own tools reach a session this way.
+- **Not reported: `waiting` and `idle`.** No event has been measured for either.
+  `PermissionRequest` has no counterpart here — `PreToolUse` could gate a call,
+  but a hook that answers `ask` to ring a bell would be changing the turn rather
+  than observing it. `Stop` ends one execution loop, not the conversation, so it
+  is `done` and never `idle`. `PostInvocation` exists and is unregistered:
+  nothing is left for it to say.
+- **The provider id is `antigravity`**, registered in lich and enumerated by
+  `tests/fixtures/session-start.jsonl` like every other one. It landed there
+  first: the contract moves in lich — prose, then fixtures, then the endpoint —
+  and only then here.
+
 ## Adding a provider
 
 1. Confirm the harness exposes the session lifecycle to something it will run or
    load, and that it names the session id.
 2. Add its manifest and marketplace file if it has them, and a hook-registration
-   file mapping its events onto the existing scripts.
-3. Only write a new script if a report cannot be derived from what the existing
-   ones read — extend one instead (`report-title.sh` reads two transcript
+   file mapping its events onto the existing scripts. Take the filenames, the
+   event names, the payload fields and the tool names a matcher lists from the
+   harness itself — its own docs, its binary, a run against a stub — never from
+   what they resemble on a harness already supported here. Every one of those
+   fails the same silent way: a hook that does not run reports nothing to
+   disagree with.
+3. Answer the harness on the terms it addresses the command with. Two things
+   differ per harness and neither has a default worth assuming: how the command
+   finds the script (`$CLAUDE_PLUGIN_ROOT`, a placeholder, or a working directory
+   and relative paths), and what it expects back (silence, an exit code, or a
+   JSON verdict on stdout). Run its registration in the suite the way *that*
+   harness runs it — a test that exports what the harness does not is a test that
+   proves nothing.
+4. Register the provider id in lich before the client reports it: prose, then
+   fixtures, then the endpoint, then here. A fixture is never edited to make a
+   run green — until lich accepts the id, declare it in `PENDING_UPSTREAM`
+   (`tests/contract.mjs`), which fails the moment a refreshed fixture registers
+   it.
+5. Only write a new script if a report cannot be derived from what the existing
+   ones read — extend one instead (`report-title.sh` reads three transcript
    formats). A harness that takes no commands at all is the one case for a
    client of its own, which is what `opencode/lich.js` is.
-4. Register only the reports the harness can actually close. A state nothing can
+6. Register only the reports the harness can actually close. A state nothing can
    end is worse on a card than no state.
-5. Add the provider's column to each doc in this directory.
+7. Add the provider's column to each doc in this directory.
diff --git a/docs/session-start.md b/docs/session-start.md
index 606a986..22b9b47 100644
--- a/docs/session-start.md
+++ b/docs/session-start.md
@@ -8,17 +8,18 @@ Reports the agent CLI's own session id so lich can persist the link between its
 session (the card) and the agent session running inside it. lich stores it as
 the *provider* session id — the field is provider-agnostic.
 
-| script                             | action                          | Claude Code hook | Codex hook     | opencode event    | omp event       | Crush hook   |
-|------------------------------------|---------------------------------|------------------|----------------|-------------------|-----------------|--------------|
-| `report-session-start.sh <provider>` | send the CLI's `session_id`   | `SessionStart`   | `SessionStart` | `session.created` | `session_start` | `PreToolUse` |
+| script                             | action                          | Claude Code hook | Codex hook     | Antigravity hook | opencode event    | omp event       | Crush hook   |
+|------------------------------------|---------------------------------|------------------|----------------|------------------|-------------------|-----------------|--------------|
+| `report-session-start.sh <provider>` | send the CLI's `session_id`   | `SessionStart`   | `SessionStart` | `PreInvocation`  | `session.created` | `session_start` | `PreToolUse` |
 
 `POST /session-start` with `{"session_id": $LICH_SESSION_ID,
-"provider_session_id": <session_id from the hook payload on stdin>, "provider":
+"provider_session_id": <session_id/conversationId from the hook payload on stdin>, "provider":
 <$1>}`.
 
 The provider id comes from the registration, not from the payload: the scripts
 are shared, the hook files are not, so `hooks.json` passes `claude`,
-`codex-hooks.json` passes `codex` and `crush-hooks.json` passes `crush`.
+`codex-hooks.json` passes `codex`, the root `hooks.json` passes `antigravity`
+and `crush-hooks.json` passes `crush`.
 `opencode/lich.js` and `omp/lich.js` have no registration to read it from and
 spell their own.
 lich keys the card's icon on it — a hand-run `codex` inside a shell session
diff --git a/docs/session-state.md b/docs/session-state.md
index bb99e35..4181025 100644
--- a/docs/session-state.md
+++ b/docs/session-state.md
@@ -8,14 +8,14 @@ Reports the session's processing state so the lich card shows a spinner while
 the agent works, a check when the turn ends, and a bell (plus an actionable
 toast) when the agent is blocked on the user.
 
-| script                    | state            | Claude Code hook   | Codex hook          | opencode event            | omp event       |
-|---------------------------|------------------|--------------------|---------------------|---------------------------|-----------------|
-| `report-state.sh busy`    | `busy`           | `UserPromptSubmit` | `UserPromptSubmit`  | `session.status` (`busy`) | `input`         |
-| `report-tool.sh`          | `busy` + `tool`  | `PreToolUse`       | `PreToolUse`        | `tool.execute.before`     | `tool_call`     |
-| `report-state.sh busy`    | `busy`           | `PostToolUse`      | `PostToolUse`       | `session.status` (`busy`) | `turn_start`    |
-| `report-state.sh done`    | `done`           | `Stop`             | `Stop`              | `session.status` (`idle`) | `session_stop`  |
-| `report-state.sh waiting` | `waiting`+`reason`| `Notification`    | `PermissionRequest` | any `*.asked`             | — (not measured)|
-| `report-state.sh idle`    | `idle`           | `SessionEnd`       | — (never fires)     | — (never fires)           | — (never fires) |
+| script                    | state            | Claude Code hook   | Codex hook          | Antigravity hook   | opencode event            | omp event       |
+|---------------------------|------------------|--------------------|---------------------|--------------------|---------------------------|-----------------|
+| `report-state.sh busy`    | `busy`           | `UserPromptSubmit` | `UserPromptSubmit`  | `PreInvocation`    | `session.status` (`busy`) | `input`         |
+| `report-tool.sh`          | `busy` + `tool`  | `PreToolUse`       | `PreToolUse`        | `PreToolUse`       | `tool.execute.before`     | `tool_call`     |
+| `report-state.sh busy`    | `busy`           | `PostToolUse`      | `PostToolUse`       | —                  | `session.status` (`busy`) | `turn_start`    |
+| `report-state.sh done`    | `done`           | `Stop`             | `Stop`              | `Stop`             | `session.status` (`idle`) | `session_stop`  |
+| `report-state.sh waiting` | `waiting`+`reason`| `Notification`    | `PermissionRequest` | — (not measured)   | any `*.asked`             | — (not measured)|
+| `report-state.sh idle`    | `idle`           | `SessionEnd`       | — (never fires)     | — (never fires)    | — (never fires)           | — (never fires) |
 
 opencode and omp run no scripts: `opencode/lich.js` and `omp/lich.js` send the
 same payloads off the events their harness hands a loaded module. opencode's
@@ -130,15 +130,16 @@ always exit 0) stop being merely polite here.
 What the two harnesses actually send, taken off a real run of each against a
 stub listener rather than off their documentation:
 
-| Action        | Claude Code       | Codex                     | opencode         | omp              |
-|---------------|-------------------|---------------------------|------------------|------------------|
-| run a command | `Bash`            | `Bash`                    | `bash`           | `bash`           |
-| edit a file   | `Edit` / `Write`  | `apply_patch`             | `edit` / `write` | `edit` / `write` |
-| read a file   | `Read`            | — (goes through `Bash`)   | `read`           | `read`           |
-| search        | `Grep` / `Glob`   | — (goes through `Bash`)   | `grep` / `glob`  | `grep` / `glob`  |
+| Action        | Claude Code       | Codex                     | Antigravity                        | opencode         | omp              |
+|---------------|-------------------|---------------------------|------------------------------------|------------------|------------------|
+| run a command | `Bash`            | `Bash`                    | `run_command`                      | `bash`           | `bash`           |
+| edit a file   | `Edit` / `Write`  | `apply_patch`             | `write_to_file` / `replace_file_content` | `edit` / `write` | `edit` / `write` |
+| read a file   | `Read`            | — (goes through `Bash`)   | `view_file`                        | `read`           | `read`           |
+| search        | `Grep` / `Glob`   | — (goes through `Bash`)   | `grep_search`                      | `grep` / `glob`  | `grep` / `glob`  |
 
-The `detail` is read by field, never by tool name — `command`, then
-`file_path` / `path`, then `pattern` / `url` / `query` — which is what makes one
+The `detail` is read by field, never by tool name — `command` / `CommandLine`,
+then `file_path` / `path` / `TargetFile`, then `url` / `query` / `Query` — one
+chain over both spellings, which is what makes one
 rule cover both: a Codex shell call arrives as `Bash` carrying the same
 `command` string Claude Code sends. opencode spells the same fields in camel
 case (`filePath`) and hands over paths already relative to the session, so
diff --git a/docs/session-title.md b/docs/session-title.md
index 11529ad..0577037 100644
--- a/docs/session-title.md
+++ b/docs/session-title.md
@@ -8,12 +8,12 @@ Reports the title the agent CLI gives its own session, so lich can name the
 session card after it. lich only applies it while the card's label is still
 automatic, so re-sending on every `Stop` is idempotent.
 
-| script            | action                    | Claude Code hook | Codex hook | opencode event    | omp event                    | Crush hook |
-|-------------------|---------------------------|------------------|------------|-------------------|------------------------------|------------|
-| `report-title.sh` | send the session's title  | `Stop`           | `Stop`     | `session.updated` | `session_stop`, `turn_start` | —          |
+| script            | action                    | Claude Code hook | Codex hook | Antigravity hook | opencode event    | omp event                    | Crush hook |
+|-------------------|---------------------------|------------------|------------|------------------|-------------------|------------------------------|------------|
+| `report-title.sh` | send the session's title  | `Stop`           | `Stop`     | `Stop`           | `session.updated` | `session_stop`, `turn_start` | —          |
 
 `POST /session-title` with `{"session_id": $LICH_SESSION_ID, "title": <title>}`.
-Both providers keep the title in the transcript file (`transcript_path` on
+Providers keep the title in the transcript file (`transcript_path` or `transcriptPath` on
 stdin), in their own shape — the script reads whichever is there:
 
 - **Claude Code** — the last line matching `"type":"ai-title"`, field
@@ -22,8 +22,10 @@ stdin), in their own shape — the script reads whichever is there:
   line, cut to 80 characters. Codex generates no title: it names a thread after
   its first user message verbatim (`threads.title` in its state database), so
   this reports the same label Codex shows, only trimmed to card size.
+- **Antigravity** — the first `USER_INPUT` entry's `content` text (unwrapping
+  `<USER_REQUEST>` block tags), trimmed to 80 characters.
 
-Both formats are internal and undocumented — extraction failures are swallowed
+All formats are internal and undocumented — extraction failures are swallowed
 and the hook no-ops. Requires `jq`; absent → no-op.
 
 - **opencode** — no transcript to read: `session.updated` carries the whole
diff --git a/docs/session-touched.md b/docs/session-touched.md
index a40e719..2d93d08 100644
--- a/docs/session-touched.md
+++ b/docs/session-touched.md
@@ -9,9 +9,9 @@ session's git status immediately instead of waiting for its ~3s poll. Latency
 optimization only — without the plugin the poll catches the same changes, up
 to a poll interval later.
 
-| script              | Claude Code hook                                        | Codex hook                                              | Crush hook                                             | opencode event | omp event                                        |
-|---------------------|---------------------------------------------------------|---------------------------------------------------------|--------------------------------------------------------|----------------|--------------------------------------------------|
-| `report-touched.sh` | `PostToolUse` matcher `Edit\|Write\|NotebookEdit\|Bash`  | `PostToolUse` matcher `apply_patch\|Edit\|Write\|Bash`  | `PreToolUse` matcher `^(edit\|write\|multiedit\|bash)$` | `file.edited`  | `tool_result` for `write`/`edit`/`bash`/`notebook` |
+| script              | Claude Code hook                                        | Codex hook                                              | Antigravity hook                                        | Crush hook                                             | opencode event | omp event                                        |
+|---------------------|---------------------------------------------------------|---------------------------------------------------------|---------------------------------------------------------|--------------------------------------------------------|----------------|--------------------------------------------------|
+| `report-touched.sh` | `PostToolUse` matcher `Edit\|Write\|NotebookEdit\|Bash`  | `PostToolUse` matcher `apply_patch\|Edit\|Write\|Bash`  | `PostToolUse` matcher `write_to_file\|replace_file_content\|run_command` | `PreToolUse` matcher `^(edit\|write\|multiedit\|bash)$` | `file.edited`  | `tool_result` for `write`/`edit`/`bash`/`notebook` |
 
 `POST /session-touched` with `{"session_id": $LICH_SESSION_ID}`.
 
diff --git a/hooks.json b/hooks.json
new file mode 100644
index 0000000..8be3809
--- /dev/null
+++ b/hooks.json
@@ -0,0 +1,52 @@
+{
+  "lich": {
+    "PreInvocation": [
+      {
+        "type": "command",
+        "command": "hooks/report-session-start.sh antigravity; printf '{}'",
+        "timeout": 5
+      },
+      {
+        "type": "command",
+        "command": "hooks/report-state.sh busy; printf '{}'",
+        "timeout": 5
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "hooks/report-tool.sh; printf '{\"decision\":\"allow\"}'",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "write_to_file|replace_file_content|run_command",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "hooks/report-touched.sh; printf '{}'",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "type": "command",
+        "command": "hooks/report-state.sh done; printf '{\"decision\":\"\"}'",
+        "timeout": 5
+      },
+      {
+        "type": "command",
+        "command": "hooks/report-title.sh; printf '{\"decision\":\"\"}'",
+        "timeout": 5
+      }
+    ]
+  }
+}
diff --git a/hooks/detail.jq b/hooks/detail.jq
index f2642d0..e9b74e8 100644
--- a/hooks/detail.jq
+++ b/hooks/detail.jq
@@ -16,16 +16,34 @@
 # with the part every card shares. Outside that directory only the file name is
 # left, which at least names the file. Commands are never shortened — a leading
 # slash there belongs to a binary, not to a path worth cutting.
-.cwd as $cwd
+#
+# Antigravity spells the same two things differently: the session's directory is
+# the first of `workspacePaths`, and the arguments are PascalCase under
+# `toolCall.args`. Field names only — they join the fallback chain below rather
+# than forking it, so a field a harness never sends is a rung it falls straight
+# through. Every one of these names was read off a payload from a real turn: the
+# step-type enum in the binary is *not* what arrives here (its `MCP_TOOL` is
+# `call_mcp_tool` on the wire), so it cannot be used to derive them.
+#
+# An MCP call is the one that needs a branch rather than a rung. Every server's
+# tools arrive as the single tool `call_mcp_tool`, so the name on the card says
+# nothing on its own; the server and the tool it called are arguments, and
+# together they are the readable half — lich's own tools would otherwise all
+# read alike.
+(.workspacePaths[0]? // .cwd) as $cwd
 | def short: if ($cwd // "") != "" and startswith($cwd + "/") then ltrimstr($cwd + "/")
              elif startswith("/") then sub(".*/"; "")
              else . end;
-  (.tool_input // {})
-| if ((.command? // "") | tostring) != "" then
-    (.command | tostring
+  (.toolCall.args // .tool_input // {})
+| if ((.ToolName? // "") | tostring) != "" then
+    ([.ServerName?, .ToolName?] | map(select(type == "string" and . != "")) | join("/"))
+  elif ((.CommandLine? // .command? // "") | tostring) != "" then
+    ((.CommandLine? // .command) | tostring
      | if startswith("*** Begin Patch")
        then ((capture("\\*\\*\\* (?:Add|Update|Delete) File: (?<p>[^\n]*)") // {}) | .p // "")
        else . end)
   else
-    ((.file_path? // .path? // .pattern? // .url? // .query? // "") | tostring | short)
+    ((.TargetFile? // .AbsolutePath? // .DirectoryPath?
+      // .file_path? // .path? // .pattern?
+      // .Url? // .url? // .Query? // .query? // "") | tostring | short)
   end
diff --git a/hooks/report-session-start.sh b/hooks/report-session-start.sh
index a5d10b0..07b6d99 100755
--- a/hooks/report-session-start.sh
+++ b/hooks/report-session-start.sh
@@ -9,9 +9,10 @@ provider=${1:-claude}
 # Parse session_id from the stdin payload. Prefer jq; fall back to sed so the
 # hook works on Windows, where jq is usually absent but sed (Git Bash) is not.
 if command -v jq >/dev/null 2>&1; then
-  provider_session_id=$(jq -r '.session_id // empty' 2>/dev/null)
+  provider_session_id=$(jq -r '.conversationId // .session_id // empty' 2>/dev/null)
 else
-  provider_session_id=$(sed -n 's/.*"session_id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p')
+  provider_session_id=$(sed -n -e 's/.*"conversationId"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' \
+                               -e 's/.*"session_id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -n 1)
 fi
 [ -n "$provider_session_id" ] || exit 0
 
diff --git a/hooks/report-state.sh b/hooks/report-state.sh
index 205fdac..00475e9 100755
--- a/hooks/report-state.sh
+++ b/hooks/report-state.sh
@@ -28,7 +28,7 @@ if [ "$state" = waiting ]; then
       # Codex's PermissionRequest has no message field at all, so its report is
       # the tool it is asking about, qualified with the words the busy report
       # already puts on the card.
-      tool=$(printf '%s' "$payload" | jq -r '.tool_name // empty' 2>/dev/null | head -n 1)
+      tool=$(printf '%s' "$payload" | jq -r '.toolCall.name // .tool_name // empty' 2>/dev/null | head -n 1)
       detail=$(printf '%s' "$payload" | \
         jq -r -f "$(dirname "$0")/detail.jq" 2>/dev/null | head -n 1)
       if [ -n "$tool" ]; then
diff --git a/hooks/report-title.sh b/hooks/report-title.sh
index f84a5bc..de5e6eb 100755
--- a/hooks/report-title.sh
+++ b/hooks/report-title.sh
@@ -7,7 +7,7 @@
 [ -n "$LICH_PORT" ] && [ -n "$LICH_TOKEN" ] && [ -n "$LICH_SESSION_ID" ] || exit 0
 command -v jq >/dev/null 2>&1 || exit 0
 
-transcript_path=$(jq -r '.transcript_path // empty' 2>/dev/null)
+transcript_path=$(jq -r '.transcriptPath // .transcript_path // empty' 2>/dev/null)
 [ -f "$transcript_path" ] || exit 0
 
 # Claude Code: ai-title is an internal transcript line; swallow extraction
@@ -24,6 +24,14 @@ if [ -z "$title" ]; then
     | head -n 1 | cut -c 1-80)
 fi
 
+# Antigravity: names a thread after its first USER_INPUT content.
+if [ -z "$title" ]; then
+  title=$(grep '"type":"USER_INPUT"' "$transcript_path" 2>/dev/null \
+    | head -n 1 | jq -r '.content // empty' 2>/dev/null \
+    | sed -e 's/<USER_REQUEST>//g' -e 's/<\/USER_REQUEST>//g' \
+    | sed -n '/[^[:space:]]/{p;q}' | cut -c 1-80)
+fi
+
 # lich rejects a blank title (400): a Codex first line can be nothing but
 # spaces, and an ai-title could in principle be padded. Trim before deciding
 # there is a title at all — command substitution above only ate the newlines.
diff --git a/hooks/report-tool.sh b/hooks/report-tool.sh
index 6c9cf0a..4e473d4 100755
--- a/hooks/report-tool.sh
+++ b/hooks/report-tool.sh
@@ -18,10 +18,11 @@ command -v jq >/dev/null 2>&1 && has_jq=1 || has_jq=
 # absent but sed (Git Bash) is not. A tool name is an identifier, so sed reading
 # it out of the raw payload is safe in a way arbitrary text would not be.
 if [ -n "$has_jq" ]; then
-  tool=$(printf '%s' "$payload" | jq -r '.tool_name // empty' 2>/dev/null)
+  tool=$(printf '%s' "$payload" | jq -r '.toolCall.name // .tool_name // empty' 2>/dev/null)
 else
   tool=$(printf '%s' "$payload" | \
-    sed -n 's/.*"tool_name"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p')
+    sed -n -e 's/.*"tool_name"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' \
+           -e 's/.*"toolCall"[[:space:]]*:[[:space:]]*{[^}]*"name"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -n 1)
 fi
 [ -n "$tool" ] || exit 0
 
diff --git a/plugin.json b/plugin.json
new file mode 100644
index 0000000..57f28f3
--- /dev/null
+++ b/plugin.json
@@ -0,0 +1,3 @@
+{
+  "name": "lich"
+}
diff --git a/tests/contract.mjs b/tests/contract.mjs
index 7a75607..ff7d6ab 100644
--- a/tests/contract.mjs
+++ b/tests/contract.mjs
@@ -49,6 +49,24 @@ export const rejected = (endpoint) => CASES[endpoint].filter((c) => c.reject)
 export const STATES = new Set(accepted('/hook').map((c) => c.accept.state))
 export const PROVIDERS = new Set(accepted('/session-start').map((c) => c.accept.provider))
 
+/**
+ * Providers this plugin already reports for, and lich does not accept yet.
+ *
+ * A contract moves in lich first — prose, then fixtures, then the endpoint —
+ * and only then here, so a client that lands ahead of its endpoint is declared
+ * here rather than smuggled in by editing a fixture. lich answers 400 to a
+ * provider it has not registered, so what this set really records is a report
+ * that does not arrive yet; the plugin side is still held to every other line.
+ *
+ * Emptying it is the last step of adding a provider, not an optional one: the
+ * suites fail the moment a refreshed fixture registers one, so the marker
+ * cannot outlive the gap it names. Antigravity was the first entry and is gone
+ * from it — lich registered the provider, `refresh-fixtures.sh` brought the
+ * fixture down, and the enumerations went back to coming from the fixtures
+ * alone. Empty is the resting state.
+ */
+export const PENDING_UPSTREAM = new Set([])
+
 export const isObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v)
 export const blank = (v) => typeof v !== 'string' || v.trim() === ''
 
@@ -72,7 +90,8 @@ export const REJECT_RULES = {
     'missing session_id': (b) => !('session_id' in b),
     'missing provider_session_id': (b) => !('provider_session_id' in b) && !('claude_session_id' in b),
     'empty provider_session_id': (b) => b.provider_session_id === '',
-    'unregistered provider': (b) => 'provider' in b && !PROVIDERS.has(b.provider),
+    'unregistered provider': (b) =>
+      'provider' in b && !PROVIDERS.has(b.provider) && !PENDING_UPSTREAM.has(b.provider),
     'malformed json': (b, raw) => !isJsonObject(raw),
   },
   '/session-title': {
diff --git a/tests/fixtures/session-start.jsonl b/tests/fixtures/session-start.jsonl
index eadbb30..3a104e7 100644
--- a/tests/fixtures/session-start.jsonl
+++ b/tests/fixtures/session-start.jsonl
@@ -1,4 +1,5 @@
 {"name":"reported provider","body":{"session_id":"s1","provider_session_id":"018f9c5a-0000-7000-9a3b-1c2d3e4f5c01","provider":"codex"},"accept":{"session_id":"s1","provider_session_id":"018f9c5a-0000-7000-9a3b-1c2d3e4f5c01","provider":"codex"}}
+{"name":"antigravity conversation id","body":{"session_id":"s1","provider_session_id":"7bb32ee5-e8e3-42cd-a13c-849723bc4e57","provider":"antigravity"},"accept":{"session_id":"s1","provider_session_id":"7bb32ee5-e8e3-42cd-a13c-849723bc4e57","provider":"antigravity"}}
 {"name":"opencode session id","body":{"session_id":"s1","provider_session_id":"ses_011856954ffe5NEMhsYeTuWykR","provider":"opencode"},"accept":{"session_id":"s1","provider_session_id":"ses_011856954ffe5NEMhsYeTuWykR","provider":"opencode"}}
 {"name":"omp session id","body":{"session_id":"s1","provider_session_id":"019ffb38-ceab-7000-afae-20b8eae145d8","provider":"omp"},"accept":{"session_id":"s1","provider_session_id":"019ffb38-ceab-7000-afae-20b8eae145d8","provider":"omp"}}
 {"name":"crush session id","body":{"session_id":"s1","provider_session_id":"db3492a0-4a6b-4335-8c0b-d4cc43fc4cb0","provider":"crush"},"accept":{"session_id":"s1","provider_session_id":"db3492a0-4a6b-4335-8c0b-d4cc43fc4cb0","provider":"crush"}}
diff --git a/tests/hooks.test.mjs b/tests/hooks.test.mjs
index ef1e716..9667811 100644
--- a/tests/hooks.test.mjs
+++ b/tests/hooks.test.mjs
@@ -18,6 +18,7 @@ import {
   CASES,
   LICH_SESSION_ID,
   PROVIDERS,
+  PENDING_UPSTREAM,
   ROOT,
   REJECT_RULES,
   STATES,
@@ -36,12 +37,20 @@ const BASE_ENV = Object.fromEntries(
 
 /**
  * Runs a hook exactly as its registration spells it: the command string from
- * hooks.json / codex-hooks.json, through a shell, with $CLAUDE_PLUGIN_ROOT set.
+ * the harness's own hook file, through a shell.
+ *
+ * `pluginRoot` is what the harness gives the command to find the scripts with.
+ * Claude Code, Codex and Crush get $CLAUDE_PLUGIN_ROOT. Antigravity expands no
+ * such variable — it runs the command with the working directory set to the
+ * folder holding hooks.json — so it is run here with the variable unset, which
+ * is the regression test for a registration that reaches for it anyway: the
+ * command resolves to /hooks/<script> and exits 127.
  */
-function runHook(command, { env = {}, stdin = '' } = {}) {
+function runHook(command, { env = {}, stdin = '', pluginRoot = true } = {}) {
   return new Promise((resolve) => {
     const child = spawn('/bin/sh', ['-c', command], {
-      env: { ...BASE_ENV, CLAUDE_PLUGIN_ROOT: ROOT, ...env },
+      cwd: ROOT,
+      env: { ...BASE_ENV, ...(pluginRoot ? { CLAUDE_PLUGIN_ROOT: ROOT } : {}), ...env },
       stdio: ['pipe', 'pipe', 'pipe'],
     })
     let stdout = ''
@@ -58,12 +67,18 @@ function runHook(command, { env = {}, stdin = '' } = {}) {
   })
 }
 
-// A hook that reports never speaks on stdout: on Codex the session-state hook
-// rides PermissionRequest, where output and a non-zero exit are an answer to
-// the request rather than an observation.
-function assertSilentSuccess(result) {
+// A hook script never speaks on stdout: on Codex the session-state hook rides
+// PermissionRequest, where output and a non-zero exit are an answer to the
+// request rather than an observation.
+//
+// Antigravity is the harness that needs one anyway — it reads a JSON object off
+// stdout and acts on it, and a PreToolUse handler that says nothing leaves the
+// tool call without the `decision` its contract makes required. So the verdict
+// is appended by the registration, not printed by the shared script, and what
+// arrives on stdout is exactly that verdict and nothing the script added.
+function assertHookSucceeded(result, stdout = '') {
   assert.equal(result.code, 0, `exited ${result.code}: ${result.stderr}`)
-  assert.equal(result.stdout, '', `wrote to stdout: ${result.stdout}`)
+  assert.equal(result.stdout, stdout, `stdout was ${JSON.stringify(result.stdout)}`)
 }
 
 // ------------------------------------------------------------ registrations --
@@ -72,6 +87,10 @@ const HOOK_FILES = [
   { provider: 'claude', file: 'hooks/hooks.json' },
   { provider: 'codex', file: 'hooks/codex-hooks.json' },
   { provider: 'crush', file: 'hooks/crush-hooks.json' },
+  // Antigravity fixes both the name and the place: a plugin's hooks are read
+  // from `hooks.json` beside its `plugin.json`, so this one alone sits at the
+  // plugin root rather than in hooks/ (docs/providers.md).
+  { provider: 'antigravity', file: 'hooks.json', pluginRoot: false },
 ]
 
 // Crush has no plugin root to expand, so its registration ships the clone's
@@ -87,41 +106,70 @@ const SCRIPTS = {
 }
 
 /**
- * What each harness registers. Claude Code and Codex carry every report; Crush
- * carries the two its single `PreToolUse` event can honour, because a `busy`
- * nothing can end would pin a spinner to a card (docs/providers.md).
+ * What each harness registers. Claude Code, Codex and Antigravity carry every
+ * report; Crush carries the two its single `PreToolUse` event can honour,
+ * because a `busy` nothing can end would pin a spinner to a card
+ * (docs/providers.md).
  */
 const REGISTERED_SCRIPTS = {
   claude: Object.keys(SCRIPTS),
   codex: Object.keys(SCRIPTS),
   crush: ['report-session-start.sh', 'report-touched.sh'],
+  antigravity: Object.keys(SCRIPTS),
 }
 
 /**
  * A registration group is either Claude Code's shape (a matcher wrapping a
- * `hooks` array) or Crush's (the hook itself, matcher included).
+ * `hooks` array) or Crush's (the hook itself, matcher included). Antigravity
+ * uses both, one per event: `PreToolUse`/`PostToolUse` are grouped behind a
+ * matcher, `PreInvocation`/`Stop` are flat lists of handlers.
  */
 const hooksIn = (group) => (Array.isArray(group.hooks) ? group.hooks : [group])
 
+/**
+ * Every hook file maps events to handlers; only the key it hangs that map on
+ * differs. Claude Code, Codex and Crush use `hooks`; an Antigravity file is
+ * keyed by hook *name* instead, so several integrations can merge into one
+ * file — lich's is `lich`.
+ */
+const eventsIn = (json) => json.hooks ?? json.lich
+
+/**
+ * Antigravity reads a JSON object off the hook's stdout and acts on it, so its
+ * registration appends the verdict the event's contract asks for. Split back
+ * off here, so every assertion below stays about the report the script sent.
+ */
+function splitVerdict(command) {
+  const m = command.match(/;\s*printf\s+'(.*)'\s*$/)
+  return m
+    ? { report: command.slice(0, m.index), stdout: m[1] }
+    : { report: command, stdout: '' }
+}
+
 function registrations() {
   const out = []
-  for (const { provider, file } of HOOK_FILES) {
+  for (const { provider, file, pluginRoot = true } of HOOK_FILES) {
     const json = JSON.parse(readFileSync(path.join(ROOT, file), 'utf8'))
-    for (const [event, groups] of Object.entries(json.hooks)) {
+    const events = eventsIn(json)
+    assert.ok(events, `${file} hangs its events on no key this suite knows`)
+    for (const [event, groups] of Object.entries(events)) {
       for (const group of groups) {
         for (const hook of hooksIn(group)) {
           const script = Object.keys(SCRIPTS).find((s) => hook.command.includes(s))
           assert.ok(script, `unknown script in ${file}: ${hook.command}`)
           const command = hook.command.split(PLUGIN_ROOT_PLACEHOLDER).join(ROOT)
+          const { report, stdout } = splitVerdict(command)
           out.push({
             provider,
             file,
             event,
             matcher: group.matcher,
             command,
+            pluginRoot,
+            stdout,
             script,
             endpoint: SCRIPTS[script],
-            argument: command.trim().split(/\s+/).slice(1).join(' '),
+            argument: report.trim().split(/\s+/).slice(1).join(' '),
           })
         }
       }
@@ -167,6 +215,23 @@ function codexTranscript(message, name = 'codex.jsonl') {
   return file
 }
 
+/** Antigravity names a thread after its first USER_INPUT content. */
+function antigravityTranscript(content, name = 'antigravity.jsonl') {
+  const file = path.join(TMP, name)
+  const lines = [
+    JSON.stringify({
+      step_index: 0,
+      source: 'USER_EXPLICIT',
+      type: 'USER_INPUT',
+      status: 'DONE',
+      created_at: '2026-08-23T22:05:42Z',
+      content: content === null ? '' : `<USER_REQUEST>\n${content}\n</USER_REQUEST>`,
+    }),
+  ]
+  writeFileSync(file, lines.join('\n') + '\n')
+  return file
+}
+
 /**
  * A PATH holding every tool the hooks use except the named one — for the
  * fallbacks a script keeps for machines where a tool is absent.
@@ -192,12 +257,14 @@ const PROVIDER_SESSION_ID = {
   codex: '018f9c5a-0000-7000-9a3b-1c2d3e4f5c01',
   crush: 'db3492a0-4a6b-4335-8c0b-d4cc43fc4cb0',
   opencode: 'ses_011856954ffe5NEMhsYeTuWykR',
+  antigravity: 'a1604c72-3091-449e-a60b-27da041f8ca2',
 }
 
 // Crush has no transcript to point a hook at: its payload is about the tool.
 const TRANSCRIPT = {
   claude: claudeTranscript('Fix the replay ring overflow'),
   codex: codexTranscript('Fix the replay ring overflow\nand its second line'),
+  antigravity: antigravityTranscript('Fix the replay ring overflow\nand its second line'),
 }
 
 /**
@@ -211,6 +278,7 @@ const TOOL_CALL = {
   claude: { tool_name: 'Bash', tool_input: { command: 'pnpm test', description: 'run the suite' } },
   codex: { tool_name: 'Bash', tool_input: { command: 'go test ./...' } },
   crush: { tool_name: 'write', tool_input: { file_path: 'probe.txt', content: 'ok\n' } },
+  antigravity: { toolCall: { name: 'run_command', args: { CommandLine: 'pnpm test' } } },
 }
 
 /** The event each harness raises a `waiting` report from. */
@@ -258,6 +326,14 @@ function stdinFor({ provider, event }) {
       ...(event === 'PreToolUse' ? TOOL_CALL.crush : {}),
     })
   }
+  if (provider === 'antigravity') {
+    return JSON.stringify({
+      conversationId: PROVIDER_SESSION_ID.antigravity,
+      transcriptPath: TRANSCRIPT.antigravity,
+      workspacePaths: [ROOT],
+      ...(event === 'PreToolUse' ? TOOL_CALL.antigravity : {}),
+    })
+  }
   return JSON.stringify({
     session_id: PROVIDER_SESSION_ID[provider],
     transcript_path: TRANSCRIPT[provider],
@@ -292,7 +368,10 @@ test('the vendored fixtures parse and carry exactly one body and one verdict', (
     }
   }
   assert.deepEqual([...STATES].sort(), ['busy', 'done', 'idle', 'waiting'])
-  assert.deepEqual([...PROVIDERS].sort(), ['claude', 'codex', 'crush', 'omp', 'opencode'])
+  assert.deepEqual(
+    [...PROVIDERS].sort(),
+    ['antigravity', 'claude', 'codex', 'crush', 'omp', 'opencode'],
+  )
 })
 
 test('every rejected case is modelled by a client-side rule', () => {
@@ -350,13 +429,67 @@ test("Codex's registration runs every hook through the wrapper on Windows", () =
   }
 })
 
+// Antigravity expands no plugin-root variable of any kind. It runs the command
+// through `sh -c` with the working directory set to the folder holding
+// hooks.json — which, for a plugin, is the plugin root — so the paths are
+// relative to that and nothing else. A ${CLAUDE_PLUGIN_ROOT} borrowed from the
+// Claude Code registration expands to nothing there and every hook exits 127
+// on a path that starts at the filesystem root.
+test("Antigravity's registration reaches for no plugin root", () => {
+  const raw = readFileSync(path.join(ROOT, 'hooks.json'), 'utf8')
+  assert.ok(
+    !/PLUGIN_ROOT/.test(raw),
+    'hooks.json must not name a plugin-root variable: Antigravity sets none',
+  )
+  for (const r of REGISTRATIONS.filter((r) => r.provider === 'antigravity')) {
+    assert.match(
+      r.command,
+      /^hooks\/[a-z-]+\.sh\b/,
+      `command must be relative to the plugin root: ${r.command}`,
+    )
+  }
+})
+
+// Antigravity reads a JSON object off the hook's stdout and acts on it, so
+// silence is not the neutral answer it is everywhere else: `decision` is
+// required on PreToolUse, and an unanswered tool call is a turn this plugin
+// interfered with. The shared scripts stay silent — Codex reads their stdout as
+// an answer to a permission request — so the verdict belongs to the
+// registration, and every handler carries one.
+const ANTIGRAVITY_VERDICT = {
+  // Let the tool run: this is an observation, never a gate.
+  PreToolUse: '{"decision":"allow"}',
+  // Anything other than "continue" lets the loop end, and a card must be able
+  // to reach `done`.
+  Stop: '{"decision":""}',
+  PostToolUse: '{}',
+  PreInvocation: '{}',
+}
+
+test("Antigravity's registration answers every event with its verdict", () => {
+  const registered = REGISTRATIONS.filter((r) => r.provider === 'antigravity')
+  assert.ok(registered.length > 0)
+  for (const r of registered) {
+    assert.equal(
+      r.stdout,
+      ANTIGRAVITY_VERDICT[r.event],
+      `${r.event} hook answers ${JSON.stringify(r.stdout)}`,
+    )
+  }
+})
+
 test('every registered state argument is an accepted state', () => {
   const sent = REGISTRATIONS.filter((r) => r.script === 'report-state.sh').map((r) => r.argument)
   assert.ok(sent.length > 0)
   for (const state of sent) assert.ok(STATES.has(state), `registration reports unknown state "${state}"`)
   // A harness that reports state at all wires up the whole vocabulary; Codex's
-  // SessionEnd never fires today, but the entry is deliberate. Crush reports no
-  // state at all — see docs/providers.md for both.
+  // SessionEnd never fires today, but the entry is deliberate. Antigravity reports
+  // busy and done. Crush reports no state at all — see docs/providers.md for all three.
+  const EXPECTED_STATES = {
+    claude: STATES,
+    codex: STATES,
+    antigravity: new Set(['busy', 'done']),
+  }
   for (const [provider, scripts] of Object.entries(REGISTERED_SCRIPTS)) {
     if (!scripts.includes('report-state.sh')) continue
     const states = new Set(
@@ -364,17 +497,34 @@ test('every registered state argument is an accepted state', () => {
         (r) => r.argument,
       ),
     )
-    assert.deepEqual([...states].sort(), [...STATES].sort(), `${provider} misses a state`)
+    assert.deepEqual(
+      [...states].sort(),
+      [...(EXPECTED_STATES[provider] ?? STATES)].sort(),
+      `${provider} misses a state`,
+    )
   }
 })
 
 test('every registered provider argument is a registered provider', () => {
   for (const r of REGISTRATIONS.filter((r) => r.script === 'report-session-start.sh')) {
-    assert.ok(PROVIDERS.has(r.argument), `registration reports unknown provider "${r.argument}"`)
+    assert.ok(
+      PROVIDERS.has(r.argument) || PENDING_UPSTREAM.has(r.argument),
+      `registration reports unknown provider "${r.argument}"`,
+    )
     assert.equal(r.argument, r.provider, `${r.file} reports the wrong provider`)
   }
 })
 
+test('the pending set is still pending upstream', () => {
+  for (const provider of PENDING_UPSTREAM) {
+    assert.ok(
+      !PROVIDERS.has(provider),
+      `lich registers "${provider}" now — drop it from PENDING_UPSTREAM and let the ` +
+        `fixtures enumerate it like every other provider`,
+    )
+  }
+})
+
 // 1-4: shape, endpoint, token, no deprecated alias — for every script, as each
 // harness registers it.
 for (const registration of REGISTRATIONS) {
@@ -389,7 +539,7 @@ for (const registration of REGISTRATIONS) {
         env: lichEnv(stub.port),
         stdin: stdinFor(registration),
       })
-      assertSilentSuccess(result)
+      assertHookSucceeded(result, registration.stdout ?? '')
       assert.equal(stub.requests.length, 1, `sent ${stub.requests.length} requests, expected 1`)
 
       const { body } = assertContractHonoured(endpoint, stub.requests[0])
@@ -403,7 +553,7 @@ for (const registration of REGISTRATIONS) {
       }
       if (script === 'report-tool.sh') {
         assert.equal(body.state, 'busy')
-        assert.equal(body.tool, TOOL_CALL[provider].tool_name)
+        assert.equal(body.tool, TOOL_CALL[provider].tool_name ?? TOOL_CALL[provider].toolCall?.name)
       }
       if (script === 'report-session-start.sh') {
         assert.equal(body.provider, provider)
@@ -420,7 +570,7 @@ test('session-start falls back to claude when the registration passes no provide
       env: lichEnv(stub.port),
       stdin: stdinFor({ provider: 'claude', event: 'SessionStart' }),
     })
-    assertSilentSuccess(result)
+    assertHookSucceeded(result)
     const { body } = assertContractHonoured('/session-start', stub.requests[0])
     assert.equal(body.provider, 'claude')
   })
@@ -442,7 +592,7 @@ for (const [label, payload] of NO_REASON) {
         env: lichEnv(stub.port),
         stdin: JSON.stringify({ cwd: ROOT, ...payload }),
       })
-      assertSilentSuccess(result)
+      assertHookSucceeded(result)
       assert.equal(stub.requests.length, 1, 'a reason it could not build cost the report')
       const { body } = assertContractHonoured('/hook', stub.requests[0])
       assert.equal(body.state, 'waiting')
@@ -460,7 +610,7 @@ test('waiting reports the tool name as its reason without jq', async () => {
       env: { ...lichEnv(stub.port), PATH: binWithout('jq') },
       stdin: stdinFor({ provider: 'codex', event: 'PermissionRequest' }),
     })
-    assertSilentSuccess(result)
+    assertHookSucceeded(result)
     const { body } = assertContractHonoured('/hook', stub.requests[0])
     assert.equal(body.reason, TOOL_CALL.codex.tool_name)
   })
@@ -472,7 +622,7 @@ test('waiting sends no message-shaped reason without jq', async () => {
       env: { ...lichEnv(stub.port), PATH: binWithout('jq') },
       stdin: stdinFor({ provider: 'claude', event: 'Notification' }),
     })
-    assertSilentSuccess(result)
+    assertHookSucceeded(result)
     const { body } = assertContractHonoured('/hook', stub.requests[0])
     assert.equal(body.state, 'waiting')
     assert.ok(!('reason' in body), `escaped nothing and sent it anyway: ${stub.requests[0].raw}`)
@@ -506,7 +656,7 @@ test('session-start parses the payload without jq', async () => {
       env: { ...lichEnv(stub.port), PATH: binWithout('jq') },
       stdin: stdinFor({ provider: 'claude', event: 'SessionStart' }),
     })
-    assertSilentSuccess(result)
+    assertHookSucceeded(result)
     assert.equal(stub.requests.length, 1)
     const { body } = assertContractHonoured('/session-start', stub.requests[0])
     assert.equal(body.provider_session_id, PROVIDER_SESSION_ID.claude)
@@ -519,7 +669,7 @@ test('session-start no-ops when the payload carries no session id', async () =>
       env: lichEnv(stub.port),
       stdin: JSON.stringify({ transcript_path: TRANSCRIPT.codex }),
     })
-    assertSilentSuccess(result)
+    assertHookSucceeded(result)
     assert.equal(stub.requests.length, 0, 'sent a report with no provider session id')
   })
 })
@@ -533,6 +683,8 @@ const NO_TITLE = [
   ['codex rollout without a user message', () => codexTranscript(null, 'no-message.jsonl')],
   ['codex first line that is whitespace', () => codexTranscript('   \nreal work', 'blank-line.jsonl')],
   ['codex message that is a newline', () => codexTranscript('\nreal work', 'leading-nl.jsonl')],
+  ['antigravity transcript without user input', () => antigravityTranscript(null, 'no-user-input.jsonl')],
+  ['antigravity user input that is whitespace', () => antigravityTranscript('   ', 'blank-user-input.jsonl')],
 ]
 
 for (const [label, make] of NO_TITLE) {
@@ -542,7 +694,7 @@ for (const [label, make] of NO_TITLE) {
         env: lichEnv(stub.port),
         stdin: JSON.stringify({ session_id: 's', transcript_path: make() }),
       })
-      assertSilentSuccess(result)
+      assertHookSucceeded(result)
       assert.equal(
         stub.requests.length,
         0,
@@ -559,7 +711,7 @@ test('session-title trims the title it reports', async () => {
       env: lichEnv(stub.port),
       stdin: JSON.stringify({ session_id: 's', transcript_path: file }),
     })
-    assertSilentSuccess(result)
+    assertHookSucceeded(result)
     const { body } = assertContractHonoured('/session-title', stub.requests[0])
     assert.equal(body.title, 'Fix the replay ring overflow')
   })
@@ -572,7 +724,7 @@ test('session-title escapes a title that would break the JSON body', async () =>
       env: lichEnv(stub.port),
       stdin: JSON.stringify({ session_id: 's', transcript_path: file }),
     })
-    assertSilentSuccess(result)
+    assertHookSucceeded(result)
     const { body } = assertContractHonoured('/session-title', stub.requests[0])
     assert.equal(body.title, 'Fix "quoted" \\ and \ttabbed')
   })
@@ -584,7 +736,7 @@ test('session-title no-ops when the transcript is missing', async () => {
       env: lichEnv(stub.port),
       stdin: JSON.stringify({ session_id: 's', transcript_path: path.join(TMP, 'absent.jsonl') }),
     })
-    assertSilentSuccess(result)
+    assertHookSucceeded(result)
     assert.equal(stub.requests.length, 0)
   })
 })
@@ -598,7 +750,7 @@ async function runToolHook(payload, { env = {} } = {}) {
       env: { ...lichEnv(stub.port), ...env },
       stdin: JSON.stringify({ session_id: 's', hook_event_name: 'PreToolUse', ...payload }),
     })
-    assertSilentSuccess(result)
+    assertHookSucceeded(result)
     return { requests: stub.requests }
   })
 }
@@ -667,6 +819,53 @@ const DETAILS = [
     { tool_name: 'WebFetch', tool_input: { url: 'https://example.com/a' } },
     'https://example.com/a',
   ],
+  [
+    'an antigravity run_command',
+    { toolCall: { name: 'run_command', args: { CommandLine: 'pnpm test' } } },
+    'pnpm test',
+  ],
+  [
+    'an antigravity write_to_file',
+    {
+      workspacePaths: ['/w'],
+      toolCall: {
+        name: 'write_to_file',
+        args: { TargetFile: '/w/internal/terminal/usage.go', CodeContent: 'package terminal' },
+      },
+    },
+    'internal/terminal/usage.go',
+  ],
+  [
+    'an antigravity view_file outside workspace',
+    {
+      workspacePaths: ['/w'],
+      toolCall: { name: 'view_file', args: { AbsolutePath: '/etc/hosts' } },
+    },
+    'hosts',
+  ],
+  [
+    'an antigravity grep_search',
+    { toolCall: { name: 'grep_search', args: { Query: 'statusEvent' } } },
+    'statusEvent',
+  ],
+  // Every MCP server's tools reach a hook as the one tool `call_mcp_tool`, so
+  // the detail is the only thing telling two of them apart — including lich's
+  // own, which is what a card is most likely to be showing.
+  [
+    'an antigravity MCP call',
+    {
+      toolCall: {
+        name: 'call_mcp_tool',
+        args: { ServerName: 'lich', ToolName: 'open_session', Arguments: {} },
+      },
+    },
+    'lich/open_session',
+  ],
+  [
+    'an antigravity read_url_content',
+    { toolCall: { name: 'read_url_content', args: { Url: 'https://example.com/a' } } },
+    'https://example.com/a',
+  ],
 ]
 
 for (const [label, payload, want] of DETAILS) {
@@ -674,7 +873,7 @@ for (const [label, payload, want] of DETAILS) {
     const { requests } = await runToolHook(payload)
     const { body } = assertContractHonoured('/hook', requests[0])
     assert.equal(body.state, 'busy')
-    assert.equal(body.tool, payload.tool_name)
+    assert.equal(body.tool, payload.tool_name ?? payload.toolCall?.name)
     assert.equal(body.detail, want)
   })
 }
@@ -751,7 +950,7 @@ for (const { script, argument, event } of EVERY_SCRIPT) {
           env: { ...env, ...(('LICH_PORT' in env) ? { LICH_PORT: String(stub.port) } : {}) },
           stdin: stdinFor({ provider: 'claude', event }),
         })
-        assertSilentSuccess(result)
+        assertHookSucceeded(result)
         assert.equal(stub.requests.length, 0, 'reported without a full lich environment')
       })
     })
@@ -764,7 +963,7 @@ for (const { script, argument, event } of EVERY_SCRIPT) {
           env: lichEnv(stub.port),
           stdin: stdinFor({ provider: 'claude', event }),
         })
-        assertSilentSuccess(result)
+        assertHookSucceeded(result)
         assert.equal(stub.requests.length, 1)
       },
       { status: 500 },
@@ -779,6 +978,6 @@ for (const { script, argument, event } of EVERY_SCRIPT) {
       env: lichEnv(port),
       stdin: stdinFor({ provider: 'claude', event }),
     })
-    assertSilentSuccess(result)
+    assertHookSucceeded(result)
   })
 }