@goodfoot/agent-hooks 1.0.8 → 1.0.10

package/dist/agents/antigravity/outputs.js

@@ -1,3 +1,14 @@
+/**
+ * Antigravity output builders, one per event.
+ *
+ * Unlike Claude Code and Codex, Antigravity gives each event a **different**
+ * stdout shape — there is no single envelope every event shares. `PreToolUse`
+ * returns a permission decision, `PostToolUse` returns `{}` and nothing else,
+ * the two invocation events return injected steps, and `Stop` returns a
+ * continue-or-not decision. Each builder below emits only the fields its own
+ * event's contract names; see `CONTRACT.md` in this directory.
+ * @module
+ */
 import { HookBlockError } from "../../core/transport.js";
 /**
  * Antigravity has no exit-code signaling channel: every event replies at
@@ -15,14 +26,16 @@ export const EXIT_CODES = {
  * **before** consulting `unexpectedError` policy — exactly mirroring Claude
  * Code's `HookBlockError` usage and Codex's `BlockError` re-export.
  *
- * This mechanism is a stated *prerequisite*, not a follow-up, for
- * Antigravity specifically: because every Antigravity event replies at exit
- * 0 with the decision expressed only in the JSON payload (Research, plan
- * Step 5), a handler that throws mid-decision has no narrower exit-code
- * fallback to land on the way Codex's stderr+exit-2 channel does — the block
- * decision would otherwise be indistinguishable from a swallowed crash. This
- * class landing is what makes it safe to ever widen `events.ts`'s advisory
- * allow-list past empty.
+ * The class matters more here than on the other two agents: because every
+ * Antigravity event replies at exit 0 with the decision expressed only in the
+ * JSON payload, a handler that throws mid-decision has no narrower exit-code
+ * fallback to land on the way Codex's stderr+exit-2 channel does. Without
+ * this class the block would be indistinguishable from a swallowed crash.
+ *
+ * The transport serializes it as `{ "decision": "deny", ... }`, which the
+ * host acts on for `PreToolUse` only. On the other four events the reply is
+ * well-formed but carries no decision the host recognizes, so it reads as an
+ * empty response.
  */
 export class AntigravityBlockError extends HookBlockError {
     reason;
@@ -41,41 +54,35 @@ function buildOutput(type, stdout) {
         stdout: omitUndefined(stdout),
     };
 }
+/** Builds a `PreToolUse` reply: a permission decision, optionally with argument overwrites. */
 export function preToolUseOutput(options = {}) {
     return buildOutput("PreToolUse", {
         decision: options.decision,
         reason: options.reason,
-        additionalContext: options.additionalContext,
-        updatedInput: options.updatedInput,
-        systemMessage: options.systemMessage,
+        permissionOverrides: options.permissionOverrides,
+        overwrite: options.overwrite,
     });
 }
-export function postToolUseOutput(options = {}) {
-    return buildOutput("PostToolUse", {
-        decision: options.decision,
-        reason: options.reason,
-        additionalContext: options.additionalContext,
-        systemMessage: options.systemMessage,
-    });
+/**
+ * Builds the `PostToolUse` reply. The contract defines the reply as an empty
+ * object, so this builder takes no options: there is nothing a `PostToolUse`
+ * handler can tell the host.
+ */
+export function postToolUseOutput() {
+    return buildOutput("PostToolUse", {});
 }
+/** Builds a `PreInvocation` reply carrying steps to inject before the model runs. */
 export function preInvocationOutput(options = {}) {
-    return buildOutput("PreInvocation", {
-        decision: options.decision,
-        reason: options.reason,
-        additionalContext: options.additionalContext,
-        systemMessage: options.systemMessage,
-    });
+    return buildOutput("PreInvocation", { injectSteps: options.injectSteps });
 }
+/** Builds a `PostInvocation` reply: injected steps, a termination override, or both. */
 export function postInvocationOutput(options = {}) {
     return buildOutput("PostInvocation", {
-        additionalContext: options.additionalContext,
-        systemMessage: options.systemMessage,
+        injectSteps: options.injectSteps,
+        terminationBehavior: options.terminationBehavior,
     });
 }
+/** Builds a `Stop` reply. `decision: "continue"` blocks the stop; `reason` is injected as a system message. */
 export function stopOutput(options = {}) {
-    return buildOutput("Stop", {
-        stop: options.stop,
-        reason: options.reason,
-        systemMessage: options.systemMessage,
-    });
+    return buildOutput("Stop", { decision: options.decision, reason: options.reason });
 }

package/dist/agents/antigravity/scaffold.js

@@ -0,0 +1,211 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { HOOK_FACTORY_TO_EVENT, PACKAGE_NAME } from "./constants.js";
+const IMPORT_SPECIFIER = `${PACKAGE_NAME}/antigravity`;
+const EVENT_NAMES = Object.values(HOOK_FACTORY_TO_EVENT);
+const EVENT_LOOKUP = new Map(EVENT_NAMES.map((event) => [event.toLowerCase(), event]));
+const EVENT_TO_FACTORY = Object.fromEntries(Object.entries(HOOK_FACTORY_TO_EVENT).map(([factory, event]) => [event, factory]));
+const EVENT_TO_OUTPUT = {
+    PreToolUse: "preToolUseOutput",
+    PostToolUse: "postToolUseOutput",
+    PreInvocation: "preInvocationOutput",
+    PostInvocation: "postInvocationOutput",
+    Stop: "stopOutput",
+};
+/** Resolves user-supplied hook names case-insensitively, rejecting the whole list on any miss. */
+export function validateHookNames(requested) {
+    const normalized = [];
+    const rejected = [];
+    for (const name of requested) {
+        const event = EVENT_LOOKUP.get(name.toLowerCase());
+        if (event === undefined) {
+            rejected.push(name);
+        }
+        else {
+            normalized.push(event);
+        }
+    }
+    if (rejected.length > 0) {
+        return {
+            valid: false,
+            error: `Invalid hook names: ${rejected.join(", ")}. Valid names: ${EVENT_NAMES.join(", ")}`,
+        };
+    }
+    return { valid: true, normalized };
+}
+function kebab(value) {
+    return value
+        .replace(/([a-z])([A-Z])/g, "$1-$2")
+        .replace(/([A-Z])([A-Z][a-z])/g, "$1-$2")
+        .toLowerCase();
+}
+function packageJson(projectName, outputPath) {
+    return `${JSON.stringify({
+        name: projectName,
+        version: "1.0.0",
+        type: "module",
+        scripts: {
+            build: `agent-hooks --agent antigravity -i "src/**/*.ts" -o "${outputPath}"`,
+            test: "vitest run",
+            lint: "biome check .",
+            typecheck: "tsc --noEmit",
+        },
+        dependencies: { [PACKAGE_NAME]: "^1.0.10" },
+        devDependencies: {
+            "@biomejs/biome": "2.4.9",
+            "@types/node": "^24.0.0",
+            typescript: "^5.9.3",
+            vitest: "^4.0.13",
+        },
+        engines: { node: ">=20.11.0" },
+    }, null, 2)}\n`;
+}
+function pluginJson(projectName) {
+    return `${JSON.stringify({
+        name: projectName,
+        version: "1.0.0",
+        description: `Antigravity hooks built with ${PACKAGE_NAME}`,
+    }, null, 2)}\n`;
+}
+function tsConfig() {
+    return `${JSON.stringify({
+        compilerOptions: {
+            target: "ES2022",
+            module: "NodeNext",
+            moduleResolution: "NodeNext",
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+        },
+        include: ["src/**/*.ts", "test/**/*.ts"],
+        exclude: ["dist", "node_modules"],
+    }, null, 2)}\n`;
+}
+function biomeConfig() {
+    return `{
+  "$schema": "https://biomejs.dev/schemas/2.4.9/schema.json",
+  "formatter": { "enabled": true, "indentStyle": "space", "indentWidth": 2, "lineWidth": 120 },
+  "linter": { "enabled": true, "rules": { "recommended": true } },
+  "assist": { "actions": { "source": { "organizeImports": "on" } } },
+  "files": { "includes": ["src/**/*.ts", "test/**/*.ts", "*.ts"] }
+}
+`;
+}
+function vitestConfig() {
+    return `import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: { include: ["test/**/*.test.ts"] },
+});
+`;
+}
+function readme(projectName, events) {
+    return `# ${projectName}
+
+Antigravity hooks built with \`${PACKAGE_NAME}\`. This project includes: ${events.map((event) => `\`${event}\``).join(", ")}.
+
+Run \`npm install\`, then \`npm run build\` to compile the hooks and write \`hooks.json\`. Antigravity reads that manifest from the plugin root and runs each command with its working directory set to the manifest's own directory, so the generated commands are relative and need no rewriting after install.
+
+Every hook replies at exit 0: Antigravity has no exit-code channel, and each decision travels inside the JSON payload on stdout.
+`;
+}
+function gitignore() {
+    return `bin/
+dist/
+node_modules/
+*.log
+`;
+}
+function hookSource(event) {
+    const factory = EVENT_TO_FACTORY[event];
+    const output = EVENT_TO_OUTPUT[event];
+    switch (event) {
+        case "PreToolUse":
+            return `import { ${factory}, ${output} } from "${IMPORT_SPECIFIER}";
+
+export default ${factory}({ matcher: "run_command" }, (input) => {
+  // Antigravity gives tool arguments no fixed schema, so narrow before reading.
+  const commandLine = input.toolCall.args.CommandLine;
+  if (typeof commandLine === "string" && commandLine.includes("rm -rf")) {
+    return ${output}({ decision: "deny", reason: "Refusing a destructive shell command." });
+  }
+  return ${output}({ decision: "allow" });
+});
+`;
+        case "PostToolUse":
+            return `import { ${factory}, ${output} } from "${IMPORT_SPECIFIER}";
+
+export default ${factory}({ matcher: "run_command" }, (input, { logger }) => {
+  // PostToolUse has no reply channel: the contract defines its output as {}.
+  // Report findings through the logger, never through stdout.
+  logger.info("Tool step finished", { stepIdx: input.stepIdx, error: input.error });
+  return ${output}();
+});
+`;
+        case "PreInvocation":
+            return `import { ${factory}, ${output} } from "${IMPORT_SPECIFIER}";
+
+export default ${factory}({}, () => {
+  return ${output}({
+    injectSteps: [{ ephemeralMessage: "Check for lint errors before proposing changes." }],
+  });
+});
+`;
+        case "PostInvocation":
+            return `import { ${factory}, ${output} } from "${IMPORT_SPECIFIER}";
+
+export default ${factory}({}, (input) => {
+  if (input.invocationNum < 2) {
+    return ${output}({ terminationBehavior: "force_continue" });
+  }
+  return ${output}({});
+});
+`;
+        case "Stop":
+            return `import { ${factory}, ${output} } from "${IMPORT_SPECIFIER}";
+
+export default ${factory}({}, (input) => {
+  if (!input.fullyIdle) {
+    return ${output}({ decision: "continue", reason: "Background tasks are still running." });
+  }
+  return ${output}({});
+});
+`;
+    }
+}
+function hookTest(event) {
+    return `import { describe, expect, it } from "vitest";
+import hook from "../src/${kebab(event)}.js";
+
+describe("${event} hook", () => {
+  it("exports a ${event} hook", () => {
+    expect(hook.hookEventName).toBe("${event}");
+  });
+});
+`;
+}
+/** Creates a new Antigravity hook project. Refuses to write into an existing directory. */
+export function scaffoldProject(options) {
+    const validation = validateHookNames(options.hooks);
+    if (!validation.valid) {
+        throw new Error(validation.error);
+    }
+    const { directory, outputPath } = options;
+    if (fs.existsSync(directory)) {
+        throw new Error(`Directory already exists: ${directory}`);
+    }
+    fs.mkdirSync(path.join(directory, "src"), { recursive: true });
+    fs.mkdirSync(path.join(directory, "test"), { recursive: true });
+    const projectName = path.basename(directory);
+    fs.writeFileSync(path.join(directory, "package.json"), packageJson(projectName, outputPath));
+    fs.writeFileSync(path.join(directory, "plugin.json"), pluginJson(projectName));
+    fs.writeFileSync(path.join(directory, "tsconfig.json"), tsConfig());
+    fs.writeFileSync(path.join(directory, "biome.json"), biomeConfig());
+    fs.writeFileSync(path.join(directory, "vitest.config.ts"), vitestConfig());
+    fs.writeFileSync(path.join(directory, ".gitignore"), gitignore());
+    fs.writeFileSync(path.join(directory, "README.md"), readme(projectName, validation.normalized));
+    for (const event of validation.normalized) {
+        fs.writeFileSync(path.join(directory, "src", `${kebab(event)}.ts`), hookSource(event));
+        fs.writeFileSync(path.join(directory, "test", `${kebab(event)}.test.ts`), hookTest(event));
+    }
+}

package/dist/agents/antigravity/transport.js

@@ -3,7 +3,7 @@
  * `drive()`/`Transport` interface — the same seam Claude Code's and Codex's
  * transports are rewritten/re-exported against.
  *
- * Antigravity's wire semantics are the simplest of the three shipped agents,
+ * Antigravity's wire semantics are the simplest of the four shipped agents,
  * and also the least forgiving: **every reply exits 0, unconditionally.**
  * There is no exit-code channel at all — not the 2-of-30-events native-deny
  * split Claude Code has, not Codex's uniform stderr+exit-2 `BlockError`
@@ -16,6 +16,8 @@
  *   ...fields }` on stdout at exit 0 — this is why the class is a stated
  *   prerequisite (`outputs.ts` module docs, `events.ts` module docs): with no
  *   exit-code fallback, a block computed mid-throw has nowhere else to land.
+ *   The host acts on that decision for `PreToolUse`; on the other four events
+ *   it is a well-formed reply carrying no decision the host recognizes.
  * - an unexpected handler/runtime failure → its stacktrace on stderr
  *   (diagnostic only, not a wire signal) plus the empty response `{}` on
  *   stdout, still at exit 0.

package/dist/agents/antigravity/types.js

@@ -1,11 +1,18 @@
 /**
- * Antigravity wire types (plan step 5, item-6 descope: typed factories +
- * output builders + conformance matrix only — no `CONTRACT.md` pin, no
- * published protocol doc exists for this release). Shapes below are the
- * minimal surface the plan names for the five shipped events
- * (`PreToolUse`/`PostToolUse`/`PreInvocation`/`PostInvocation`/`Stop`),
- * derived structurally from Claude Code's and Codex's `types.ts` rather than
- * from any Antigravity-specific reference — there is none to cite yet.
+ * Antigravity wire types, transcribed from the host's own hook reference.
+ *
+ * Source of record: `assets/external/skills/agy-customizations/docs/hooks.md`,
+ * embedded in the `agy` binary and pinned verbatim in this directory's
+ * `CONTRACT.md`. Nothing here is derived by analogy from Claude Code or
+ * Codex — the three agents' payloads share no field.
+ *
+ * Two properties of this contract drive every shape below:
+ *
+ * 1. **All keys are camelCase** (protojson encoding), including `stepIdx` and
+ *    `conversationId`.
+ * 2. **No payload carries its own event name.** Claude Code's
+ *    `hook_event_name` and Codex's equivalent have no counterpart here; a
+ *    handler knows its event only from the factory it was built with.
  * @module
  */
 export {};

package/dist/agents/codex/cli-support.js

@@ -15,7 +15,7 @@ import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import * as esbuild from "esbuild";
 import ts from "typescript";
-import { buildEsbuildLoaderMap, discoverHookSourceFiles, parseEsbuildLoaderFlag, pruneStaleHashedBundles, sha256Prefix8, symlinkVisiblePath, } from "../../cli.js";
+import { buildEsbuildLoaderMap, discoverHookSourceFiles, moduleWorkingDir, parseEsbuildLoaderFlag, pruneStaleHashedBundles, sha256Prefix8, symlinkVisiblePath, } from "../../cli.js";
 import { EVENTS_WITH_MATCHER, HOOK_FACTORY_TO_EVENT } from "./constants.js";
 /**
  * Extracts Codex hook metadata (event name, matcher, timeout in
@@ -88,9 +88,10 @@ export function analyzeCodexHookFile(sourcePath) {
  * Compiles one Codex hook to a self-contained ESM executable whose entry
  * wrapper imports this package's Codex runtime module (`execute`).
  */
-export async function compileCodexHook(sourcePath, loaders, sourcemap = true) {
+export async function compileCodexHook(sourcePath, loaders, sourcemap = false) {
     const resolveDir = path.dirname(sourcePath);
     const runtimePathAbsolute = symlinkVisiblePath(path.resolve(path.dirname(fileURLToPath(import.meta.url)), "./transport.js"), resolveDir);
+    const absWorkingDir = moduleWorkingDir(runtimePathAbsolute, resolveDir);
     let relativeRuntimePath = path.relative(resolveDir, runtimePathAbsolute).replace(/\\/g, "/");
     if (!relativeRuntimePath.startsWith(".")) {
         relativeRuntimePath = `./${relativeRuntimePath}`;
@@ -102,6 +103,7 @@ execute(hook);
 `;
     const baseName = path.basename(sourcePath, path.extname(sourcePath));
     const result = await esbuild.build({
+        absWorkingDir,
         stdin: {
             contents: wrapperContent,
             resolveDir,

package/dist/agents/codex/scaffold.js

@@ -55,7 +55,7 @@ function generatePackageJson(projectName, outputPath) {
             typecheck: "tsc --noEmit",
         },
         dependencies: {
-            [PACKAGE_NAME]: "^1.0.8",
+            [PACKAGE_NAME]: "^1.0.10",
         },
         devDependencies: {
             "@biomejs/biome": "2.4.9",

package/dist/agents/opencode/cli-support.js

@@ -23,7 +23,7 @@ import { buildEsbuildLoaderMap, discoverHookSourceFiles, parseEsbuildLoaderFlag
  * Bundles one OpenCode plugin entry to a self-contained ESM artifact. The
  * source file's own default export is preserved unchanged — no wrapper.
  */
-export async function compileOpenCodePlugin(sourcePath, loaders, sourcemap = true) {
+export async function compileOpenCodePlugin(sourcePath, loaders, sourcemap = false) {
     const result = await esbuild.build({
         entryPoints: [sourcePath],
         loader: loaders,

package/dist/cli.js

@@ -26,7 +26,7 @@ import { scaffoldProject } from "./scaffold.js";
 // ============================================================================
 // Constants
 // ============================================================================
-const VERSION = "1.0.8";
+const VERSION = "1.0.10";
 const DEFAULT_ESBUILD_LOADERS = {
     ".md": "text",
 };
@@ -71,6 +71,10 @@ Required Arguments:
       bundle. There is no default: omitting this flag is an error.
       With --agent opencode, -o/--output is treated as a plugin artifact
       directory (no hooks.json manifest is generated).
+      With --agent antigravity, -o/--output is the hooks.json path at the
+      plugin root; bundles are written to a bin/ directory beside it and the
+      generated commands are relative to the manifest, which is the working
+      directory Antigravity runs each handler in.
       Example: --agent claude-code
 
 Build Mode (compile existing hooks):
@@ -94,6 +98,8 @@ Scaffold Mode (create new hook project):
       Valid types: PreToolUse, PostToolUse, PostToolUseFailure, Notification,
                    UserPromptSubmit, SessionStart, SessionEnd, Stop,
                    SubagentStart, SubagentStop, PreCompact, PermissionRequest
+      With --agent antigravity the valid types are: PreToolUse, PostToolUse,
+                   PreInvocation, PostInvocation, Stop
       Example: --hooks Stop,SubagentStop,PreToolUse
 
   -o, --output <path>
@@ -136,13 +142,13 @@ Optional Arguments:
   --no-stable-names
       Restore the pre-1.7 behavior: hashed compiled bundles (<name>.<hash>.mjs).
 
-  --sourcemap (default)
+  --sourcemap
       Embed an inline sourcemap in each compiled bundle so stack traces show
       original TypeScript source locations.
 
-  --no-sourcemap
-      Emit bundles without the inline sourcemap, shrinking compiled output by
-      roughly 85-90%. The content hash is unaffected.
+  --no-sourcemap (default)
+      Emit bundles without the inline sourcemap, shrinking compiled output.
+      The content hash is unaffected.
 
   -h, --help
       Show this help message.
@@ -251,7 +257,7 @@ function parseArgs(argv) {
         // as true, while the Codex branch defaults by command context
         // (plugin mode → stable, otherwise hashed).
         stableNames: undefined,
-        sourcemap: true,
+        sourcemap: false,
     };
     for (let i = 0; i < argv.length; i++) {
         const arg = argv[i];
@@ -636,6 +642,28 @@ function symlinkVisiblePath(realPath, resolveDir) {
         dir = parent;
     }
 }
+/**
+ * Returns the stable project anchor for a module reached through node_modules.
+ *
+ * esbuild otherwise uses process.cwd() when rendering module-boundary comments
+ * and sourcemap source paths. A workspace script normally runs from the
+ * consuming package, while its dependencies may be hoisted several directories
+ * higher, making those emitted paths depend on the consumer's nesting depth.
+ * Anchoring at the directory which owns the visible node_modules keeps the
+ * canonical `node_modules/...` form in every such layout.
+ */
+function moduleWorkingDir(modulePath, fallback) {
+    for (let dir = path.dirname(modulePath);;) {
+        if (path.basename(dir) === "node_modules") {
+            return path.dirname(dir);
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            return fallback;
+        }
+        dir = parent;
+    }
+}
 /**
  * Compiles a TypeScript hook file to a self-contained ESM executable.
  *
@@ -666,6 +694,7 @@ async function compileHook(options) {
     // nesting depth.
     const resolveDir = path.dirname(sourcePath);
     const runtimePathAbsolute = symlinkVisiblePath(path.resolve(path.dirname(fileURLToPath(import.meta.url)), "./agents/claude-code/transport.js"), resolveDir);
+    const absWorkingDir = moduleWorkingDir(runtimePathAbsolute, resolveDir);
     // Compute relative paths from resolveDir to avoid absolute paths in source maps.
     // This ensures reproducible builds regardless of checkout directory.
     const relativeSourcePath = `./${path.basename(sourcePath)}`;
@@ -725,6 +754,7 @@ execute(hook);
     ].join("\n");
     // Common esbuild options
     const commonOptions = {
+        absWorkingDir,
         stdin: stdinOptions,
         loader: loaders,
         format: "esm",
@@ -778,7 +808,7 @@ execute(hook);
     // output minus the trailing sourceMappingURL comment (verified on esbuild
     // 0.24.2), so the sourcemap-free content is emitted directly. The content
     // hash is always derived from pass-1 output, so it is unchanged by the flag.
-    if (sourcemap === false) {
+    if (sourcemap !== true) {
         return { content: contentForHash, contentHash };
     }
     const resultWithSourcemap = await esbuild.build({
@@ -1252,9 +1282,61 @@ async function main() {
             closeLog();
         }
     }
-    // Antigravity ships in step 5; fail closed until then.
+    // Antigravity's manifest shape has no counterpart in the other agents: the
+    // top-level keys are hook names, only two of the five events wrap their
+    // handlers in a matcher group, and the host sets each handler's working
+    // directory to the manifest's own directory. See
+    // src/agents/antigravity/CONTRACT.md.
+    if (args.agent === "antigravity") {
+        const { runAntigravityCli, validateAntigravityArgs } = await import("./agents/antigravity/cli-support.js");
+        const antigravityValidationError = validateAntigravityArgs({
+            input: args.input,
+            output: args.output,
+            loaderFlags: args.loaderFlags ?? [],
+            sourcemap: args.sourcemap,
+            stableNames: args.stableNames,
+            scaffold: args.scaffold,
+            hooks: args.hooks,
+        });
+        if (antigravityValidationError !== undefined) {
+            process.stderr.write(`Error: ${antigravityValidationError}\n\n`);
+            process.stdout.write(HELP_TEXT);
+            process.exit(1);
+        }
+        try {
+            const compiledCount = await runAntigravityCli({
+                input: args.input,
+                output: args.output,
+                executable: args.executable,
+                loaderFlags: args.loaderFlags ?? [],
+                sourcemap: args.sourcemap,
+                stableNames: args.stableNames,
+                scaffold: args.scaffold,
+                hooks: args.hooks,
+            });
+            if (args.scaffold !== undefined && args.scaffold !== "") {
+                process.stdout.write(`Scaffolded ${path.resolve(process.cwd(), args.scaffold)}\n`);
+            }
+            else {
+                process.stdout.write(`Generated ${path.resolve(process.cwd(), args.output)} with ${compiledCount} hook(s)\n`);
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            log("error", "Antigravity build failed", { error: message });
+            process.stderr.write(`Error: ${message}\n`);
+            process.exit(1);
+        }
+        finally {
+            closeLog();
+        }
+    }
+    // Everything below is the Claude Code path. Each other agent returns from
+    // its own branch above, so reaching here with a different agent would mean
+    // a branch was removed without removing its VALID_AGENTS entry.
     if (args.agent !== "claude-code") {
-        process.stderr.write(`Error: --agent ${args.agent} is not implemented in this release; only "claude-code", "codex", and "opencode" build today (antigravity ships in step 5).\n`);
+        process.stderr.write(`Error: --agent ${args.agent} has no build branch.\n`);
         process.exit(1);
     }
     // Handle scaffold mode
@@ -1389,4 +1471,4 @@ if (isDirectExecution) {
 // Shared build primitives reused by the per-agent CLI branches (single
 // source for driver logic — the duplication check forbids re-deriving these
 // inside agents/*).
-export { analyzeHookFile, buildLoaderMap, buildLoaderMap as buildEsbuildLoaderMap, compileHook, detectHookContext, discoverHookFiles, discoverHookFiles as discoverHookSourceFiles, extractPreservedHooks, generateCommandPath, generateContentHash, generateContentHash as sha256Prefix8, generateHooksJson, groupHooksByEventAndMatcher, HOOK_FACTORY_TO_EVENT, mergeHooksJson, parseArgs, parseLoaderFlag, parseLoaderFlag as parseEsbuildLoaderFlag, pruneStaleHashedBundles, readExistingHooksJson, removeOldGeneratedFiles, symlinkVisiblePath, validateArgs, };
+export { analyzeHookFile, buildLoaderMap, buildLoaderMap as buildEsbuildLoaderMap, compileHook, detectHookContext, discoverHookFiles, discoverHookFiles as discoverHookSourceFiles, extractPreservedHooks, generateCommandPath, generateContentHash, generateContentHash as sha256Prefix8, generateHooksJson, groupHooksByEventAndMatcher, HOOK_FACTORY_TO_EVENT, mergeHooksJson, moduleWorkingDir, parseArgs, parseLoaderFlag, parseLoaderFlag as parseEsbuildLoaderFlag, pruneStaleHashedBundles, readExistingHooksJson, removeOldGeneratedFiles, symlinkVisiblePath, validateArgs, };

package/dist/index.js

@@ -6,8 +6,8 @@
  * {@link HookBlockError}, the Logger, env utilities, and stdin helpers.
  *
  * Per-agent entry points (`@goodfoot/agent-hooks/claude-code`, `/codex`,
- * `/antigravity`) are added to the package `exports` map only in the step
- * that lands their implementation — never pre-declared.
+ * `/opencode`, `/antigravity`) expose each host's native protocol without
+ * leaking host-specific types through this root module.
  * @module
  */
 export { defineHook } from "./core/define-hook.js";

package/dist/scaffold.js

@@ -131,7 +131,7 @@ function generatePackageJson(projectName, outputPath) {
             typecheck: "tsc --noEmit",
         },
         dependencies: {
-            "@goodfoot/agent-hooks": "^1.0.8",
+            "@goodfoot/agent-hooks": "^1.0.10",
         },
         devDependencies: {
             "@biomejs/biome": "2.4.16",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodfoot/agent-hooks",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Unified agent hooks library: shared core runtime with per-agent entry points for Claude Code, Codex, and Antigravity",
   "homepage": "https://github.com/goodfoot-io/marketplace/tree/main/packages/agent-hooks",
   "repository": {
@@ -43,6 +43,10 @@
     "./opencode": {
       "import": "./dist/agents/opencode/index.js",
       "types": "./types/agents/opencode/index.d.ts"
+    },
+    "./antigravity": {
+      "import": "./dist/agents/antigravity/index.js",
+      "types": "./types/agents/antigravity/index.d.ts"
     }
   },
   "bin": "./dist/cli.js",