Skip to content

#1 Persistent memory for AI coding agents based on real-world benchmarks

feat(cli): native hooks adapter for Antigravity CLI (agy) (#1146)

Bertho Jorisd60652a70587
diff --git a/README.md b/README.md
index 332e2010..eb6bd1fa 100644
--- a/README.md
+++ b/README.md
@@ -672,6 +672,7 @@ The agentmemory entry is the **same MCP server block** across every host that us
| **Hermes Agent** | `~/.hermes/config.yaml` | Use the deeper [memory provider plugin](integrations/hermes/) with `memory.provider: agentmemory`. |
| **Qwen Code** | `~/.qwen/settings.json` | `agentmemory connect qwen` writes the standard `mcpServers` block. Hook payload is field-compatible with Claude Code, so the existing 12-hook scripts work without modification — wire them via the `hooks` section in the same `settings.json`. |
| **Antigravity** (replaces Gemini CLI) | `mcp_config.json` (in Antigravity's User dir) | `agentmemory connect antigravity` writes the standard `mcpServers` block. macOS: `~/Library/Application Support/Antigravity/User/`. Linux: `~/.config/Antigravity/User/`. Use after the 2026-06-18 Gemini CLI sunset. |
+| **Antigravity CLI** (`agy`) | `~/.gemini/config/mcp_config.json` | `agentmemory connect antigravity-cli` — the `agy` CLI keeps its own config under `~/.gemini/`, separate from the Antigravity IDE above. Pass `--with-hooks` for native auto-capture via `~/.gemini/config/hooks.json`. |
| **Kiro** | `~/.kiro/settings/mcp.json` | `agentmemory connect kiro` writes the user-level config. Workspace overrides go in `.kiro/settings/mcp.json` next to your code. |
| **Warp** | `~/.warp/.mcp.json` | `agentmemory connect warp` writes the standard `mcpServers` block. Warp also auto-discovers skills from `.claude/skills/` — once the Claude Code plugin is installed the 8 agentmemory skills (`remember`, `recall`, `recap`, `handoff`, `forget`, `commit-context`, `commit-history`, `session-history`) appear natively in Warp's slash-command palette. |
| **Cline (CLI)** | `~/.cline/mcp.json` | `agentmemory connect cline` writes the standard `mcpServers` block. VS Code extension users: paste the same block via Cline Settings → MCP Servers → Edit JSON. |
diff --git a/plugin/hooks/hooks.antigravity.json b/plugin/hooks/hooks.antigravity.json
new file mode 100644
index 00000000..e3152b7a
--- /dev/null
+++ b/plugin/hooks/hooks.antigravity.json
@@ -0,0 +1,43 @@
+{
+ "agentmemory": {
+ "enabled": true,
+ "PreInvocation": [
+ {
+ "type": "command",
+ "command": "node ${CLAUDE_PLUGIN_ROOT}/scripts/antigravity-bridge.mjs PreInvocation",
+ "timeout": 10
+ }
+ ],
+ "PreToolUse": [
+ {
+ "matcher": "view_file|view_code_item|read_file|edit_file|replace_file_content|write_to_file|create_file|grep_search|codebase_search|find_by_name|list_dir",
+ "hooks": [
+ {
+ "type": "command",
+ "command": "node ${CLAUDE_PLUGIN_ROOT}/scripts/antigravity-bridge.mjs PreToolUse",
+ "timeout": 10
+ }
+ ]
+ }
+ ],
+ "PostToolUse": [
+ {
+ "matcher": "",
+ "hooks": [
+ {
+ "type": "command",
+ "command": "node ${CLAUDE_PLUGIN_ROOT}/scripts/antigravity-bridge.mjs PostToolUse",
+ "timeout": 10
+ }
+ ]
+ }
+ ],
+ "Stop": [
+ {
+ "type": "command",
+ "command": "node ${CLAUDE_PLUGIN_ROOT}/scripts/antigravity-bridge.mjs Stop",
+ "timeout": 10
+ }
+ ]
+ }
+}
diff --git a/plugin/scripts/antigravity-bridge.mjs b/plugin/scripts/antigravity-bridge.mjs
new file mode 100644
index 00000000..12d72ba9
--- /dev/null
+++ b/plugin/scripts/antigravity-bridge.mjs
@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/hooks/antigravity-bridge.ts
+const SCRIPTS_DIR = dirname(fileURLToPath(import.meta.url));
+const TOOL_NAME_MAP = {
+ view_file: "read",
+ view_line_range: "read",
+ view_code_item: "read",
+ read_file: "read",
+ read_url_content: "read",
+ edit_file: "edit",
+ replace_file_content: "edit",
+ propose_code: "edit",
+ write_to_file: "write",
+ create_file: "write",
+ grep_search: "grep",
+ codebase_search: "grep",
+ find_by_name: "glob",
+ list_dir: "glob"
+};
+const ARG_KEY_MAP = {
+ AbsolutePath: "file_path",
+ TargetFile: "file_path",
+ DirectoryPath: "path",
+ SearchDirectory: "path",
+ Pattern: "pattern",
+ Query: "pattern",
+ CommandLine: "command"
+};
+function asObject(value) {
+ return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function firstString(...values) {
+ for (const v of values) if (typeof v === "string" && v.length > 0) return v;
+}
+function normalizeToolArgs(args) {
+ if (!args) return {};
+ const out = { ...args };
+ for (const [from, to] of Object.entries(ARG_KEY_MAP)) if (out[to] === void 0 && args[from] !== void 0) out[to] = args[from];
+ return out;
+}
+function normalizePayload(event, raw) {
+ const toolCall = asObject(raw["toolCall"]);
+ const workspacePaths = Array.isArray(raw["workspacePaths"]) ? raw["workspacePaths"] : [];
+ const sessionId = firstString(raw["conversationId"], raw["session_id"], raw["sessionId"]) ?? "unknown";
+ const cwd = firstString(raw["cwd"], workspacePaths[0]) ?? process.cwd();
+ const out = {
+ ...raw,
+ session_id: sessionId,
+ cwd,
+ hook_event_name: event
+ };
+ const transcriptPath = firstString(raw["transcript_path"], raw["transcriptPath"]);
+ if (transcriptPath) out["transcript_path"] = transcriptPath;
+ if (toolCall) {
+ const args = normalizeToolArgs(asObject(toolCall["args"]) ?? asObject(toolCall["toolArgs"]));
+ const rawName = firstString(toolCall["name"], toolCall["toolName"], args["ToolName"], args["toolName"]);
+ if (rawName) {
+ out["tool_name"] = TOOL_NAME_MAP[rawName] ?? rawName;
+ out["native_tool_name"] = rawName;
+ }
+ out["tool_input"] = args;
+ const result = toolCall["result"] ?? raw["toolResult"] ?? raw["result"];
+ if (result !== void 0) out["tool_result"] = result;
+ }
+ return out;
+}
+function targetsFor(event, raw) {
+ switch (event) {
+ case "PreInvocation": {
+ const n = raw["invocationNum"];
+ return typeof n !== "number" || n <= 1 ? ["session-start.mjs", "prompt-submit.mjs"] : ["prompt-submit.mjs"];
+ }
+ case "PreToolUse": return ["pre-tool-use.mjs"];
+ case "PostToolUse": return ["post-tool-use.mjs"];
+ case "Stop": return ["stop.mjs", "session-end.mjs"];
+ default: return [];
+ }
+}
+function responseFor(event) {
+ return event === "PreToolUse" ? "{\"decision\":\"allow\"}" : "{}";
+}
+async function main() {
+ const event = process.argv[2];
+ if (!event) return;
+ let input = "";
+ for await (const chunk of process.stdin) input += chunk;
+ let raw;
+ try {
+ raw = JSON.parse(input);
+ } catch {
+ return;
+ }
+ if (!raw || typeof raw !== "object") return;
+ const payload = JSON.stringify(normalizePayload(event, raw));
+ for (const script of targetsFor(event, raw)) spawnSync(process.execPath, [join(SCRIPTS_DIR, script)], {
+ input: payload,
+ stdio: [
+ "pipe",
+ "ignore",
+ "ignore"
+ ]
+ });
+}
+if (process.argv[1] !== void 0 && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) main().catch(() => {}).finally(() => {
+ process.stdout.write(responseFor(process.argv[2] ?? ""));
+ process.exit(0);
+});
+//#endregion
+export { normalizePayload, responseFor, targetsFor };
+
+//# sourceMappingURL=antigravity-bridge.mjs.map
\ No newline at end of file
diff --git a/plugin/skills/agentmemory-agents/REFERENCE.md b/plugin/skills/agentmemory-agents/REFERENCE.md
index a0ec69ca..8943cfa4 100644
--- a/plugin/skills/agentmemory-agents/REFERENCE.md
+++ b/plugin/skills/agentmemory-agents/REFERENCE.md
@@ -3,11 +3,12 @@
Generated from `src/cli/connect/index.ts`. Do not edit the block below by hand; run `npm run skills:gen` after adding or removing an adapter.
<!-- AUTOGEN:agents START - generated by scripts/skills/generate.ts, do not edit by hand -->
-`agentmemory connect <agent>` wires the memory server into a host agent. 18 adapters:
+`agentmemory connect <agent>` wires the memory server into a host agent. 19 adapters:
| Agent | Name | Protocol |
| --- | --- | --- |
| Antigravity | `antigravity` | Using MCP via mcp_config.json. Antigravity replaces Gemini CLI (sunset 2026-06-18). |
+| Antigravity CLI (agy) | `antigravity-cli` | Using MCP via ~/.gemini/config/mcp_config.json (the agy CLI, not the Antigravity IDE, that one is `connect antigravity`). The `/mcp` slash command inside agy lists configured servers. Pass --with-hooks to also install the native ~/.gemini/config/hooks.json auto-capture hooks. |
| Claude Code | `claude-code` | Using MCP. Hooks are also available, see https://github.com/rohitg00/agentmemory#claude-code-one-block-paste-it. |
| Cline | `cline` | Using MCP via ~/.cline/mcp.json (CLI). VS Code users: add the same block via Cline Settings → MCP Servers → Edit JSON. |
| Codex CLI | `codex` | Using MCP. Hooks ship via the Codex plugin; on Codex Desktop, also pass --with-hooks to install the global hooks.json workaround for openai/codex#16430. |
diff --git a/plugin/skills/agentmemory-rest-api/REFERENCE.md b/plugin/skills/agentmemory-rest-api/REFERENCE.md
index d12ff461..b92e35a9 100644
--- a/plugin/skills/agentmemory-rest-api/REFERENCE.md
+++ b/plugin/skills/agentmemory-rest-api/REFERENCE.md
@@ -5,7 +5,7 @@ Generated from `src/triggers/api.ts`. Do not edit the block below by hand; run `
<!-- AUTOGEN:rest START - generated by scripts/skills/generate.ts, do not edit by hand -->
The REST API is the primary surface. All paths are under `http://localhost:3111` (override with `--port`). When `AGENTMEMORY_SECRET` is set, send `Authorization: Bearer $AGENTMEMORY_SECRET`; localhost is otherwise open.
-118 registered endpoints:
+119 registered endpoints:
| Method | Path |
| --- | --- |
diff --git a/src/cli/connect/antigravity-cli.ts b/src/cli/connect/antigravity-cli.ts
new file mode 100644
index 00000000..af64870f
--- /dev/null
+++ b/src/cli/connect/antigravity-cli.ts
@@ -0,0 +1,97 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import * as p from "@clack/prompts";
+import { createJsonMcpAdapter } from "./json-mcp-adapter.js";
+import type { ConnectOptions, ConnectResult } from "./types.js";
+import {
+ buildMergedAntigravityHooks,
+ containsSpaces,
+ type AntigravityHookManifest,
+} from "./antigravity-hooks.js";
+import { findPluginRoot } from "./codex-hooks.js";
+import {
+ backupFile,
+ logBackup,
+ logInstalled,
+ readJsonSafe,
+ writeJsonAtomic,
+} from "./util.js";
+
+// The `agy` CLI shares no configuration with the Antigravity IDE that
+// `antigravity.ts` wires — it reads MCP from ~/.gemini/config/mcp_config.json
+// and hooks from ~/.gemini/config/hooks.json (per-workspace overrides in
+// <repo>/.agents/hooks.json). Detection keys off ~/.gemini/antigravity-cli/,
+// which only the CLI creates; ~/.gemini/ alone would also match Gemini CLI.
+// Sources: antigravity.google/docs/hooks, antigravity.google/docs/cli/using
+const GEMINI_DIR = join(homedir(), ".gemini");
+const ANTIGRAVITY_CLI_DIR = join(GEMINI_DIR, "antigravity-cli");
+const CUSTOMIZATION_DIR = join(GEMINI_DIR, "config");
+const ANTIGRAVITY_CLI_HOOKS = join(CUSTOMIZATION_DIR, "hooks.json");
+
+export const adapter = createJsonMcpAdapter({
+ name: "antigravity-cli",
+ displayName: "Antigravity CLI (agy)",
+ detectDir: ANTIGRAVITY_CLI_DIR,
+ configPath: join(CUSTOMIZATION_DIR, "mcp_config.json"),
+ docs: "https://github.com/rohitg00/agentmemory#other-agents",
+ protocolNote:
+ "→ Using MCP via ~/.gemini/config/mcp_config.json (the agy CLI, not the Antigravity IDE — that one is `connect antigravity`). The `/mcp` slash command inside agy lists configured servers. Pass --with-hooks to also install the native ~/.gemini/config/hooks.json auto-capture hooks.",
+ installHooks: installAntigravityCliHooks,
+});
+
+/**
+ * Merge the bundled `plugin/hooks/hooks.antigravity.json` into
+ * `~/.gemini/config/hooks.json`, replacing only the bundle agentmemory owns.
+ */
+function installAntigravityCliHooks(opts: ConnectOptions): ConnectResult {
+ let pluginRoot: string;
+ try {
+ pluginRoot = findPluginRoot();
+ } catch (err) {
+ return {
+ kind: "skipped",
+ reason: err instanceof Error ? err.message : String(err),
+ };
+ }
+
+ // agy honours no quoting, so a space in the path yields hooks that load
+ // but never run. Refuse rather than install something that can only fail.
+ if (containsSpaces(pluginRoot)) {
+ return {
+ kind: "skipped",
+ reason: `Antigravity CLI cannot run hook commands whose path contains spaces, and agentmemory is installed at ${pluginRoot}. Reinstall it under a space-free path to use --with-hooks; MCP works either way.`,
+ };
+ }
+
+ const existing = readJsonSafe<AntigravityHookManifest>(ANTIGRAVITY_CLI_HOOKS);
+ const merged = buildMergedAntigravityHooks(existing, pluginRoot);
+
+ if (opts.dryRun) {
+ p.log.info(
+ `[dry-run] Would ${existing ? "merge" : "create"} ${ANTIGRAVITY_CLI_HOOKS} with ${Object.keys(merged).length} hook bundle(s)`,
+ );
+ return { kind: "installed", mutatedPath: ANTIGRAVITY_CLI_HOOKS };
+ }
+
+ let backupPath: string | undefined;
+ if (existsSync(ANTIGRAVITY_CLI_HOOKS)) {
+ backupPath = backupFile(ANTIGRAVITY_CLI_HOOKS, "antigravity-cli-hooks", "json");
+ logBackup(backupPath);
+ } else {
+ mkdirSync(CUSTOMIZATION_DIR, { recursive: true });
+ }
+
+ writeJsonAtomic(ANTIGRAVITY_CLI_HOOKS, merged);
+
+ logInstalled("Antigravity CLI hooks", ANTIGRAVITY_CLI_HOOKS);
+ p.log.info(
+ "User-scope hooks reference absolute paths under the bundled plugin/ dir. Re-run `agentmemory connect antigravity-cli --with-hooks` after upgrading agentmemory to refresh them.",
+ );
+
+ return {
+ kind: "installed",
+ mutatedPath: ANTIGRAVITY_CLI_HOOKS,
+ ...(backupPath !== undefined && { backupPath }),
+ };
+}
diff --git a/src/cli/connect/antigravity-hooks.ts b/src/cli/connect/antigravity-hooks.ts
new file mode 100644
index 00000000..b3b11297
--- /dev/null
+++ b/src/cli/connect/antigravity-hooks.ts
@@ -0,0 +1,163 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+/**
+ * Merge engine for Antigravity CLI's `hooks.json`.
+ *
+ * Antigravity does not use the `{ hooks: { <Event>: [...] } }` envelope
+ * that `codex-hooks.ts` handles for Claude Code, Codex and Droid. Its file
+ * is a map of *named* hook bundles at the root:
+ *
+ * {
+ * "<hook-name>": {
+ * "enabled": true,
+ * "PreToolUse": [ { "matcher": "…", "hooks": [ { type, command, timeout } ] } ],
+ * "Stop": [ { type, command, timeout } ]
+ * }
+ * }
+ *
+ * The two shapes are not a typo: tool events take the `{ matcher, hooks }`
+ * wrapper, lifecycle events a flat handler list. Wrapping a lifecycle event
+ * makes agy read the wrapper as a handler and reject the *whole file*
+ * (`command hook must specify 'command'`), disabling every other bundle in
+ * it too.
+ *
+ * Named bundles make the merge simpler than the Codex one: agentmemory owns
+ * exactly the top-level keys whose commands point under
+ * `<pluginRoot>/scripts/`, so a re-install drops those wholesale and re-adds
+ * a fresh bundle, preserving user keys and their order.
+ *
+ * `${CLAUDE_PLUGIN_ROOT}` is resolved at install time — agy expands no env
+ * vars and requires absolute paths. The resolved path must also be bare and
+ * space-free: agy runs no shell and strips no quotes, so `node "<root>/…"`
+ * looks for a module whose name starts with a quote, and a space truncates
+ * the argument with no escaping form that works.
+ *
+ * Behaviour above verified against agy 1.0.15.
+ * Source: antigravity.google/docs/hooks
+ */
+
+type HookHandler = { type: string; command: string; timeout?: number };
+type HookEntry = { matcher?: string; hooks: HookHandler[] };
+export type NamedHook = { enabled?: boolean } & Record<
+ string,
+ boolean | HookEntry[] | HookHandler[] | undefined
+>;
+export type AntigravityHookManifest = Record<string, NamedHook>;
+
+/** Tool events: `[ { matcher, hooks: [...] } ]`. */
+const TOOL_EVENT_KEYS = new Set(["PreToolUse", "PostToolUse"]);
+
+/** Lifecycle events: a flat `[ { type, command } ]` handler list. */
+const LIFECYCLE_EVENT_KEYS = new Set([
+ "PreInvocation",
+ "PostInvocation",
+ "Stop",
+]);
+
+/** Events Antigravity dispatches. Anything else in a bundle is metadata. */
+const EVENT_KEYS = new Set([...TOOL_EVENT_KEYS, ...LIFECYCLE_EVENT_KEYS]);
+
+export function buildMergedAntigravityHooks(
+ existing: AntigravityHookManifest | null,
+ pluginRoot: string,
+ manifestFile = "hooks.antigravity.json",
+): AntigravityHookManifest {
+ const ours = JSON.parse(
+ readFileSync(join(pluginRoot, "hooks", manifestFile), "utf-8"),
+ ) as AntigravityHookManifest;
+ const scriptsDir = join(pluginRoot, "scripts");
+
+ const out: AntigravityHookManifest = {};
+
+ for (const [name, bundle] of Object.entries(existing ?? {})) {
+ if (isAgentmemoryBundle(bundle, scriptsDir)) continue;
+ out[name] = bundle;
+ }
+
+ for (const [name, bundle] of Object.entries(ours)) {
+ out[name] = resolveBundle(bundle, pluginRoot);
+ }
+
+ return out;
+}
+
+/** True when `pluginRoot` cannot be expressed in an Antigravity `command`. */
+export function containsSpaces(pluginRoot: string): boolean {
+ return /\s/.test(pluginRoot);
+}
+
+/**
+ * Every handler in a bundle, across both event shapes: an entry that carries
+ * no `hooks` array is itself the handler.
+ */
+function allHandlers(bundle: NamedHook): HookHandler[] {
+ const out: HookHandler[] = [];
+ for (const [key, value] of Object.entries(bundle)) {
+ if (!EVENT_KEYS.has(key) || !Array.isArray(value)) continue;
+ for (const entry of value as (HookEntry | HookHandler)[]) {
+ if (!entry || typeof entry !== "object") continue;
+ const nested = (entry as HookEntry).hooks;
+ if (Array.isArray(nested)) out.push(...nested);
+ else out.push(entry as HookHandler);
+ }
+ }
+ return out;
+}
+
+function isAgentmemoryBundle(bundle: unknown, scriptsDir: string): boolean {
+ if (!bundle || typeof bundle !== "object" || Array.isArray(bundle)) {
+ return false;
+ }
+ const normalizedScriptsDir = normalizePathForCommandMatch(scriptsDir);
+ return allHandlers(bundle as NamedHook).some((handler) =>
+ normalizePathForCommandMatch(handler?.command ?? "").includes(
+ normalizedScriptsDir,
+ ),
+ );
+}
+
+function resolveBundle(bundle: NamedHook, pluginRoot: string): NamedHook {
+ const out: NamedHook = {};
+ for (const [key, value] of Object.entries(bundle)) {
+ if (!EVENT_KEYS.has(key) || !Array.isArray(value)) {
+ out[key] = value as boolean;
+ continue;
+ }
+ if (LIFECYCLE_EVENT_KEYS.has(key)) {
+ out[key] = (value as HookHandler[]).map((handler) =>
+ resolveHandler(handler, pluginRoot),
+ );
+ continue;
+ }
+ out[key] = (value as HookEntry[]).map((entry) => {
+ const next: HookEntry = {
+ hooks: entry.hooks.map((handler) => resolveHandler(handler, pluginRoot)),
+ };
+ if (entry.matcher !== undefined) next.matcher = entry.matcher;
+ return next;
+ });
+ }
+ return out;
+}
+
+function resolveHandler(
+ handler: HookHandler,
+ pluginRoot: string,
+): HookHandler {
+ return {
+ type: handler.type,
+ // Replacer function, not a string: a plugin path containing `$$`, `$&`,
+ // "$`" or `$'` would otherwise be read as a replacement pattern and
+ // silently mangle the installed command.
+ command: handler.command.replace(
+ /\$\{CLAUDE_PLUGIN_ROOT\}/g,
+ () => pluginRoot,
+ ),
+ ...(handler.timeout !== undefined && { timeout: handler.timeout }),
+ };
+}
+
+function normalizePathForCommandMatch(value: string): string {
+ return value.replace(/\\/g, "/");
+}
diff --git a/src/cli/connect/guidelines.ts b/src/cli/connect/guidelines.ts
index d1b95593..26770b6a 100644
--- a/src/cli/connect/guidelines.ts
+++ b/src/cli/connect/guidelines.ts
@@ -120,6 +120,14 @@ export function guidelineTargets(
scope: "global",
source: "https://antigravity.google/docs/rules-workflows",
},
+ // The agy CLI reads the same ~/.gemini/GEMINI.md as the IDE.
+ "antigravity-cli": {
+ globalPath: join(home, ".gemini", "GEMINI.md"),
+ projectPath: join(".agents", "rules", "agentmemory.md"),
+ format: "block",
+ scope: "global",
+ source: "https://antigravity.google/docs/rules-workflows",
+ },
"copilot-cli": {
globalPath: join(home, ".copilot", "copilot-instructions.md"),
projectPath: join(".github", "copilot-instructions.md"),
diff --git a/src/cli/connect/index.ts b/src/cli/connect/index.ts
index 0014e7d4..a0256c7a 100644
--- a/src/cli/connect/index.ts
+++ b/src/cli/connect/index.ts
@@ -4,6 +4,7 @@ import pc from "picocolors";
import type { ConnectAdapter, ConnectOptions, ConnectResult } from "./types.js";
import { writeGuideline } from "./guidelines.js";
import { adapter as antigravity } from "./antigravity.js";
+import { adapter as antigravityCli } from "./antigravity-cli.js";
import { adapter as claudeCode } from "./claude-code.js";
import { adapter as cline } from "./cline.js";
import { adapter as copilotCli } from "./copilot-cli.js";
@@ -30,6 +31,7 @@ export const ADAPTERS: readonly ConnectAdapter[] = [
geminiCli,
qwen,
antigravity,
+ antigravityCli,
kiro,
warp,
cline,
diff --git a/src/hooks/antigravity-bridge.ts b/src/hooks/antigravity-bridge.ts
new file mode 100644
index 00000000..60e65bac
--- /dev/null
+++ b/src/hooks/antigravity-bridge.ts
@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// Antigravity CLI (`agy`) bridge — sits in front of the canonical hooks
+// because three parts of agy's contract make them unusable as direct
+// `command` targets: only five events exist (no SessionStart/SessionEnd/
+// UserPromptSubmit, so the lifecycle is synthesized from PreInvocation and
+// Stop); the payload is camelCase and nests tool calls under `toolCall`; and
+// stdout must be a JSON object, which `pre-tool-use.mjs` breaks when
+// AGENTMEMORY_INJECT_CONTEXT=true makes it write raw context text.
+//
+// Invoked as: node antigravity-bridge.mjs <PreInvocation|PreToolUse|PostToolUse|Stop>
+// Sources: antigravity.google/docs/hooks, antigravity.google/docs/cli/using
+
+const SCRIPTS_DIR = dirname(fileURLToPath(import.meta.url));
+
+// Antigravity inherits Cascade-style tool names. Map them onto the tool
+// vocabulary pre-tool-use.ts / post-tool-use.ts already understand so the
+// existing file-activity heuristics keep working unchanged.
+const TOOL_NAME_MAP: Record<string, string> = {
+ view_file: "read",
+ view_line_range: "read",
+ view_code_item: "read",
+ read_file: "read",
+ read_url_content: "read",
+ edit_file: "edit",
+ replace_file_content: "edit",
+ propose_code: "edit",
+ write_to_file: "write",
+ create_file: "write",
+ grep_search: "grep",
+ codebase_search: "grep",
+ find_by_name: "glob",
+ list_dir: "glob",
+};
+
+// Antigravity tool args are PascalCase; the canonical hooks look for
+// snake_case keys. Only the keys those hooks actually read are mapped.
+const ARG_KEY_MAP: Record<string, string> = {
+ AbsolutePath: "file_path",
+ TargetFile: "file_path",
+ DirectoryPath: "path",
+ SearchDirectory: "path",
+ Pattern: "pattern",
+ Query: "pattern",
+ CommandLine: "command",
+};
+
+type Json = Record<string, unknown>;
+
+function asObject(value: unknown): Json | undefined {
+ return typeof value === "object" && value !== null && !Array.isArray(value)
+ ? (value as Json)
+ : undefined;
+}
+
+function firstString(...values: unknown[]): string | undefined {
+ for (const v of values) {
+ if (typeof v === "string" && v.length > 0) return v;
+ }
+ return undefined;
+}
+
+function normalizeToolArgs(args: Json | undefined): Json {
+ if (!args) return {};
+ const out: Json = { ...args };
+ for (const [from, to] of Object.entries(ARG_KEY_MAP)) {
+ if (out[to] === undefined && args[from] !== undefined) out[to] = args[from];
+ }
+ return out;
+}
+
+// Translate one Antigravity hook payload into the flat, snake_case shape the
+// bundled hooks consume. Unknown fields pass through so future Antigravity
+// additions stay visible to the capture pipeline.
+export function normalizePayload(event: string, raw: Json): Json {
+ const toolCall = asObject(raw["toolCall"]);
+ const workspacePaths = Array.isArray(raw["workspacePaths"])
+ ? (raw["workspacePaths"] as unknown[])
+ : [];
+
+ const sessionId =
+ firstString(raw["conversationId"], raw["session_id"], raw["sessionId"]) ??
+ "unknown";
+ const cwd =
+ firstString(raw["cwd"], workspacePaths[0]) ?? process.cwd();
+
+ const out: Json = {
+ ...raw,
+ session_id: sessionId,
+ cwd,
+ hook_event_name: event,
+ };
+
+ const transcriptPath = firstString(
+ raw["transcript_path"],
+ raw["transcriptPath"],
+ );
+ if (transcriptPath) out["transcript_path"] = transcriptPath;
+
+ if (toolCall) {
+ const args = normalizeToolArgs(
+ asObject(toolCall["args"]) ?? asObject(toolCall["toolArgs"]),
+ );
+ const rawName = firstString(
+ toolCall["name"],
+ toolCall["toolName"],
+ args["ToolName"],
+ args["toolName"],
+ );
+ if (rawName) {
+ out["tool_name"] = TOOL_NAME_MAP[rawName] ?? rawName;
+ // Keep the host-native name so captured observations stay traceable
+ // back to the tool Antigravity actually ran.
+ out["native_tool_name"] = rawName;
+ }
+ out["tool_input"] = args;
+ const result = toolCall["result"] ?? raw["toolResult"] ?? raw["result"];
+ if (result !== undefined) out["tool_result"] = result;
+ }
+
+ return out;
+}
+
+// Map an Antigravity event to the bundled scripts it should drive.
+// PreInvocation stands in for both SessionStart and UserPromptSubmit: the
+// first invocation of a conversation opens the session, every later one is a
+// fresh user turn. PostInvocation is deliberately unmapped — PostToolUse
+// already captures the work, and firing again would double-record it.
+export function targetsFor(event: string, raw: Json): string[] {
+ switch (event) {
+ case "PreInvocation": {
+ const n = raw["invocationNum"];
+ const isFirst = typeof n !== "number" || n <= 1;
+ return isFirst
+ ? ["session-start.mjs", "prompt-submit.mjs"]
+ : ["prompt-submit.mjs"];
+ }
+ case "PreToolUse":
+ return ["pre-tool-use.mjs"];
+ case "PostToolUse":
+ return ["post-tool-use.mjs"];
+ case "Stop":
+ return ["stop.mjs", "session-end.mjs"];
+ default:
+ return [];
+ }
+}
+
+// The stdout contract, per event. agy treats a PreToolUse response without
+// `decision` as a denial, so a bare `{}` there makes it refuse every matched
+// tool call (verified on 1.0.15). No other event carries a permission
+// decision, so they stay on `{}` — sending one would override user settings.
+export function responseFor(event: string): string {
+ return event === "PreToolUse" ? '{"decision":"allow"}' : "{}";
+}
+
+async function main() {
+ const event = process.argv[2];
+ if (!event) return;
+
+ let input = "";
+ for await (const chunk of process.stdin) {
+ input += chunk;
+ }
+
+ let raw: Json;
+ try {
+ raw = JSON.parse(input) as Json;
+ } catch {
+ return;
+ }
+ if (!raw || typeof raw !== "object") return;
+
+ const payload = JSON.stringify(normalizePayload(event, raw));
+
+ for (const script of targetsFor(event, raw)) {
+ // Synchronous so the hook process does not exit before the capture
+ // POSTs are issued. Each bundled hook already caps its own fetch
+ // timeout, so the worst case here is bounded by those.
+ spawnSync(process.execPath, [join(SCRIPTS_DIR, script)], {
+ input: payload,
+ // Child stdout is discarded on purpose: Antigravity parses this
+ // process's stdout as the hook response, and the bundled scripts
+ // emit prose when context injection is enabled.
+ stdio: ["pipe", "ignore", "ignore"],
+ });
+ }
+}
+
+// Guarded so the pure helpers above stay importable from tests without the
+// module blocking on stdin. Every other bundled hook is a leaf script and
+// needs no such guard.
+const invokedDirectly =
+ process.argv[1] !== undefined &&
+ resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+
+if (invokedDirectly) {
+ main()
+ .catch(() => {})
+ .finally(() => {
+ // Always a well-formed, non-blocking response, emitted even when the
+ // capture above threw or the payload was unparseable — a hook that
+ // writes nothing is as fatal to PreToolUse as one that writes `{}`.
+ process.stdout.write(responseFor(process.argv[2] ?? ""));
+ process.exit(0);
+ });
+}
diff --git a/test/antigravity-connect-hooks.test.ts b/test/antigravity-connect-hooks.test.ts
new file mode 100644
index 00000000..7b33f1e6
--- /dev/null
+++ b/test/antigravity-connect-hooks.test.ts
@@ -0,0 +1,375 @@
+import { describe, it, expect } from "vitest";
+import { execFileSync } from "node:child_process";
+import { copyFileSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import {
+ buildMergedAntigravityHooks,
+ containsSpaces,
+ type AntigravityHookManifest,
+} from "../src/cli/connect/antigravity-hooks.js";
+import { findPluginRoot } from "../src/cli/connect/codex-hooks.js";
+import {
+ normalizePayload,
+ responseFor,
+ targetsFor,
+} from "../src/hooks/antigravity-bridge.js";
+
+const PLUGIN_ROOT = resolve(__dirname, "..", "plugin");
+
+function build(existing: AntigravityHookManifest | null = null) {
+ return buildMergedAntigravityHooks(existing, findPluginRoot());
+}
+
+type Handler = { type: string; command: string; timeout?: number };
+
+function eventEntries(bundle: unknown, event: string) {
+ return (bundle as Record<string, unknown>)[event] as {
+ matcher?: string;
+ hooks: Handler[];
+ }[];
+}
+
+function handlers(bundle: unknown, event: string) {
+ return (bundle as Record<string, unknown>)[event] as Handler[];
+}
+
+/** Every handler in a bundle, across both of agy's event shapes. */
+function allCommands(bundle: unknown): string[] {
+ const out: string[] = [];
+ for (const value of Object.values(bundle as Record<string, unknown>)) {
+ if (!Array.isArray(value)) continue;
+ for (const entry of value) {
+ const nested = (entry as { hooks?: Handler[] }).hooks;
+ for (const h of nested ?? [entry as Handler]) out.push(h.command);
+ }
+ }
+ return out;
+}
+
+describe("buildMergedAntigravityHooks", () => {
+ it("rewrites ${CLAUDE_PLUGIN_ROOT} to absolute pluginRoot in every command", () => {
+ for (const bundle of Object.values(build())) {
+ for (const command of allCommands(bundle)) {
+ expect(command).not.toContain("${CLAUDE_PLUGIN_ROOT}");
+ expect(command).toContain(`${PLUGIN_ROOT}/scripts/`);
+ }
+ }
+ });
+
+ it("leaves the resolved script path unquoted, as agy's parser requires", () => {
+ // agy does not run `command` through a shell and does not strip quotes
+ // before splitting, so `node "<root>/x.mjs"` makes node look for a module
+ // whose name literally begins with a double quote. Verified on 1.0.15.
+ for (const bundle of Object.values(build())) {
+ for (const command of allCommands(bundle)) {
+ expect(command).not.toContain('"');
+ }
+ }
+ });
+
+ it("shapes tool events and lifecycle events the way agy parses them", () => {
+ // Only tool events take the { matcher, hooks } wrapper. Wrapping a
+ // lifecycle event makes agy reject the entire file, which silently
+ // disables every other bundle in it too. Verified on agy 1.0.15.
+ const bundle = build()["agentmemory"]!;
+ for (const event of ["PreToolUse", "PostToolUse"]) {
+ for (const entry of eventEntries(bundle, event)) {
+ expect(Array.isArray(entry.hooks), event).toBe(true);
+ expect(entry, event).not.toHaveProperty("command");
+ }
+ }
+ for (const event of ["PreInvocation", "Stop"]) {
+ for (const handler of handlers(bundle, event)) {
+ expect(handler.type, event).toBe("command");
+ expect(handler.command, event).toContain("antigravity-bridge.mjs");
+ expect(handler, event).not.toHaveProperty("hooks");
+ expect(handler, event).not.toHaveProperty("matcher");
+ }
+ }
+ });
+
+ it("flags a plugin path that agy could never execute", () => {
+ // Quoted or not, a space truncates the argument — there is no escaping
+ // form that works, so the installer has to refuse instead of writing a
+ // bundle that loads but never fires.
+ expect(containsSpaces("C:/Program Files/agentmemory/plugin")).toBe(true);
+ expect(containsSpaces("/opt/agentmemory/plugin")).toBe(false);
+ });
+
+ it("registers under a single named bundle, as Antigravity's schema requires", () => {
+ expect(Object.keys(build())).toEqual(["agentmemory"]);
+ expect(build()["agentmemory"]!["enabled"]).toBe(true);
+ });
+
+ it("only wires events Antigravity actually dispatches", () => {
+ const bundle = build()["agentmemory"]!;
+ const events = Object.keys(bundle).filter((k) => k !== "enabled");
+ // PostInvocation is intentionally unwired: PostToolUse already captures
+ // the work, so firing both would double-record every turn.
+ expect(events.sort()).toEqual(
+ ["PreInvocation", "PreToolUse", "PostToolUse", "Stop"].sort(),
+ );
+ });
+
+ it("scopes PreToolUse to the file tools agy actually exposes", () => {
+ const matcher = eventEntries(build()["agentmemory"], "PreToolUse")[0]!
+ .matcher!;
+ for (const tool of ["view_file", "edit_file", "write_to_file", "grep_search"]) {
+ expect(matcher.split("|")).toContain(tool);
+ }
+ // run_command is deliberately excluded — shell invocations are captured
+ // on PostToolUse, and matching them here would fire on every command.
+ expect(matcher.split("|")).not.toContain("run_command");
+ });
+
+ it("keeps user-authored hook bundles untouched", () => {
+ const existing: AntigravityHookManifest = {
+ "block-run-command": {
+ enabled: true,
+ PreToolUse: [
+ {
+ matcher: "run_command",
+ hooks: [{ type: "command", command: "/usr/local/bin/deny.sh" }],
+ },
+ ],
+ },
+ };
+ const merged = build(existing);
+ expect(merged["block-run-command"]).toEqual(existing["block-run-command"]);
+ expect(merged["agentmemory"]).toBeDefined();
+ });
+
+ it("replaces a stale agentmemory bundle instead of duplicating it", () => {
+ const stale: AntigravityHookManifest = {
+ "agentmemory-legacy": {
+ enabled: true,
+ Stop: [
+ {
+ hooks: [
+ {
+ type: "command",
+ command: `node "${PLUGIN_ROOT}/scripts/removed-hook.mjs" Stop`,
+ },
+ ],
+ },
+ ],
+ },
+ };
+ const merged = build(stale);
+ expect(merged["agentmemory-legacy"]).toBeUndefined();
+ expect(Object.keys(merged)).toEqual(["agentmemory"]);
+ });
+
+ it("recognises a stale bundle written in the flat lifecycle shape too", () => {
+ // Ownership detection has to see through both shapes, or a re-install
+ // leaves the old bundle behind and agy runs two copies of every hook.
+ const stale: AntigravityHookManifest = {
+ "agentmemory-legacy": {
+ enabled: true,
+ Stop: [
+ {
+ type: "command",
+ command: `node ${PLUGIN_ROOT}/scripts/removed-hook.mjs Stop`,
+ },
+ ],
+ },
+ };
+ expect(build(stale)["agentmemory-legacy"]).toBeUndefined();
+ });
+
+ it("re-install is idempotent", () => {
+ const first = build();
+ expect(build(first)).toEqual(first);
+ });
+
+ it("keeps a pluginRoot containing $-replacement patterns literal", () => {
+ // `String.prototype.replace` with a string argument reads `$$`, `$&`,
+ // "$`" and `$'` in the replacement as patterns. An install path holding
+ // any of them would otherwise be rewritten into a broken command, and
+ // the only symptom would be hooks that silently never fire.
+ const tmp = mkdtempSync(join(tmpdir(), "am-antigravity-"));
+ try {
+ const oddRoot = join(tmp, "plug$&$$in");
+ mkdirSync(join(oddRoot, "hooks"), { recursive: true });
+ copyFileSync(
+ join(PLUGIN_ROOT, "hooks", "hooks.antigravity.json"),
+ join(oddRoot, "hooks", "hooks.antigravity.json"),
+ );
+
+ const command = handlers(
+ buildMergedAntigravityHooks(null, oddRoot)["agentmemory"],
+ "Stop",
+ )[0]!.command;
+
+ expect(command).toContain(`${oddRoot}/scripts/`);
+ expect(command).not.toContain("${CLAUDE_PLUGIN_ROOT}");
+ } finally {
+ rmSync(tmp, { recursive: true, force: true });
+ }
+ });
+});
+
+describe("antigravity bridge payload normalization", () => {
+ it("maps conversationId and workspacePaths onto the canonical fields", () => {
+ const out = normalizePayload("PostToolUse", {
+ conversationId: "conv_123",
+ workspacePaths: ["/repo/app"],
+ transcriptPath: "/tmp/t.jsonl",
+ });
+ expect(out["session_id"]).toBe("conv_123");
+ expect(out["cwd"]).toBe("/repo/app");
+ expect(out["transcript_path"]).toBe("/tmp/t.jsonl");
+ expect(out["hook_event_name"]).toBe("PostToolUse");
+ });
+
+ it("flattens toolCall into tool_name/tool_input with Cascade names mapped", () => {
+ const out = normalizePayload("PreToolUse", {
+ conversationId: "c1",
+ toolCall: {
+ name: "view_file",
+ args: { AbsolutePath: "/repo/src/index.ts", StartLine: 1 },
+ },
+ });
+ expect(out["tool_name"]).toBe("read");
+ expect(out["native_tool_name"]).toBe("view_file");
+ expect((out["tool_input"] as Record<string, unknown>)["file_path"]).toBe(
+ "/repo/src/index.ts",
+ );
+ // Original PascalCase args survive for anything downstream that wants them.
+ expect((out["tool_input"] as Record<string, unknown>)["StartLine"]).toBe(1);
+ });
+
+ it("normalizes a payload captured verbatim from agy 1.0.15", () => {
+ // Recorded by pointing a probe hook at a live `agy --print` run. Note
+ // there is no `cwd` key at all, and `workspacePaths` came back empty in
+ // headless mode — the session id has to come from `conversationId`.
+ const out = normalizePayload("PreToolUse", {
+ artifactDirectoryPath:
+ "C:/Users/u/.gemini/antigravity-cli/brain/53642203-62f2-45e9-bda3-b1304c61bc99",
+ conversationId: "53642203-62f2-45e9-bda3-b1304c61bc99",
+ modelName: "gemini-3.6-flash-high",
+ stepIdx: 3,
+ toolCall: {
+ args: { DirectoryPath: "C:\\Users\\u\\.gemini\\antigravity-cli" },
+ name: "list_dir",
+ },
+ transcriptPath:
+ "C:/Users/u/.gemini/antigravity-cli/brain/53642203/.system_generated/logs/transcript_full.jsonl",
+ workspacePaths: [],
+ });
+
+ expect(out["session_id"]).toBe("53642203-62f2-45e9-bda3-b1304c61bc99");
+ expect(out["tool_name"]).toBe("glob");
+ expect(out["native_tool_name"]).toBe("list_dir");
+ expect((out["tool_input"] as Record<string, unknown>)["path"]).toBe(
+ "C:\\Users\\u\\.gemini\\antigravity-cli",
+ );
+ expect(out["transcript_path"]).toContain("transcript_full.jsonl");
+ // Fields agy sends that no bundled hook reads still survive the trip.
+ expect(out["modelName"]).toBe("gemini-3.6-flash-high");
+ expect(out["stepIdx"]).toBe(3);
+ });
+
+ it("maps every PascalCase arg the canonical hooks read", () => {
+ const cases: [string, string, string][] = [
+ ["AbsolutePath", "file_path", "/repo/a.ts"],
+ ["TargetFile", "file_path", "/repo/b.ts"],
+ ["DirectoryPath", "path", "/repo/src"],
+ ["SearchDirectory", "path", "/repo/test"],
+ ["Pattern", "pattern", "*.ts"],
+ ["Query", "pattern", "normalizePayload"],
+ ["CommandLine", "command", "npm test"],
+ ];
+ for (const [from, to, value] of cases) {
+ const input = normalizePayload("PreToolUse", {
+ toolCall: { name: "view_file", args: { [from]: value } },
+ })["tool_input"] as Record<string, unknown>;
+ expect(input[to], `${from} -> ${to}`).toBe(value);
+ // The original key survives alongside the canonical one.
+ expect(input[from], from).toBe(value);
+ }
+ });
+
+ it("does not let a mapped alias clobber an explicit canonical key", () => {
+ const input = normalizePayload("PreToolUse", {
+ toolCall: {
+ name: "edit_file",
+ args: { TargetFile: "/repo/alias.ts", file_path: "/repo/explicit.ts" },
+ },
+ })["tool_input"] as Record<string, unknown>;
+ expect(input["file_path"]).toBe("/repo/explicit.ts");
+ });
+
+ it("passes unmapped tool names through unchanged", () => {
+ const out = normalizePayload("PostToolUse", {
+ toolCall: { name: "run_command", args: { CommandLine: "npm test" } },
+ });
+ expect(out["tool_name"]).toBe("run_command");
+ expect((out["tool_input"] as Record<string, unknown>)["command"]).toBe(
+ "npm test",
+ );
+ });
+
+ it("falls back to a placeholder session id rather than dropping the event", () => {
+ expect(normalizePayload("Stop", {})["session_id"]).toBe("unknown");
+ });
+});
+
+describe("antigravity bridge stdout contract", () => {
+ // agy documents `decision` as required on PreToolUse output and treats a
+ // response without it as a denial — a bare `{}` there makes the agent
+ // refuse every matched tool call instead of passively capturing it.
+ it("answers PreToolUse with an explicit allow, everything else with {}", () => {
+ expect(JSON.parse(responseFor("PreToolUse"))).toEqual({
+ decision: "allow",
+ });
+ for (const event of ["PreInvocation", "PostToolUse", "Stop", ""]) {
+ expect(JSON.parse(responseFor(event)), event).toEqual({});
+ }
+ });
+
+ it("writes that contract to stdout when the bundled script actually runs", () => {
+ const script = join(PLUGIN_ROOT, "scripts", "antigravity-bridge.mjs");
+ const run = (event: string) =>
+ execFileSync(process.execPath, [script, event], {
+ input: JSON.stringify({
+ conversationId: "c1",
+ toolCall: { name: "view_file", args: { AbsolutePath: "/repo/a.ts" } },
+ }),
+ encoding: "utf-8",
+ // No server is listening on port 1, so every capture fetch fails
+ // fast: this asserts the response survives a failed capture, which
+ // is exactly the case where a swallowed error could emit nothing.
+ env: { ...process.env, AGENTMEMORY_URL: "http://127.0.0.1:1" },
+ stdio: ["pipe", "pipe", "ignore"],
+ });
+
+ expect(JSON.parse(run("PreToolUse"))).toEqual({ decision: "allow" });
+ expect(JSON.parse(run("PostToolUse"))).toEqual({});
+ });
+});
+
+describe("antigravity bridge event routing", () => {
+ it("opens the session on the first invocation only", () => {
+ expect(targetsFor("PreInvocation", { invocationNum: 1 })).toEqual([
+ "session-start.mjs",
+ "prompt-submit.mjs",
+ ]);
+ expect(targetsFor("PreInvocation", { invocationNum: 4 })).toEqual([
+ "prompt-submit.mjs",
+ ]);
+ });
+
+ it("treats a missing invocationNum as the first invocation", () => {
+ expect(targetsFor("PreInvocation", {})).toContain("session-start.mjs");
+ });
+
+ it("closes the session on Stop", () => {
+ expect(targetsFor("Stop", {})).toEqual(["stop.mjs", "session-end.mjs"]);
+ });
+
+ it("ignores PostInvocation to avoid double-capturing a turn", () => {
+ expect(targetsFor("PostInvocation", {})).toEqual([]);
+ });
+});
diff --git a/test/cli-connect.test.ts b/test/cli-connect.test.ts
index 46a1f240..ce43ac83 100644
--- a/test/cli-connect.test.ts
+++ b/test/cli-connect.test.ts
@@ -44,6 +44,7 @@ describe("agentmemory connect — dispatcher", () => {
expect(knownAgents().sort()).toEqual(
[
"antigravity",
+ "antigravity-cli",
"claude-code",
"cline",
"copilot-cli",
@@ -63,7 +64,7 @@ describe("agentmemory connect — dispatcher", () => {
"zed",
].sort(),
);
- expect(ADAPTERS.length).toBe(18);
+ expect(ADAPTERS.length).toBe(19);
});
it("every adapter exposes detect() and install()", () => {
diff --git a/test/connect-guidelines.test.ts b/test/connect-guidelines.test.ts
index 91727236..633aedc5 100644
--- a/test/connect-guidelines.test.ts
+++ b/test/connect-guidelines.test.ts
@@ -133,6 +133,7 @@ describe("guidelineTargets coverage", () => {
expect(names).toEqual(
[
"antigravity",
+ "antigravity-cli",
"cline",
"continue",
"copilot-cli",
diff --git a/tsdown.config.ts b/tsdown.config.ts
index 390a4df6..0c6426c1 100644
--- a/tsdown.config.ts
+++ b/tsdown.config.ts
@@ -14,6 +14,7 @@ const hookEntries = [
"src/hooks/stop.ts",
"src/hooks/session-end.ts",
"src/hooks/post-commit.ts",
+ "src/hooks/antigravity-bridge.ts",
];
const shared = {