portable-agent-layer 0.88.0 → 0.89.0

package/src/hooks/lib/inference.ts

@@ -25,12 +25,20 @@ import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import {
   getActiveAgent,
+  isAntigravity,
   isClaude,
   isCodex,
   isCopilot,
   isCursor,
   isOpencode,
 } from "./agent";
+import {
+  extractAntigravityText,
+  INFERENCE_AGENT,
+  removeSpawnedConversation,
+  streamJsonPrompt,
+  writeInferenceAgent,
+} from "./antigravity-inference";
 import { logDebug, logError } from "./log";
 import {
   type FixedModelRoute,
@@ -108,6 +116,8 @@ function previewRoute(): RoutePreview {
     return { agent, route: "copilot-spawn", reason: "copilot binary on PATH" };
   if (isCursor() && hasCursorBinary())
     return { agent, route: "cursor-spawn", reason: "cursor-agent binary on PATH" };
+  if (isAntigravity() && hasAntigravityBinary())
+    return { agent, route: "antigravity-spawn", reason: "agy binary on PATH" };
   if (hasApiKey())
     return {
       agent,
@@ -130,6 +140,7 @@ export function canInfer(): boolean {
   if (isOpencode() && hasOpencodeBinary()) return true;
   if (isCopilot() && hasCopilotBinary()) return true;
   if (isCursor() && hasCursorBinary()) return true;
+  if (isAntigravity() && hasAntigravityBinary()) return true;
   return hasApiKey();
 }
 
@@ -218,13 +229,23 @@ export async function inference(opts: InferenceOptions): Promise<InferenceResult
       return inferenceViaCliSpawn(bin, buildCursorArgs(opts), buildCliPrompt(opts), opts);
     }
   }
+  if (isAntigravity()) {
+    const bin = getAntigravityBinary();
+    if (bin) {
+      logDebug(
+        "inference",
+        `${tag} route=antigravity-spawn agent=${agent} model=${modelFor("antigravity-spawn", opts)}`
+      );
+      return inferenceViaAntigravitySpawn(bin, opts);
+    }
+  }
   if (hasApiKey()) {
     logDebug("inference", `${tag} route=anthropic-api agent=${agent}`);
     return inferenceViaApi(opts);
   }
   logDebug(
     "inference",
-    `${tag} route=none agent=${agent} hasApiKey=false hasOpenAiKey=${hasOpenAiKey()} hasClaude=${hasClaudeBinary()} hasCodex=${hasCodexBinary()} hasOpencode=${hasOpencodeBinary()} hasCopilot=${hasCopilotBinary()} hasCursor=${hasCursorBinary()}`
+    `${tag} route=none agent=${agent} hasApiKey=false hasOpenAiKey=${hasOpenAiKey()} hasClaude=${hasClaudeBinary()} hasCodex=${hasCodexBinary()} hasOpencode=${hasOpencodeBinary()} hasCopilot=${hasCopilotBinary()} hasCursor=${hasCursorBinary()} hasAgy=${hasAntigravityBinary()}`
   );
   return { success: false };
 }
@@ -261,6 +282,10 @@ function getCursorBinary(): string | null {
   return cachedBinary("cursor-agent");
 }
 
+function getAntigravityBinary(): string | null {
+  return cachedBinary("agy");
+}
+
 function hasClaudeBinary(): boolean {
   return getClaudeBinary() !== null;
 }
@@ -276,6 +301,9 @@ function hasCopilotBinary(): boolean {
 function hasCursorBinary(): boolean {
   return getCursorBinary() !== null;
 }
+function hasAntigravityBinary(): boolean {
+  return getAntigravityBinary() !== null;
+}
 
 /**
  * Build the argv for `claude --print …`. Pure.
@@ -469,6 +497,51 @@ export function buildCursorArgs(_opts: InferenceOptions): string[] {
   return ["-p", "--mode", "ask", "--output-format", "text", "--trust"];
 }
 
+/**
+ * Build the argv for a one-turn `agy` stream-json session. Pure.
+ *
+ * The prompt goes in as one NDJSON `user` event on stdin (streamJsonPrompt), not
+ * through `-p`: a multi-paragraph argv element cannot survive cmd.exe on Windows,
+ * and stream-json input drops a `-p` prompt anyway. Closing stdin ends the
+ * session once the turn's `result` event is out.
+ *
+ * `--json-schema` is deliberately absent: under the tool-less agent it looped
+ * through several turns, so the schema rides in the prompt as for every other CLI.
+ */
+export function buildAntigravityArgs(opts: InferenceOptions): string[] {
+  return [
+    "--input-format",
+    "stream-json",
+    "--output-format",
+    "stream-json",
+    "--model",
+    modelFor("antigravity-spawn", opts),
+    "--agent",
+    INFERENCE_AGENT,
+  ];
+}
+
+/** Runs from an empty workspace that holds only the tool-less inference agent. */
+async function inferenceViaAntigravitySpawn(
+  bin: string,
+  opts: InferenceOptions
+): Promise<InferenceResult> {
+  const dir = await mkdtemp(join(tmpdir(), "pal-antigravity-"));
+  try {
+    writeInferenceAgent(dir);
+    return await inferenceViaCliSpawn(
+      bin,
+      buildAntigravityArgs(opts),
+      streamJsonPrompt(buildCliPrompt(opts)),
+      opts,
+      extractAntigravityText,
+      { cwd: dir, afterRun: removeSpawnedConversation }
+    );
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
 /**
  * Build the argv for `copilot -p …` from inference options. Pure.
  *
@@ -683,6 +756,8 @@ interface SpawnPlace {
   cwd?: string;
   env?: Record<string, string | undefined>;
   logTag?: string;
+  /** Sees the final attempt's stdout whatever the outcome, timeouts included. */
+  afterRun?: (rawStdout: string) => void;
 }
 
 /**
@@ -731,6 +806,7 @@ async function inferenceViaCliSpawn(
     attempt = await singleCliAttempt(binary, args, stdinInput, env, timeout, place.cwd);
   }
 
+  place.afterRun?.(attempt.stdout);
   const elapsedMs = Date.now() - started;
   const finish = (result: InferenceResult): InferenceResult => {
     logDebug(

package/src/hooks/lib/invocation-context.ts

@@ -0,0 +1,99 @@
+/**
+ * Antigravity's PreInvocation, which stands in for both SessionStart and
+ * UserPromptSubmit: agy has neither, and fires this before every model call.
+ *
+ * Only the first call of a turn (`invocationNum` 0) carries a new prompt. Its
+ * one reply injects a `userMessage` step, which agy keeps for the rest of the
+ * conversation — so the session context goes in once per conversation and the
+ * prompt context once per turn.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { getPromptContext } from "../handlers/inject-retrieval";
+import { latestUserRequest } from "./antigravity-transcript";
+import { autoUpdateOnStart } from "./auto-update";
+import { regenerateIfNeeded } from "./claude-md";
+import { buildSystemReminder } from "./context";
+import { type HookTurnPayload, hookSessionId } from "./hook-turn";
+import { logContextSnapshot, logError, logPromptSnapshot } from "./log";
+import { paths } from "./paths";
+import { capturePrompt } from "./prompt-capture";
+
+export interface InvocationPayload extends HookTurnPayload {
+  invocationNum?: number;
+  transcriptPath?: string;
+}
+
+const REMEMBERED_CONVERSATIONS = 200;
+
+function startedFile(): string {
+  return resolve(paths.state(), "antigravity-conversations.json");
+}
+
+function startedConversations(): string[] {
+  try {
+    const file = startedFile();
+    return existsSync(file) ? JSON.parse(readFileSync(file, "utf-8")) : [];
+  } catch {
+    return [];
+  }
+}
+
+/** True exactly once per conversation: the call that gets to start it. */
+function claimConversationStart(conversationId: string): boolean {
+  const started = startedConversations();
+  if (started.includes(conversationId)) return false;
+  const kept = [...started, conversationId].slice(-REMEMBERED_CONVERSATIONS);
+  writeFileSync(startedFile(), JSON.stringify(kept), "utf-8");
+  return true;
+}
+
+function attempt(label: string, work: () => unknown): void {
+  try {
+    work();
+  } catch (err) {
+    logError(`InvocationContext:${label}`, err);
+  }
+}
+
+function sessionStartReminder(): string {
+  attempt("regenerate", regenerateIfNeeded);
+  attempt("auto-update", autoUpdateOnStart);
+  const reminder = buildSystemReminder({ agent: "claude" });
+  if (reminder) logContextSnapshot(reminder);
+  return reminder;
+}
+
+async function promptReminder(prompt: string, conversationId: string) {
+  const context = await getPromptContext(prompt, conversationId);
+  logPromptSnapshot(prompt, context);
+  return context;
+}
+
+/** The agy reply that adds `text` to the conversation as one user step. */
+function injectedStep(text: string): string {
+  return JSON.stringify({ injectSteps: [{ userMessage: text }] });
+}
+
+/** What PreInvocation should print, or null to print nothing. */
+export async function invocationContext(
+  payload: InvocationPayload,
+  sentAt: Date = new Date()
+): Promise<string | null> {
+  const conversationId = hookSessionId(payload);
+  if (payload.invocationNum !== 0 || !conversationId || !payload.transcriptPath) {
+    return null;
+  }
+
+  const prompt = latestUserRequest(payload.transcriptPath);
+  if (prompt === null) return null;
+
+  const parts = [
+    claimConversationStart(conversationId) ? sessionStartReminder() : null,
+    await promptReminder(prompt, conversationId),
+  ].filter((part): part is string => Boolean(part));
+  await capturePrompt(prompt, conversationId, sentAt, "InvocationContext");
+
+  return parts.length > 0 ? injectedStep(parts.join("\n\n")) : null;
+}

package/src/hooks/lib/ledger-hook.ts

@@ -8,7 +8,7 @@
 
 import { existsSync, readFileSync } from "node:fs";
 import { isAbsolute, resolve } from "node:path";
-import { normalizeToolUse } from "./agent";
+import { ANTIGRAVITY_WRITE_TOOLS, FILE_TARGET_KEYS, normalizeToolUse } from "./agent";
 import {
   claimPending,
   type LedgerEntry,
@@ -38,6 +38,7 @@ const LEDGERED_TOOLS = new Set([
   "insert",
   "str_replace",
   "str_replace_editor",
+  ...ANTIGRAVITY_WRITE_TOOLS,
 ]);
 
 /**
@@ -53,9 +54,6 @@ const PATCHING_TOOLS = new Set(["apply_patch", "applypatch"]);
  */
 const READING_COMMANDS = new Set(["view"]);
 
-/** Agents disagree on the spelling; the value is the same file either way. */
-const TARGET_KEYS = ["file_path", "filePath", "path"];
-
 /** Every header in the V4A patch format that names a file the patch changes. */
 const PATCHED_FILE_HEADER = /^\*\*\* (?:Add|Update|Delete) File: (.+)$/gm;
 
@@ -153,7 +151,7 @@ function derivedPairingKey(anchor: string, tool: string, target: string): string
 }
 
 function sessionOf(payload: Record<string, unknown>): string | null {
-  const session = payload.sessionId ?? payload.session_id;
+  const session = payload.sessionId ?? payload.session_id ?? payload.conversationId;
   return typeof session === "string" && session.length > 0 ? session : null;
 }
 
@@ -229,6 +227,16 @@ export function snapshotCall(call: LedgeredCall): void {
   savePending({ ...call, before: contentsOf(call.target), ts: new Date().toISOString() });
 }
 
+/** Antigravity fires PostToolUse for a failed call too, and says so only in `error`. */
+function reportsFailure(payload: Record<string, unknown>): boolean {
+  return typeof payload.error === "string" && payload.error.length > 0;
+}
+
+/** The calls in a post-tool payload whose change actually reached the disk. */
+export function landedCalls(payload: Record<string, unknown>): LedgeredCall[] {
+  return reportsFailure(payload) ? [] : ledgeredCalls(payload);
+}
+
 /** Pair a parked before-state with the result, or nothing if none was parked. */
 export function commitApplied(call: LedgeredCall): LedgerEntry | null {
   const pending = claimPending(call.toolUseId);
@@ -303,7 +311,7 @@ export function ledgeredTarget(
 ): string | null {
   if (!LEDGERED_TOOLS.has(toolName.toLowerCase())) return null;
   if (readsRatherThanChanges(toolInput)) return null;
-  for (const key of TARGET_KEYS) {
+  for (const key of FILE_TARGET_KEYS) {
     const value = toolInput[key];
     if (typeof value === "string" && value.length > 0) return value;
   }

package/src/hooks/lib/models.ts

@@ -14,21 +14,40 @@ export type FixedModelRoute =
   | "claude-spawn"
   | "anthropic-api"
   | "codex-spawn"
-  | "openai-api";
+  | "openai-api"
+  | "antigravity-spawn";
 
-const ANTHROPIC_MODELS = { small: HAIKU_MODEL, medium: SONNET_MODEL };
-const OPENAI_MODELS = { small: "gpt-6-luna", medium: "gpt-6-sol" };
+/** `large` is the flagship that authors skills and subagents; without one, the agent authors inline. */
+type RouteModels = Record<InferenceTier, string> & { large?: string };
+
+const ANTHROPIC_MODELS: RouteModels = {
+  small: HAIKU_MODEL,
+  medium: SONNET_MODEL,
+  large: FABLE_MODEL,
+};
+const OPENAI_MODELS: RouteModels = {
+  small: "gpt-6-luna",
+  medium: "gpt-6-sol",
+  large: "gpt-6-astra",
+};
+/** An Antigravity subagent's `model:` takes only a tier name, so `large` is `pro`. */
+const GEMINI_MODELS: RouteModels = {
+  small: "gemini-3.8-flash-low",
+  medium: "gemini-3.8-flash-high",
+  large: "pro",
+};
 
 /**
  * opencode's models come from the user's own config (opencodeTierModel). Copilot and
  * Cursor are absent on purpose: which named models they accept depends on the user's
  * plan, and a free plan refuses every one but Auto.
  */
-const INFERENCE_MODELS: Record<FixedModelRoute, Record<InferenceTier, string>> = {
+const INFERENCE_MODELS: Record<FixedModelRoute, RouteModels> = {
   "claude-spawn": ANTHROPIC_MODELS,
   "anthropic-api": ANTHROPIC_MODELS,
   "codex-spawn": OPENAI_MODELS,
   "openai-api": OPENAI_MODELS,
+  "antigravity-spawn": GEMINI_MODELS,
 };
 
 export function isFixedModelRoute(route: string): route is FixedModelRoute {
@@ -42,22 +61,20 @@ export function inferenceModel(
   return INFERENCE_MODELS[route][tier];
 }
 
-/**
- * Per-agent flagship model used to AUTHOR new skills (via `create-skill`).
- *
- * This is the single extension point for delegated skill authoring: an agent
- * present here → `create-skill` spins up that agent's `skill-author` subagent on
- * this model; an agent absent → `create-skill` authors inline. Add a provider by
- * adding one entry (and a matching platform block in assets/agents/skill-author.md).
- */
-export const FLAGSHIP_AUTHOR_MODEL: Partial<Record<AgentType, string>> = {
-  claude: FABLE_MODEL,
-  // codex: "gpt-5.5",   // enable once Codex ships a tool-capable flagship subagent
+const AGENT_SPAWN_ROUTE: Partial<Record<AgentType, FixedModelRoute>> = {
+  claude: "claude-spawn",
+  codex: "codex-spawn",
+  antigravity: "antigravity-spawn",
 };
 
-/** Flagship authoring model for an agent, or undefined if none is configured. */
+/**
+ * The model an agent's `skill-author` / `subagent-author` runs on, or undefined
+ * when `create-skill` and `create-subagent` should author inline. A new provider
+ * needs a `large` model on its route and a platform block in assets/agents/*-author.md.
+ */
 export function flagshipAuthorModel(agent: AgentType): string | undefined {
-  return FLAGSHIP_AUTHOR_MODEL[agent];
+  const route = AGENT_SPAWN_ROUTE[agent];
+  return route ? INFERENCE_MODELS[route].large : undefined;
 }
 
 export interface ModelPricing {

package/src/hooks/lib/paths.ts

@@ -120,13 +120,43 @@ export const paths = {
 
 // Platform directories (env override or cross-platform defaults)
 const h = homedir();
+
+const AGENT_DIR_DEFAULTS = {
+  PAL_CLAUDE_DIR: [".claude"],
+  PAL_OPENCODE_DIR: [".config", "opencode"],
+  PAL_CURSOR_DIR: [".cursor"],
+  PAL_COPILOT_DIR: [".copilot"],
+  PAL_CODEX_DIR: [".codex"],
+  PAL_GEMINI_DIR: [".gemini"],
+  PAL_AGENTS_DIR: [".agents"],
+} as const;
+
+type AgentDirOverride = keyof typeof AGENT_DIR_DEFAULTS;
+
+const defaultAgentDir = (env: AgentDirOverride) => resolve(h, ...AGENT_DIR_DEFAULTS[env]);
+
+const agentDir = (env: AgentDirOverride) => () => envPath(env, defaultAgentDir(env));
+
+/** Every agent dir override with the real directory it replaces. */
+export function agentDirOverrides(): { env: AgentDirOverride; realDir: string }[] {
+  return (Object.keys(AGENT_DIR_DEFAULTS) as AgentDirOverride[]).map((env) => ({
+    env,
+    realDir: defaultAgentDir(env),
+  }));
+}
+
+const geminiDir = agentDir("PAL_GEMINI_DIR");
+
 export const platform = {
-  claudeDir: () => envPath("PAL_CLAUDE_DIR", resolve(h, ".claude")),
-  opencodeDir: () => envPath("PAL_OPENCODE_DIR", resolve(h, ".config", "opencode")),
-  cursorDir: () => envPath("PAL_CURSOR_DIR", resolve(h, ".cursor")),
-  copilotDir: () => envPath("PAL_COPILOT_DIR", resolve(h, ".copilot")),
-  codexDir: () => envPath("PAL_CODEX_DIR", resolve(h, ".codex")),
-  agentsDir: () => envPath("PAL_AGENTS_DIR", resolve(h, ".agents")),
+  claudeDir: agentDir("PAL_CLAUDE_DIR"),
+  opencodeDir: agentDir("PAL_OPENCODE_DIR"),
+  cursorDir: agentDir("PAL_CURSOR_DIR"),
+  copilotDir: agentDir("PAL_COPILOT_DIR"),
+  codexDir: agentDir("PAL_CODEX_DIR"),
+  antigravityPluginDir: () => resolve(geminiDir(), "config", "plugins", "pal"),
+  antigravityCliDir: () => resolve(geminiDir(), "antigravity-cli"),
+  antigravitySettings: () => resolve(geminiDir(), "antigravity-cli", "settings.json"),
+  agentsDir: agentDir("PAL_AGENTS_DIR"),
 } as const;
 
 // Engine/asset paths (in PAL_PKG / repo root)
@@ -140,6 +170,9 @@ export const assets = {
   cursorHooksTemplate: () => pkg("assets", "templates", "hooks.cursor.json"),
   copilotHooksTemplate: () => pkg("assets", "templates", "hooks.copilot.json"),
   codexHooksTemplate: () => pkg("assets", "templates", "hooks.codex.json"),
+  antigravityHooksTemplate: () => pkg("assets", "templates", "hooks.antigravity.json"),
+  antigravitySettingsTemplate: () =>
+    pkg("assets", "templates", "settings.antigravity.json"),
   codexRulesTemplate: () => pkg("assets", "templates", "rules.codex.rules"),
   statuslineScriptBash: () => pkg("assets", "statusline.sh"),
   statuslineScriptPs1: () => pkg("assets", "statusline.ps1"),

package/src/hooks/lib/prompt-capture.ts

@@ -0,0 +1,28 @@
+/**
+ * What every prompt hook records about the prompt itself, whichever event the
+ * agent delivers it on. Each handler is independent, so one failing is logged
+ * and never stops the other.
+ */
+
+import { captureRating } from "../handlers/rating";
+import { captureSessionName } from "../handlers/session-name";
+import { logError } from "./log";
+
+const HANDLER_NAMES = ["rating", "session-name"];
+
+export async function capturePrompt(
+  prompt: string,
+  sessionId: string | undefined,
+  sentAt: Date,
+  caller: string
+): Promise<void> {
+  const results = await Promise.allSettled([
+    captureRating(prompt, sessionId, sentAt),
+    captureSessionName(prompt, sessionId ?? ""),
+  ]);
+  results.forEach((result, i) => {
+    if (result.status === "rejected") {
+      logError(`${caller}:${HANDLER_NAMES[i]}`, result.reason);
+    }
+  });
+}

package/src/hooks/lib/prompt-text.ts

@@ -17,6 +17,7 @@ const SYSTEM_TEXT_PATTERNS = [
   /^Please continue the conversation/i,
   /^Note:.*was read before/i,
   /^Another Claude session sent a message:/i,
+  /^<agent-message\b/i,
 ];
 
 export function isSystemText(prompt: string): boolean {

package/src/hooks/lib/readme-sync.ts

@@ -16,7 +16,7 @@ interface SyncResult {
 
 /** Files that, when changed, should trigger a README check. */
 export const WATCHED_PATHS = [
-  "src/cli/index.ts",
+  "src/cli",
   "src/hooks/lib/paths.ts",
   "src/hooks/lib/inference.ts",
   "src/tools/youtube-analyze.ts",
@@ -24,33 +24,6 @@ export const WATCHED_PATHS = [
   "assets/agents",
 ];
 
-/**
- * A flag spelling of a command the README documents under its canonical name,
- * or the `cli` prefix the dispatcher consumes before a command is ever named.
- */
-function isAliasOrInternalRoute(cmd: string): boolean {
-  return ["--help", "-h", "help", "-v", "--version", "cli"].includes(cmd);
-}
-
-/** Extract CLI command names from the switch statement in index.ts */
-function extractCliCommands(): string[] {
-  const pkg = palPkg();
-  const cliPath = resolve(pkg, "src", "cli", "index.ts");
-  if (!existsSync(cliPath)) return [];
-
-  const content = readFileSync(cliPath, "utf-8");
-  const matches = content.matchAll(/case\s+"([^"]+)":/g);
-  const commands: string[] = [];
-
-  for (const match of matches) {
-    const cmd = match[1];
-    if (isAliasOrInternalRoute(cmd)) continue;
-    commands.push(cmd);
-  }
-
-  return [...new Set(commands)];
-}
-
 /** Extract PAL_* env var names from paths.ts + API keys from source */
 function extractEnvVars(): string[] {
   const pkg = palPkg();
@@ -113,7 +86,7 @@ function documentedSkillNames(readme: string): string[] {
 }
 
 /** Validate that README.md documents all code surfaces. */
-export function validateReadmeSync(): SyncResult {
+export function validateReadmeSync(cliCommands: string[]): SyncResult {
   const pkg = palPkg();
   const readmePath = resolve(pkg, "README.md");
 
@@ -124,8 +97,7 @@ export function validateReadmeSync(): SyncResult {
   const readme = readFileSync(readmePath, "utf-8");
   const issues: string[] = [];
 
-  // Check CLI commands
-  for (const cmd of extractCliCommands()) {
+  for (const cmd of cliCommands) {
     if (!readme.includes(`pal cli ${cmd}`)) {
       issues.push(`CLI command "${cmd}" exists in code but not documented in README`);
     }

package/src/hooks/lib/security-gate.ts

@@ -7,7 +7,7 @@
  * lives here instead; the entrypoint is left with stdin, stdout and the ledger.
  */
 
-import { normalizeToolUse } from "./agent";
+import { ANTIGRAVITY_WRITE_TOOLS, FILE_TARGET_KEYS, normalizeToolUse } from "./agent";
 import { logDebug } from "./log";
 import { checkBashCommand, checkFilePath } from "./security";
 
@@ -43,6 +43,7 @@ const SHELL_TOOLS = [
   "run_in_terminal",
   "terminal",
   "execute_command",
+  "run_command",
 ];
 
 const FILE_WRITE_TOOLS = [
@@ -64,6 +65,7 @@ const FILE_WRITE_TOOLS = [
   "replacestring",
   "edit_notebook_file",
   "notebookedit",
+  ...ANTIGRAVITY_WRITE_TOOLS,
 ];
 
 function isShellExec(input: SecurityInput): input is ShellExecInput {
@@ -121,7 +123,12 @@ export function decideRefusal(input: SecurityInput, cwd: string): GateRefusal |
     `toolName=${toolUse.toolName} args=${Object.keys(toolUse.toolInput).join(",")}`
   );
 
-  const command = firstStringArg(toolUse.toolInput, ["command", "commandLine", "script"]);
+  const command = firstStringArg(toolUse.toolInput, [
+    "command",
+    "commandLine",
+    "CommandLine",
+    "script",
+  ]);
   if (runsShellCommand(toolUse.toolName) && command) {
     const reason = checkBashCommand(command);
     // "No output" from a downstream tool is indistinguishable between "denied,
@@ -141,7 +148,7 @@ export function decideRefusal(input: SecurityInput, cwd: string): GateRefusal |
     }
   }
 
-  const filePath = firstStringArg(toolUse.toolInput, ["file_path", "filePath", "path"]);
+  const filePath = firstStringArg(toolUse.toolInput, FILE_TARGET_KEYS);
   if (writesFile(toolUse.toolName) && filePath) {
     const reason = checkFilePath(filePath);
     if (reason) {

package/src/hooks/lib/semi-static.ts

@@ -3,7 +3,7 @@
  *
  * One entry here = the only change needed to add a new source across all consumers:
  * CLAUDE.md @imports, opencode instructions[], Cursor .mdc, Copilot .instructions.md,
- * and the session-stop digest writer.
+ * Antigravity plugin rules, and the session-stop digest writer.
  */
 
 import { existsSync, readFileSync } from "node:fs";
@@ -22,9 +22,9 @@ interface SemiStaticSource {
   readonly writesDigest: boolean;
   /** Returns current content — builds fresh when writesDigest is true, reads the file otherwise. */
   load(): string;
-  /** Slug for ~/.cursor/rules/pal-${slug}.mdc and ~/.copilot/instructions/pal-${slug}.instructions.md */
+  /** Slug for the pal-${slug} rule/instruction files written for Cursor, Copilot and Antigravity. */
   readonly slug: string;
-  /** Human-readable description for Cursor .mdc frontmatter. */
+  /** Human-readable description for Cursor .mdc and Antigravity rule frontmatter. */
   readonly description: string;
 }
 
@@ -38,6 +38,16 @@ export function copilotFilename(src: SemiStaticSource): string {
   return `pal-${src.slug}.instructions.md`;
 }
 
+/** Returns the Antigravity plugin rule filename for a source. */
+export function antigravityFilename(src: SemiStaticSource): string {
+  return `pal-${src.slug}.md`;
+}
+
+/** An Antigravity rule file; a rule without a valid `trigger` is silently discarded. */
+export function antigravityRule(description: string, content: string): string {
+  return `---\ntrigger: always_on\ndescription: ${description}\n---\n\n${content}`;
+}
+
 function readFileSafe(path: string): string {
   try {
     if (!existsSync(path)) return "";

package/src/hooks/lib/session-context.ts

@@ -7,6 +7,8 @@
  * context for weeks — and none of it was reachable from a test.
  */
 
+import type { AgentName } from "./agent-registry";
+
 export interface ContextEnvelope {
   /** Whether the agent parses stdout as JSON or reads it as raw text. */
   kind: "json" | "text";
@@ -31,7 +33,7 @@ export type SessionStartContext = "full" | "without-handoff" | "none";
  * is resumed. Copilot does not document it, and has shipped a release that
  * dropped startup context, so it keeps getting the full context on resume.
  */
-const RESUME_KEEPS_CONTEXT: ReadonlySet<string> = new Set(["claude", "codex"]);
+const RESUME_KEEPS_CONTEXT: ReadonlySet<string> = new Set<AgentName>(["claude", "codex"]);
 
 /**
  * After a compaction, CompactRecover restores the last exchange, so the