From ea4cbed3399dada2510520f3603ff73fd5c78dad Mon Sep 17 00:00:00 2001
From: omartelo <meopedevts@proton.me>
Date: Sun, 23 Aug 2026 19:53:19 -0300
Subject: [PATCH 1/4] feat: report Antigravity CLI sessions to lich

---
 CHANGELOG.md                       |  8 +++
 README.md                          | 24 ++++++--
 docs/providers.md                  | 42 +++++++++-----
 docs/session-start.md              | 10 ++--
 docs/session-state.md              | 28 ++++-----
 docs/session-title.md              | 12 ++--
 docs/session-touched.md            |  6 +-
 hooks/antigravity-hooks.json       | 52 +++++++++++++++++
 hooks/detail.jq                    | 11 ++--
 hooks/report-session-start.sh      |  5 +-
 hooks/report-state.sh              |  2 +-
 hooks/report-title.sh              | 10 +++-
 hooks/report-tool.sh               |  5 +-
 tests/fixtures/session-start.jsonl |  1 +
 tests/hooks.test.mjs               | 92 +++++++++++++++++++++++++++---
 15 files changed, 242 insertions(+), 66 deletions(-)
 create mode 100644 hooks/antigravity-hooks.json

diff --git a/CHANGELOG.md b/CHANGELOG.md
index cb093f1..529a1a5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **Antigravity CLI sessions report to lich.** A sixth harness: Antigravity CLI
+  supports native lifecycle hooks (`hooks/antigravity-hooks.json`), progressive
+  skills, and plugins. It reports session start (`PreInvocation`), session state
+  (`busy` on `PreInvocation`, `done` on `Stop`), tool executions (`PreToolUse` with
+  tool details extracted from `toolCall.name` and `toolCall.args`), git-status
+  refresh (`PostToolUse`), and session title from the first `USER_INPUT` prompt
+  in `transcriptPath`.
+
 - **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/README.md b/README.md
index f6ad3d8..cf52f3c 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
 
@@ -30,6 +30,7 @@ It also ships skills for the parts of lich you configure from inside a session:
 .agents/plugins/marketplace.json  # marketplace, Codex
 hooks/hooks.json                  # hook registration, Claude Code
 hooks/codex-hooks.json            # hook registration, Codex
+hooks/antigravity-hooks.json      # hook registration, Antigravity CLI
 hooks/crush-hooks.json            # hook registration, Crush (merged into crush.json by hand)
 hooks/report-state.sh             # session-state hook
 hooks/report-tool.sh              # session-state hook: the tool a turn is running
@@ -43,7 +44,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/` 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.
 
 ## Installation
 
@@ -67,6 +68,17 @@ 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
+
+Link or copy the clone into Antigravity's plugin directory:
+
+```bash
+mkdir -p ~/.gemini/config/plugins/lich
+cp -r . ~/.gemini/config/plugins/lich/
+```
+
+Or merge [`hooks/antigravity-hooks.json`](hooks/antigravity-hooks.json) into `~/.gemini/config/hooks.json` (global) or `.agents/hooks.json` (per project).
+
 ### 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..c0f3756 100644
--- a/docs/providers.md
+++ b/docs/providers.md
@@ -16,8 +16,9 @@ This repository is one plugin, packaged for each harness it supports:
 | `.agents/plugins/marketplace.json` | Codex    | marketplace, points at `./`   |
 | `hooks/hooks.json`              | Claude Code | hook registration             |
 | `hooks/codex-hooks.json`        | Codex       | hook registration             |
+| `hooks/antigravity-hooks.json`  | Antigravity | hook registration             |
 | `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 |
@@ -25,9 +26,9 @@ This repository is one plugin, packaged for each harness it supports:
 
 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
+and Crush and Antigravity — expose the same things a report needs: the payload arrives as JSON
+on stdin with `session_id` / `conversationId` and `transcript_path` / `transcriptPath` (and `tool_name` /
+`toolCall` / `cwd` / `workspacePaths` 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.
 
@@ -44,16 +45,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,6 +233,19 @@ 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
+
+- **Hooks are defined in `hooks.json` (or `hooks/antigravity-hooks.json`).**
+  Antigravity CLI reads lifecycle hooks under named entries (such as `"lich"`).
+- **Payloads use camelCase.** `conversationId` is the session id, `workspacePaths`
+  contains the active workspace roots, and `transcriptPath` is the JSONL log.
+- **Tools are reported via `toolCall.name`.** Tool arguments arrive under
+  `toolCall.args` with PascalCase fields (`CommandLine`, `TargetFile`, `AbsolutePath`, etc.).
+- **Session title is read from the first `USER_INPUT` entry in `transcriptPath`.**
+- **Lifecycle mapping**: `PreInvocation` reports `session-start` and `busy`; `PreToolUse`
+  reports `busy` with the tool name; `PostToolUse` with write matchers (`write_to_file|replace_file_content|run_command`)
+  reports `touched`; `Stop` reports `done` and `session-title`.
+
 ## Adding a provider
 
 1. Confirm the harness exposes the session lifecycle to something it will run or
diff --git a/docs/session-start.md b/docs/session-start.md
index 606a986..4f16287 100644
--- a/docs/session-start.md
+++ b/docs/session-start.md
@@ -8,17 +8,17 @@ 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`, `antigravity-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..87ec72d 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,12 +130,12 @@ 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` / `find_by_name` | `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
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/antigravity-hooks.json b/hooks/antigravity-hooks.json
new file mode 100644
index 0000000..81bdbd4
--- /dev/null
+++ b/hooks/antigravity-hooks.json
@@ -0,0 +1,52 @@
+{
+  "lich": {
+    "PreInvocation": [
+      {
+        "type": "command",
+        "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/report-session-start.sh\" antigravity",
+        "timeout": 5
+      },
+      {
+        "type": "command",
+        "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/report-state.sh\" busy",
+        "timeout": 5
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/report-tool.sh\"",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "write_to_file|replace_file_content|run_command",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/report-touched.sh\"",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "type": "command",
+        "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/report-state.sh\" done",
+        "timeout": 5
+      },
+      {
+        "type": "command",
+        "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/report-title.sh\"",
+        "timeout": 5
+      }
+    ]
+  }
+}
diff --git a/hooks/detail.jq b/hooks/detail.jq
index f2642d0..9effe1a 100644
--- a/hooks/detail.jq
+++ b/hooks/detail.jq
@@ -16,16 +16,17 @@
 # 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
+.cwd as $legacy_cwd
+| (.workspacePaths[0] // $legacy_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 ((.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? // .SearchPath? // .file_path? // .path? // .Pattern? // .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/tests/fixtures/session-start.jsonl b/tests/fixtures/session-start.jsonl
index eadbb30..8aefefc 100644
--- a/tests/fixtures/session-start.jsonl
+++ b/tests/fixtures/session-start.jsonl
@@ -1,6 +1,7 @@
 {"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":"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":"antigravity session id","body":{"session_id":"s1","provider_session_id":"019ffb38-ceab-7000-afae-20b8eae145d9","provider":"antigravity"},"accept":{"session_id":"s1","provider_session_id":"019ffb38-ceab-7000-afae-20b8eae145d9","provider":"antigravity"}}
 {"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"}}
 {"name":"absent provider defaults to claude","body":{"session_id":"s1","provider_session_id":"018f9c5a-0000-7000-9a3b-1c2d3e4f5c01"},"accept":{"session_id":"s1","provider_session_id":"018f9c5a-0000-7000-9a3b-1c2d3e4f5c01","provider":"claude"}}
 {"name":"legacy claude_session_id is folded","body":{"session_id":"s1","claude_session_id":"018f9c5a-0000-7000-9a3b-1c2d3e4f5c02"},"accept":{"session_id":"s1","provider_session_id":"018f9c5a-0000-7000-9a3b-1c2d3e4f5c02","provider":"claude"}}
diff --git a/tests/hooks.test.mjs b/tests/hooks.test.mjs
index ef1e716..b2864f8 100644
--- a/tests/hooks.test.mjs
+++ b/tests/hooks.test.mjs
@@ -72,6 +72,7 @@ const HOOK_FILES = [
   { provider: 'claude', file: 'hooks/hooks.json' },
   { provider: 'codex', file: 'hooks/codex-hooks.json' },
   { provider: 'crush', file: 'hooks/crush-hooks.json' },
+  { provider: 'antigravity', file: 'hooks/antigravity-hooks.json' },
 ]
 
 // Crush has no plugin root to expand, so its registration ships the clone's
@@ -87,7 +88,7 @@ const SCRIPTS = {
 }
 
 /**
- * What each harness registers. Claude Code and Codex carry every report; Crush
+ * 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).
  */
@@ -95,6 +96,7 @@ const REGISTERED_SCRIPTS = {
   claude: Object.keys(SCRIPTS),
   codex: Object.keys(SCRIPTS),
   crush: ['report-session-start.sh', 'report-touched.sh'],
+  antigravity: Object.keys(SCRIPTS),
 }
 
 /**
@@ -107,7 +109,8 @@ function registrations() {
   const out = []
   for (const { provider, file } of HOOK_FILES) {
     const json = JSON.parse(readFileSync(path.join(ROOT, file), 'utf8'))
-    for (const [event, groups] of Object.entries(json.hooks)) {
+    const hooksMap = json.hooks ?? json.lich ?? Object.values(json)[0]
+    for (const [event, groups] of Object.entries(hooksMap)) {
       for (const group of groups) {
         for (const hook of hooksIn(group)) {
           const script = Object.keys(SCRIPTS).find((s) => hook.command.includes(s))
@@ -167,6 +170,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 +212,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 +233,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 +281,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 +323,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', () => {
@@ -355,8 +389,13 @@ test('every registered state argument is an accepted state', () => {
   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,7 +403,11 @@ 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`,
+    )
   }
 })
 
@@ -403,7 +446,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)
@@ -533,6 +576,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) {
@@ -667,6 +712,37 @@ 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' } },
+    },
+    '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',
+  ],
+  [
+    '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 +750,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)
   })
 }

From 4749d4c806594087317bbb4ca4585ccc76536217 Mon Sep 17 00:00:00 2001
From: omartelo <meopedevts@proton.me>
Date: Sun, 23 Aug 2026 20:23:28 -0300
Subject: [PATCH 2/4] fix: make the Antigravity plugin one Antigravity actually
 loads
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The registration was written against Claude Code's assumptions, so none of it
ran. Five things were wrong, each silent:

- `${CLAUDE_PLUGIN_ROOT}` — Antigravity sets no plugin-root variable. It runs a
  hook through `sh -c` with the working directory set to the folder holding
  hooks.json, so the paths are relative to that. Under the old registration
  every hook ran `/hooks/<script>` and exited 127, on every event.
- No manifest — an Antigravity plugin is `plugins/<name>/plugin.json` with its
  `hooks.json` and `skills/` beside it. Neither name is configurable, so
  `hooks/antigravity-hooks.json` was discovered by nothing. Both files move to
  the repository root, which is the plugin directory once the clone is linked
  in; `agy plugin validate .` went from "missing plugin.json" to loading one
  skill and one hook.
- No verdict on stdout — Antigravity reads a JSON object back and acts on it,
  and `decision` is required before a tool call. The registration now appends
  the answer each event asks for, so the shared scripts stay silent for Codex,
  where stdout answers a permission request.
- Tool names that do not exist — `write_to_file`, `replace_file_content` and
  `find_by_name` are Windsurf's. Antigravity's come from its step-type enum:
  `propose_code`, `file_change`, `edit_notebook`, `run_command`. The touched
  matcher had been naming tools it could never match. Same for three of
  detail.jq's argument fields.
- An edited fixture — the fixtures are lich's, and lich has not registered the
  provider, so `/session-start` answers 400. Reverted; `PENDING_UPSTREAM` in
  tests/contract.mjs names the gap, and fails once a refreshed fixture closes
  it. The shape assertions never needed the edit.

The suite could not catch the first of these because it exported
$CLAUDE_PLUGIN_ROOT for every harness. Registrations now run the way their own
harness runs them, and two guards cover the Antigravity-specific rules.
---
 CHANGELOG.md                               |  33 +++-
 CLAUDE.md                                  |  24 ++-
 README.md                                  |  15 +-
 docs/providers.md                          | 120 +++++++++++---
 docs/session-start.md                      |   3 +-
 docs/session-state.md                      |  19 ++-
 docs/session-touched.md                    |   2 +-
 hooks/antigravity-hooks.json => hooks.json |  16 +-
 hooks/detail.jq                            |  13 +-
 plugin.json                                |   3 +
 tests/contract.mjs                         |  18 +-
 tests/fixtures/session-start.jsonl         |   1 -
 tests/hooks.test.mjs                       | 182 ++++++++++++++++-----
 13 files changed, 348 insertions(+), 101 deletions(-)
 rename hooks/antigravity-hooks.json => hooks.json (53%)
 create mode 100644 plugin.json

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 529a1a5..3629376 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,13 +9,32 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- **Antigravity CLI sessions report to lich.** A sixth harness: Antigravity CLI
-  supports native lifecycle hooks (`hooks/antigravity-hooks.json`), progressive
-  skills, and plugins. It reports session start (`PreInvocation`), session state
-  (`busy` on `PreInvocation`, `done` on `Stop`), tool executions (`PreToolUse` with
-  tool details extracted from `toolCall.name` and `toolCall.args`), git-status
-  refresh (`PostToolUse`), and session title from the first `USER_INPUT` prompt
-  in `transcriptPath`.
+- **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.
+
+  lich does not register the provider yet, so `/session-start` answers 400 until
+  it does; `PENDING_UPSTREAM` in `tests/contract.mjs` names that gap rather than
+  a fixture being edited to hide 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
diff --git a/CLAUDE.md b/CLAUDE.md
index a3e591c..646096b 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,8 @@ 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. Take them from the harness itself (the CLI's own docs, its binary, a run against a stub) and never from what the name resembles on a harness you already support. Antigravity's write tools are `propose_code` and `file_change`, not the Windsurf-flavoured `write_to_file`; a matcher naming the latter matches nothing at all.
+- **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 +112,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 cf52f3c..9a64cf9 100644
--- a/README.md
+++ b/README.md
@@ -28,9 +28,10 @@ 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/antigravity-hooks.json      # hook registration, Antigravity CLI
 hooks/crush-hooks.json            # hook registration, Crush (merged into crush.json by hand)
 hooks/report-state.sh             # session-state hook
 hooks/report-tool.sh              # session-state hook: the tool a turn is running
@@ -44,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, Antigravity 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
 
@@ -70,14 +71,16 @@ Then start a new session and run `/hooks` to review and trust the plugin's hooks
 
 ### Antigravity CLI
 
-Link or copy the clone into Antigravity's plugin directory:
+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/lich
-cp -r . ~/.gemini/config/plugins/lich/
+mkdir -p ~/.gemini/config/plugins
+ln -s "$PWD" ~/.gemini/config/plugins/lich
 ```
 
-Or merge [`hooks/antigravity-hooks.json`](hooks/antigravity-hooks.json) into `~/.gemini/config/hooks.json` (global) or `.agents/hooks.json` (per project).
+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
 
diff --git a/docs/providers.md b/docs/providers.md
index c0f3756..9359ecc 100644
--- a/docs/providers.md
+++ b/docs/providers.md
@@ -14,9 +14,10 @@ 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/antigravity-hooks.json`  | Antigravity | 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 four    | the reports themselves        |
 | `hooks/win-run.cmd`             | Codex       | runs a script on Windows      |
@@ -24,13 +25,24 @@ This repository is one plugin, packaged for each harness it supports:
 | `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 and Antigravity — expose the same things a report needs: the payload arrives as JSON
-on stdin with `session_id` / `conversationId` and `transcript_path` / `transcriptPath` (and `tool_name` /
-`toolCall` / `cwd` / `workspacePaths` 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
@@ -235,27 +247,89 @@ listener. 17.x moves fast — re-measure before trusting a name.
 
 ## Antigravity specifics
 
-- **Hooks are defined in `hooks.json` (or `hooks/antigravity-hooks.json`).**
-  Antigravity CLI reads lifecycle hooks under named entries (such as `"lich"`).
-- **Payloads use camelCase.** `conversationId` is the session id, `workspacePaths`
-  contains the active workspace roots, and `transcriptPath` is the JSONL log.
-- **Tools are reported via `toolCall.name`.** Tool arguments arrive under
-  `toolCall.args` with PascalCase fields (`CommandLine`, `TargetFile`, `AbsolutePath`, etc.).
-- **Session title is read from the first `USER_INPUT` entry in `transcriptPath`.**
-- **Lifecycle mapping**: `PreInvocation` reports `session-start` and `busy`; `PreToolUse`
-  reports `busy` with the tool name; `PostToolUse` with write matchers (`write_to_file|replace_file_content|run_command`)
-  reports `touched`; `Stop` reports `done` and `session-title`.
+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 come from the step-type enum**, lowercased with the
+  `CORTEX_STEP_TYPE_` prefix dropped: `run_command`, `view_file`, `grep_search`,
+  `propose_code`, `file_change`, `edit_notebook`, `write_blob`,
+  `delete_directory`. The Windsurf-flavoured names that read like they belong
+  (`write_to_file`, `replace_file_content`, `find_by_name`) are not in it, and a
+  matcher naming them matches nothing — which costs a report rather than raising
+  an error.
+- **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.
+- **lich does not register the provider yet.** `/session-start` answers 400 to
+  `provider: "antigravity"` until it does, which is why no fixture enumerates it
+  and `PENDING_UPSTREAM` in `tests/contract.mjs` names the gap instead. The
+  contract moves in lich first — prose, then fixtures, then the endpoint.
 
 ## 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 4f16287..22b9b47 100644
--- a/docs/session-start.md
+++ b/docs/session-start.md
@@ -18,7 +18,8 @@ the *provider* session id — the field is provider-agnostic.
 
 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`, `antigravity-hooks.json` passes `antigravity` 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 87ec72d..99d4ae5 100644
--- a/docs/session-state.md
+++ b/docs/session-state.md
@@ -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                     | 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` / `find_by_name` | `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
+| Action        | Claude Code       | Codex                     | Antigravity                        | opencode         | omp              |
+|---------------|-------------------|---------------------------|------------------------------------|------------------|------------------|
+| run a command | `Bash`            | `Bash`                    | `run_command`                      | `bash`           | `bash`           |
+| edit a file   | `Edit` / `Write`  | `apply_patch`             | `propose_code` / `file_change`     | `edit` / `write` | `edit` / `write` |
+| read a file   | `Read`            | — (goes through `Bash`)   | `view_file`                        | `read`           | `read`           |
+| search        | `Grep` / `Glob`   | — (goes through `Bash`)   | `grep_search` / `code_search`      | `grep` / `glob`  | `grep` / `glob`  |
+
+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-touched.md b/docs/session-touched.md
index 2d93d08..729fcd3 100644
--- a/docs/session-touched.md
+++ b/docs/session-touched.md
@@ -11,7 +11,7 @@ to a poll interval later.
 
 | 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` |
+| `report-touched.sh` | `PostToolUse` matcher `Edit\|Write\|NotebookEdit\|Bash`  | `PostToolUse` matcher `apply_patch\|Edit\|Write\|Bash`  | `PostToolUse` matcher `propose_code\|file_change\|edit_notebook\|write_blob\|delete_directory\|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/antigravity-hooks.json b/hooks.json
similarity index 53%
rename from hooks/antigravity-hooks.json
rename to hooks.json
index 81bdbd4..8e099eb 100644
--- a/hooks/antigravity-hooks.json
+++ b/hooks.json
@@ -3,22 +3,22 @@
     "PreInvocation": [
       {
         "type": "command",
-        "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/report-session-start.sh\" antigravity",
+        "command": "hooks/report-session-start.sh antigravity; printf '{}'",
         "timeout": 5
       },
       {
         "type": "command",
-        "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/report-state.sh\" busy",
+        "command": "hooks/report-state.sh busy; printf '{}'",
         "timeout": 5
       }
     ],
     "PreToolUse": [
       {
-        "matcher": ".*",
+        "matcher": "",
         "hooks": [
           {
             "type": "command",
-            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/report-tool.sh\"",
+            "command": "hooks/report-tool.sh; printf '{\"decision\":\"allow\"}'",
             "timeout": 5
           }
         ]
@@ -26,11 +26,11 @@
     ],
     "PostToolUse": [
       {
-        "matcher": "write_to_file|replace_file_content|run_command",
+        "matcher": "propose_code|file_change|edit_notebook|write_blob|delete_directory|run_command",
         "hooks": [
           {
             "type": "command",
-            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/report-touched.sh\"",
+            "command": "hooks/report-touched.sh; printf '{}'",
             "timeout": 5
           }
         ]
@@ -39,12 +39,12 @@
     "Stop": [
       {
         "type": "command",
-        "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/report-state.sh\" done",
+        "command": "hooks/report-state.sh done; printf '{\"decision\":\"\"}'",
         "timeout": 5
       },
       {
         "type": "command",
-        "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/report-title.sh\"",
+        "command": "hooks/report-title.sh; printf '{\"decision\":\"\"}'",
         "timeout": 5
       }
     ]
diff --git a/hooks/detail.jq b/hooks/detail.jq
index 9effe1a..dce15d1 100644
--- a/hooks/detail.jq
+++ b/hooks/detail.jq
@@ -16,8 +16,13 @@
 # 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 $legacy_cwd
-| (.workspacePaths[0] // $legacy_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. The names are the ones the CLI binary carries; a field it
+# never sends is a rung the chain falls straight through.
+(.workspacePaths[0]? // .cwd) as $cwd
 | def short: if ($cwd // "") != "" and startswith($cwd + "/") then ltrimstr($cwd + "/")
              elif startswith("/") then sub(".*/"; "")
              else . end;
@@ -28,5 +33,7 @@
        then ((capture("\\*\\*\\* (?:Add|Update|Delete) File: (?<p>[^\n]*)") // {}) | .p // "")
        else . end)
   else
-    ((.TargetFile? // .AbsolutePath? // .DirectoryPath? // .SearchPath? // .file_path? // .path? // .Pattern? // .pattern? // .Url? // .url? // .Query? // .query? // "") | tostring | short)
+    ((.TargetFile? // .FilePath? // .AbsolutePath? // .NotebookPath? // .DirectoryPath?
+      // .SearchPath? // .SearchDirectory? // .file_path? // .path?
+      // .Url? // .url? // .Query? // .query? // .pattern? // "") | tostring | short)
   end
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..90f1713 100644
--- a/tests/contract.mjs
+++ b/tests/contract.mjs
@@ -49,6 +49,21 @@ 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.
+ */
+export const PENDING_UPSTREAM = new Set(['antigravity'])
+
 export const isObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v)
 export const blank = (v) => typeof v !== 'string' || v.trim() === ''
 
@@ -72,7 +87,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 8aefefc..eadbb30 100644
--- a/tests/fixtures/session-start.jsonl
+++ b/tests/fixtures/session-start.jsonl
@@ -1,7 +1,6 @@
 {"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":"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":"antigravity session id","body":{"session_id":"s1","provider_session_id":"019ffb38-ceab-7000-afae-20b8eae145d9","provider":"antigravity"},"accept":{"session_id":"s1","provider_session_id":"019ffb38-ceab-7000-afae-20b8eae145d9","provider":"antigravity"}}
 {"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"}}
 {"name":"absent provider defaults to claude","body":{"session_id":"s1","provider_session_id":"018f9c5a-0000-7000-9a3b-1c2d3e4f5c01"},"accept":{"session_id":"s1","provider_session_id":"018f9c5a-0000-7000-9a3b-1c2d3e4f5c01","provider":"claude"}}
 {"name":"legacy claude_session_id is folded","body":{"session_id":"s1","claude_session_id":"018f9c5a-0000-7000-9a3b-1c2d3e4f5c02"},"accept":{"session_id":"s1","provider_session_id":"018f9c5a-0000-7000-9a3b-1c2d3e4f5c02","provider":"claude"}}
diff --git a/tests/hooks.test.mjs b/tests/hooks.test.mjs
index b2864f8..3cb44e4 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,7 +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' },
-  { provider: 'antigravity', file: 'hooks/antigravity-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
@@ -88,9 +106,10 @@ const SCRIPTS = {
 }
 
 /**
- * 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).
+ * 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),
@@ -101,30 +120,56 @@ const REGISTERED_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'))
-    const hooksMap = json.hooks ?? json.lich ?? Object.values(json)[0]
-    for (const [event, groups] of Object.entries(hooksMap)) {
+    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(' '),
           })
         }
       }
@@ -323,10 +368,7 @@ 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(),
-    ['antigravity', 'claude', 'codex', 'crush', 'omp', 'opencode'],
-  )
+  assert.deepEqual([...PROVIDERS].sort(), ['claude', 'codex', 'crush', 'omp', 'opencode'])
 })
 
 test('every rejected case is modelled by a client-side rule', () => {
@@ -384,6 +426,55 @@ 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)
@@ -413,11 +504,24 @@ test('every registered state argument is an accepted 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) {
@@ -432,7 +536,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])
@@ -463,7 +567,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')
   })
@@ -485,7 +589,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')
@@ -503,7 +607,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)
   })
@@ -515,7 +619,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}`)
@@ -549,7 +653,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)
@@ -562,7 +666,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')
   })
 })
@@ -587,7 +691,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,
@@ -604,7 +708,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')
   })
@@ -617,7 +721,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')
   })
@@ -629,7 +733,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)
   })
 })
@@ -643,7 +747,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 }
   })
 }
@@ -718,10 +822,10 @@ const DETAILS = [
     'pnpm test',
   ],
   [
-    'an antigravity write_to_file',
+    'an antigravity propose_code',
     {
       workspacePaths: ['/w'],
-      toolCall: { name: 'write_to_file', args: { TargetFile: '/w/internal/terminal/usage.go' } },
+      toolCall: { name: 'propose_code', args: { TargetFile: '/w/internal/terminal/usage.go' } },
     },
     'internal/terminal/usage.go',
   ],
@@ -827,7 +931,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')
       })
     })
@@ -840,7 +944,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 },
@@ -855,6 +959,6 @@ for (const { script, argument, event } of EVERY_SCRIPT) {
       env: lichEnv(port),
       stdin: stdinFor({ provider: 'claude', event }),
     })
-    assertSilentSuccess(result)
+    assertHookSucceeded(result)
   })
 }

From cd2e9a1e6eef30749a9c4849a583e8485d8f54ee Mon Sep 17 00:00:00 2001
From: omartelo <meopedevts@proton.me>
Date: Sun, 23 Aug 2026 20:56:38 -0300
Subject: [PATCH 3/4] fix: take Antigravity's tool names off a payload, not off
 its enum
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The previous commit replaced `write_to_file|replace_file_content|run_command`
with names read out of the binary's step-type enum. The enum is the
implementation's vocabulary, not the payload's: a turn measured on agy 1.1.19
sends `write_to_file`, `replace_file_content`, `view_file`, `list_dir`,
`run_command` and `call_mcp_tool`, and only the last of those resembles its
enum entry (`MCP_TOOL`). So the corrected matcher matched `run_command` alone,
and a write with no shell behind it stopped refreshing the card's git status —
the same silent failure as before, with the sign flipped. Measured names
restored, here and in the docs.

Same for detail.jq: `TargetFile`, `AbsolutePath` and `DirectoryPath` are what
arrive; the four enum-derived spellings beside them are dropped rather than left
as rungs nothing ever lands on.

While there: every MCP server's tools reach a hook as the single tool
`call_mcp_tool`, so the card was showing that name for all of them. The server
and the tool it called come as arguments, and detail.jq now reads them —
lich's own tools are what a session is most likely to be running.

The rule in CLAUDE.md said to take names from the harness itself and gave the
binary as one of the places to look. It is not: a name is measured off a real
payload or it is a guess.
---
 CLAUDE.md               |  3 ++-
 docs/providers.md       | 20 +++++++++++++-------
 docs/session-state.md   |  4 ++--
 docs/session-touched.md |  2 +-
 hooks.json              |  2 +-
 hooks/detail.jq         | 22 ++++++++++++++++------
 tests/hooks.test.mjs    | 20 ++++++++++++++++++--
 7 files changed, 53 insertions(+), 20 deletions(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index 646096b..c4a879d 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -101,7 +101,8 @@ 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. Take them from the harness itself (the CLI's own docs, its binary, a run against a stub) and never from what the name resembles on a harness you already support. Antigravity's write tools are `propose_code` and `file_change`, not the Windsurf-flavoured `write_to_file`; a matcher naming the latter matches nothing at all.
+- **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
diff --git a/docs/providers.md b/docs/providers.md
index 9359ecc..ea3aa69 100644
--- a/docs/providers.md
+++ b/docs/providers.md
@@ -285,13 +285,19 @@ against a stub listener — not off a name that reads plausibly.
   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 come from the step-type enum**, lowercased with the
-  `CORTEX_STEP_TYPE_` prefix dropped: `run_command`, `view_file`, `grep_search`,
-  `propose_code`, `file_change`, `edit_notebook`, `write_blob`,
-  `delete_directory`. The Windsurf-flavoured names that read like they belong
-  (`write_to_file`, `replace_file_content`, `find_by_name`) are not in it, and a
-  matcher naming them matches nothing — which costs a report rather than raising
-  an error.
+- **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
diff --git a/docs/session-state.md b/docs/session-state.md
index 99d4ae5..4181025 100644
--- a/docs/session-state.md
+++ b/docs/session-state.md
@@ -133,9 +133,9 @@ stub listener rather than off their documentation:
 | Action        | Claude Code       | Codex                     | Antigravity                        | opencode         | omp              |
 |---------------|-------------------|---------------------------|------------------------------------|------------------|------------------|
 | run a command | `Bash`            | `Bash`                    | `run_command`                      | `bash`           | `bash`           |
-| edit a file   | `Edit` / `Write`  | `apply_patch`             | `propose_code` / `file_change`     | `edit` / `write` | `edit` / `write` |
+| 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` / `code_search`      | `grep` / `glob`  | `grep` / `glob`  |
+| search        | `Grep` / `Glob`   | — (goes through `Bash`)   | `grep_search`                      | `grep` / `glob`  | `grep` / `glob`  |
 
 The `detail` is read by field, never by tool name — `command` / `CommandLine`,
 then `file_path` / `path` / `TargetFile`, then `url` / `query` / `Query` — one
diff --git a/docs/session-touched.md b/docs/session-touched.md
index 729fcd3..2d93d08 100644
--- a/docs/session-touched.md
+++ b/docs/session-touched.md
@@ -11,7 +11,7 @@ to a poll interval later.
 
 | 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 `propose_code\|file_change\|edit_notebook\|write_blob\|delete_directory\|run_command` | `PreToolUse` matcher `^(edit\|write\|multiedit\|bash)$` | `file.edited`  | `tool_result` for `write`/`edit`/`bash`/`notebook` |
+| `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
index 8e099eb..8be3809 100644
--- a/hooks.json
+++ b/hooks.json
@@ -26,7 +26,7 @@
     ],
     "PostToolUse": [
       {
-        "matcher": "propose_code|file_change|edit_notebook|write_blob|delete_directory|run_command",
+        "matcher": "write_to_file|replace_file_content|run_command",
         "hooks": [
           {
             "type": "command",
diff --git a/hooks/detail.jq b/hooks/detail.jq
index dce15d1..e9b74e8 100644
--- a/hooks/detail.jq
+++ b/hooks/detail.jq
@@ -20,20 +20,30 @@
 # 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. The names are the ones the CLI binary carries; a field it
-# never sends is a rung the chain falls straight through.
+# 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;
   (.toolCall.args // .tool_input // {})
-| if ((.CommandLine? // .command? // "") | tostring) != "" then
+| 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
-    ((.TargetFile? // .FilePath? // .AbsolutePath? // .NotebookPath? // .DirectoryPath?
-      // .SearchPath? // .SearchDirectory? // .file_path? // .path?
-      // .Url? // .url? // .Query? // .query? // .pattern? // "") | tostring | short)
+    ((.TargetFile? // .AbsolutePath? // .DirectoryPath?
+      // .file_path? // .path? // .pattern?
+      // .Url? // .url? // .Query? // .query? // "") | tostring | short)
   end
diff --git a/tests/hooks.test.mjs b/tests/hooks.test.mjs
index 3cb44e4..c0f5e42 100644
--- a/tests/hooks.test.mjs
+++ b/tests/hooks.test.mjs
@@ -822,10 +822,13 @@ const DETAILS = [
     'pnpm test',
   ],
   [
-    'an antigravity propose_code',
+    'an antigravity write_to_file',
     {
       workspacePaths: ['/w'],
-      toolCall: { name: 'propose_code', args: { TargetFile: '/w/internal/terminal/usage.go' } },
+      toolCall: {
+        name: 'write_to_file',
+        args: { TargetFile: '/w/internal/terminal/usage.go', CodeContent: 'package terminal' },
+      },
     },
     'internal/terminal/usage.go',
   ],
@@ -842,6 +845,19 @@ const DETAILS = [
     { 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' } } },

From 2e4ba11a2f29f9a03964ec3c51922513007d1d4f Mon Sep 17 00:00:00 2001
From: omartelo <meopedevts@proton.me>
Date: Sun, 23 Aug 2026 21:10:00 -0300
Subject: [PATCH 4/4] chore: enumerate antigravity from lich's fixtures
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

lich registered the provider (omartelo/lich#370), so `refresh-fixtures.sh`
brings down a `session-start` case for it and `PENDING_UPSTREAM` empties — the
guard that fails once a refreshed fixture registers a pending provider did
exactly that, which is what emptied it. The enumerations come from the fixtures
alone again, and the antigravity payload is now held to an accepted case by
value rather than by shape.
---
 CHANGELOG.md                       | 6 +++---
 docs/providers.md                  | 8 ++++----
 tests/contract.mjs                 | 7 +++++--
 tests/fixtures/session-start.jsonl | 1 +
 tests/hooks.test.mjs               | 5 ++++-
 5 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3629376..ff55289 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -32,9 +32,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   event asks for, leaving the scripts silent for Codex, which reads their stdout
   as an answer to a permission request.
 
-  lich does not register the provider yet, so `/session-start` answers 400 until
-  it does; `PENDING_UPSTREAM` in `tests/contract.mjs` names that gap rather than
-  a fixture being edited to hide it.
+  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
diff --git a/docs/providers.md b/docs/providers.md
index ea3aa69..796db55 100644
--- a/docs/providers.md
+++ b/docs/providers.md
@@ -304,10 +304,10 @@ against a stub listener — not off a name that reads plausibly.
   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.
-- **lich does not register the provider yet.** `/session-start` answers 400 to
-  `provider: "antigravity"` until it does, which is why no fixture enumerates it
-  and `PENDING_UPSTREAM` in `tests/contract.mjs` names the gap instead. The
-  contract moves in lich first — prose, then fixtures, then the endpoint.
+- **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
 
diff --git a/tests/contract.mjs b/tests/contract.mjs
index 90f1713..ff7d6ab 100644
--- a/tests/contract.mjs
+++ b/tests/contract.mjs
@@ -60,9 +60,12 @@ export const PROVIDERS = new Set(accepted('/session-start').map((c) => c.accept.
  *
  * 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.
+ * 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(['antigravity'])
+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() === ''
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 c0f5e42..9667811 100644
--- a/tests/hooks.test.mjs
+++ b/tests/hooks.test.mjs
@@ -368,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', () => {