@agentex/agent 0.0.38 → 0.0.39

package/src/providers/antigravity/session.ts

@@ -0,0 +1,359 @@
+import type {
+  AgentSession,
+  CancelResult,
+  ClearGoalResult,
+  GoalOptions,
+  GoalState,
+  SendHandle,
+  SendOptions,
+  SessionContext,
+  SessionState,
+  SetGoalResult,
+  StopTaskResult,
+  StreamEvent,
+  TurnResult,
+  TurnTrigger,
+} from "../../types.js";
+import { GoalController, EMULATED_GOAL_CAPABILITY } from "../../goals/index.js";
+import type { ResolvedBinary } from "../../utils/binary.js";
+import { buildEnv, ensurePathInEnv } from "../../utils/env.js";
+import { resolveInstructions } from "../../utils/instructions.js";
+import { injectHomeSkills } from "../../utils/skills.js";
+import { uuidv7 } from "../../utils/uuid.js";
+import {
+  AgyConnection,
+  firstAgyErrorLine,
+  interruptAgyTurn,
+  type AgyTurnOutcome,
+} from "./connection.js";
+import {
+  ANTIGRAVITY_PROVIDER_TYPE,
+  AgyStreamParser,
+  agyUsageRecord,
+  classifyAgyFailure,
+  mapAgyTurnStatus,
+} from "./parse.js";
+import { AGY_SIGN_IN_MESSAGE, buildAgyArgs, findAgyBinary, readAgyResumeId } from "./runtime.js";
+
+interface ActiveTurn {
+  turnId: string;
+  abort: AbortController;
+  done: Promise<TurnResult>;
+}
+
+/**
+ * Open a multi-turn Antigravity session. Throws when `agy` is not installed.
+ * The process starts on the first `send()`.
+ */
+export async function createAntigravitySession(ctx: SessionContext): Promise<AgentSession> {
+  const binary = await findAgyBinary(ctx);
+  const config = ctx.config ?? {};
+  const instructions = await resolveInstructions(config.instructionsFile);
+  if (config.skillDirs && config.skillDirs.length > 0) {
+    try {
+      await injectHomeSkills(config.skillDirs, "antigravity");
+    } catch {
+      // Non-fatal
+    }
+  }
+  return new AntigravitySession(ctx, binary, instructions);
+}
+
+/**
+ * One `agy --input-format stream-json --output-format stream-json` process
+ * holds the conversation across turns. The CLI has no control protocol, so
+ * an interrupt is a SIGINT (Ctrl+C); when that ends the process, the next
+ * `send()` starts a new one on the same conversation with `--conversation`.
+ */
+class AntigravitySession implements AgentSession {
+  private _state: SessionState = "idle";
+  private conversationId: string | null;
+  private connection: AgyConnection | null = null;
+  private parser: AgyStreamParser | null = null;
+  private active: ActiveTurn | null = null;
+  /** Events received from agy processes, to tell whether one saw a message. */
+  private connectionEvents = 0;
+  private draining = false;
+  /** Instructions go into the first message of a conversation this session starts. */
+  private pendingInstructions: string | null;
+  private readonly cwd: string;
+  private readonly goals: GoalController;
+
+  constructor(
+    private readonly ctx: SessionContext,
+    private readonly binary: ResolvedBinary,
+    instructions: string | null,
+  ) {
+    this.cwd = ctx.cwd ?? process.cwd();
+    this.conversationId = readAgyResumeId(ctx.sessionParams, this.cwd);
+    this.pendingInstructions = this.conversationId ? null : instructions;
+    this.goals = new GoalController({
+      providerType: ANTIGRAVITY_PROVIDER_TYPE,
+      capability: EMULATED_GOAL_CAPABILITY,
+      getSessionId: () => this.sessionId,
+      send: (message) => this.send(message),
+      dispatch: (event) => void this.dispatch(event),
+    });
+    if (ctx.signal) {
+      if (ctx.signal.aborted) void this.close();
+      else ctx.signal.addEventListener("abort", () => void this.close(), { once: true });
+    }
+  }
+
+  get sessionId(): string | null {
+    return this.parser?.conversationId ?? this.conversationId;
+  }
+
+  get state(): SessionState {
+    return this._state;
+  }
+
+  async send(message: string, options?: SendOptions): Promise<SendHandle> {
+    if (this._state === "closed") throw new Error("Session is closed");
+    if (this.draining) throw new Error("Session is draining — no new sends accepted");
+    if (this.active) {
+      throw new Error("Antigravity session is busy — a turn is already in progress (concurrentSend not supported)");
+    }
+
+    const uuid = uuidv7();
+    const turnId = uuidv7();
+    const abort = new AbortController();
+    const text = this.pendingInstructions ? `${this.pendingInstructions}\n\n${message}` : message;
+    this.pendingInstructions = null;
+
+    this._state = "thinking";
+    const done = this.runTurn(text, turnId, abort, options);
+    this.active = { turnId, abort, done };
+    void done.then((result) => this.goals.onTurnSettled(result)).catch(() => undefined);
+    return { uuid, result: done };
+  }
+
+  private ensureConnection(): AgyConnection {
+    if (this.connection?.alive) return this.connection;
+    const config = this.ctx.config ?? {};
+    // A replacement process picks the conversation back up where it stopped.
+    this.conversationId = this.sessionId;
+    const parser = new AgyStreamParser({
+      includePartialMessages: config.includePartialMessages,
+      conversationId: this.conversationId,
+    });
+    const env = buildEnv(this.ctx.env);
+    ensurePathInEnv(env);
+    this.ctx.onLifecycle?.({ phase: "spawning" });
+    const connection = new AgyConnection({
+      command: this.binary.bin,
+      args: [
+        ...this.binary.prefixArgs,
+        ...buildAgyArgs(config, { resumeId: this.conversationId, model: config.model ?? null }),
+      ],
+      cwd: this.cwd,
+      env,
+      parser,
+      // Lines a replaced process prints on its way out belong to no turn.
+      onEvent: async (event): Promise<void> => {
+        if (this.connection === connection) await this.onEvent(event);
+      },
+      ...(this.ctx.onOutput ? { onOutput: this.ctx.onOutput } : {}),
+    });
+    if (connection.pid != null) this.ctx.onLifecycle?.({ phase: "running", pid: connection.pid });
+    this.connection = connection;
+    this.parser = parser;
+    return connection;
+  }
+
+  private async runTurn(
+    text: string,
+    turnId: string,
+    abort: AbortController,
+    options?: SendOptions,
+  ): Promise<TurnResult> {
+    await this.emitTurnEdge({ type: "turn_start", turnId, trigger: "send" });
+
+    const timeoutSec = options?.timeoutSec ?? this.ctx.config?.timeoutSec;
+    const graceSec = this.ctx.config?.graceSec;
+    let timer: ReturnType<typeof setTimeout> | null = null;
+    const guards: Promise<"timeout" | "aborted">[] = [
+      new Promise((resolve) => abort.signal.addEventListener("abort", () => resolve("aborted"), { once: true })),
+    ];
+    if (timeoutSec && timeoutSec > 0) {
+      guards.push(new Promise((resolve) => { timer = setTimeout(() => resolve("timeout"), timeoutSec * 1000); }));
+    }
+    const onSendAbort = () => abort.abort();
+    if (options?.signal) {
+      if (options.signal.aborted) abort.abort();
+      else options.signal.addEventListener("abort", onSendAbort, { once: true });
+    }
+
+    let connection = this.ensureConnection();
+    try {
+      let result: TurnResult | null = null;
+      let reason: "result" | "cancelled" | "session_closed" = "result";
+      for (let attempt = 0; result === null; attempt++) {
+        const eventsBefore = this.connectionEvents;
+        const pending = connection.nextTurn();
+        connection.write(text);
+        const first = await Promise.race([pending, ...guards]);
+        if (first === "timeout" || first === "aborted") {
+          const outcome = await interruptAgyTurn(connection, pending, graceSec);
+          // agy may report INTERRUPTED and then exit. Learn which before the
+          // next send, so it never lands on a process that is going away.
+          if (outcome?.result) await connection.waitForExit(500);
+          // Without an INTERRUPTED result the process was stopped; a late result
+          // from it must never settle the next turn.
+          if ((!outcome?.result || !connection.alive) && this.connection === connection) this.connection = null;
+          result = {
+            summary: outcome?.result?.response.trim() || null,
+            ...this.usageOf(outcome),
+            costUsd: null,
+            status: first,
+            errorCode: first,
+            errorMessage: first === "timeout" ? "Turn exceeded its timeout" : "Turn aborted",
+          };
+          reason = "cancelled";
+        } else if (
+          attempt === 0 && !first.result && first.exited && !first.authRequired
+          && this.connectionEvents === eventsBefore && this._state !== "closed"
+        ) {
+          // The process exited without ever acknowledging the message (it was
+          // already shutting down). Run it on a fresh process for the same
+          // conversation instead of failing a turn agy never started.
+          if (this.connection === connection) this.connection = null;
+          connection = this.ensureConnection();
+        } else {
+          result = this.toTurnResult(first);
+          reason = first.result ? "result" : "session_closed";
+        }
+      }
+      await this.emitTurnEdge({ type: "turn_end", turnId, trigger: "send", reason });
+      return result;
+    } finally {
+      if (timer) clearTimeout(timer);
+      options?.signal?.removeEventListener("abort", onSendAbort);
+      this.active = null;
+      if (!connection.alive && this.connection === connection) this.connection = null;
+      if (this._state !== "closed") this._state = "idle";
+    }
+  }
+
+  private usageOf(outcome: AgyTurnOutcome | null): { usage?: TurnResult["usage"] } {
+    const usage = agyUsageRecord(outcome?.result?.turnUsage ?? null, this.parser?.model ?? this.ctx.config?.model ?? null);
+    return usage ? { usage } : {};
+  }
+
+  private toTurnResult(outcome: AgyTurnOutcome): TurnResult {
+    const { result } = outcome;
+    if (result) {
+      const status = mapAgyTurnStatus(result.status);
+      if (status === "completed") {
+        return { summary: result.response.trim() || null, ...this.usageOf(outcome), costUsd: null, status, errorCode: null, errorMessage: null };
+      }
+      const errorCode = status === "aborted"
+        ? "aborted"
+        : outcome.authRequired ? "auth_required" : classifyAgyFailure(result, outcome.agyError);
+      return {
+        summary: result.response.trim() || null,
+        ...this.usageOf(outcome),
+        costUsd: null,
+        status,
+        errorCode,
+        errorMessage: errorCode === "auth_required"
+          ? AGY_SIGN_IN_MESSAGE
+          : result.error ?? outcome.agyError?.message ?? `Antigravity turn ended with ${result.status}`,
+      };
+    }
+    if (outcome.authRequired) {
+      return { summary: null, costUsd: null, status: "failed", errorCode: "auth_required", errorMessage: AGY_SIGN_IN_MESSAGE };
+    }
+    return {
+      summary: null,
+      costUsd: null,
+      status: "failed",
+      errorCode: "process_exited",
+      errorMessage: outcome.agyError?.message
+        ?? firstAgyErrorLine(outcome.stderr)
+        ?? `Antigravity CLI exited (code ${outcome.exitCode ?? "null"}${outcome.signal ? `, ${outcome.signal}` : ""}) before finishing the turn`,
+    };
+  }
+
+  private async onEvent(event: StreamEvent): Promise<void> {
+    this.connectionEvents++;
+    if (this._state !== "closed") {
+      if (event.type === "tool_call") this._state = "tool_executing";
+      else if (event.type === "assistant" || event.type === "thinking" || event.type === "tool_result") this._state = "thinking";
+    }
+    await this.dispatch(event);
+  }
+
+  private async emitTurnEdge(
+    edge:
+      | { type: "turn_start"; turnId: string; trigger: TurnTrigger }
+      | { type: "turn_end"; turnId: string; trigger: TurnTrigger; reason: "result" | "cancelled" | "session_closed" },
+  ): Promise<void> {
+    await this.dispatch({
+      ...edge,
+      timestamp: new Date().toISOString(),
+      providerType: ANTIGRAVITY_PROVIDER_TYPE,
+      sessionId: this.sessionId,
+      messageId: null,
+      eventId: null,
+      parentToolCallId: null,
+      raw: {},
+    } as StreamEvent);
+  }
+
+  private async dispatch(event: StreamEvent): Promise<void> {
+    if (!this.ctx.onEvent) return;
+    try {
+      await this.ctx.onEvent(event);
+    } catch {
+      /* a throwing handler must not break the stream */
+    }
+  }
+
+  async cancel(_uuid: string): Promise<CancelResult> {
+    // One message per turn and no queue, so there is never a queued message to drop.
+    return { cancelled: false };
+  }
+
+  async stopTask(_taskId: string): Promise<StopTaskResult> {
+    return { stopped: false };
+  }
+
+  setGoal(objective: string, options?: GoalOptions): Promise<SetGoalResult> {
+    return this.goals.setGoal(objective, options);
+  }
+
+  clearGoal(options?: { reason?: "cleared" | "blocked" }): Promise<ClearGoalResult> {
+    return this.goals.clearGoal(options);
+  }
+
+  getGoal(): GoalState | null {
+    return this.goals.getGoal();
+  }
+
+  async interrupt(): Promise<void> {
+    const active = this.active;
+    if (!active) return;
+    active.abort.abort();
+    await active.done.catch(() => undefined);
+  }
+
+  async drain(): Promise<void> {
+    this.draining = true;
+    if (this.active) await this.active.done.catch(() => undefined);
+    await this.close();
+  }
+
+  async close(): Promise<void> {
+    if (this._state === "closed" && !this.connection) return;
+    this._state = "closed";
+    const active = this.active;
+    if (active) {
+      active.abort.abort();
+      await active.done.catch(() => undefined);
+    }
+    const connection = this.connection;
+    this.connection = null;
+    if (connection) await connection.terminate(this.ctx.config?.graceSec);
+  }
+}

package/src/providers/gemini/index.ts

@@ -7,6 +7,12 @@ import { resolveAuthForProvider } from "../../utils/auth.js";
  * `@google/gemini-cli` on PATH; Gemini handles its own Google auth (GEMINI_API_KEY,
  * GOOGLE_API_KEY, or an OAuth login).
  *
+ * Since 2026-06-18 Gemini CLI no longer serves free, Google AI Pro, or Google
+ * AI Ultra sign-ins ("This client is no longer supported for Gemini Code
+ * Assist for individuals"); those accounts moved to the Antigravity CLI — use
+ * the `antigravity` provider. Gemini CLI still works with a paid API key and
+ * Gemini Code Assist Standard/Enterprise.
+ *
  * Replaces the previous one-shot `--output-format stream-json` adapter: the ACP
  * base gives gemini real sessions, streaming, tool-call correlation, permission
  * bridging (via `onUserInputRequest`), and mode discovery — none of which the

package/src/registry.ts

@@ -8,6 +8,7 @@ import { cursorProvider } from "./providers/cursor/index.js";
 import { opencodeProvider } from "./providers/opencode/index.js";
 import { piProvider } from "./providers/pi/index.js";
 import { copilotProvider } from "./providers/copilot/index.js";
+import { antigravityProvider } from "./providers/antigravity/index.js";
 
 const providers = new Map<string, ProviderModule>();
 
@@ -21,6 +22,7 @@ providers.set("cursor", cursorProvider);
 providers.set("opencode", opencodeProvider);
 providers.set("pi", piProvider);
 providers.set("copilot", copilotProvider);
+providers.set("antigravity", antigravityProvider);
 
 export function getProvider(type: string): ProviderModule {
   const provider = providers.get(type);

package/src/types.ts

@@ -667,8 +667,8 @@ export interface ProviderConfig {
   model?: string;
   /** Provider-native model variant, independent from reasoning effort. */
   modelVariant?: string;
-  /** Provider reasoning effort. Claude maps this to `--effort`; Codex sends
-   *  it as the app-server `turn/start.effort` override. */
+  /** Provider reasoning effort. Claude and Antigravity map this to `--effort`;
+   *  Codex sends it as the app-server `turn/start.effort` override. */
   effort?: string;
   /** Behavior when a host does not provide or loses its input callback. */
   unattendedPermissionPolicy?: "allow" | "deny";
@@ -729,15 +729,16 @@ export interface ProviderConfig {
   sandbox?: boolean;
   thinking?: string;
   /**
-   * Provider-specific mode pass-through. Currently used by `cursor` for its
-   * `--mode <mode>` flag. Don't use this for plan mode — set `planMode: true`
+   * Provider-specific mode pass-through. Used by `cursor` and `antigravity`
+   * for their `--mode <mode>` flag. Don't use this for plan mode — set `planMode: true`
    * instead, which is the cross-provider abstraction.
    */
   mode?: string;
   /**
    * Select a provider operating mode by id (one of `listModes()`). Honored by
    * providers with `capabilities.modes === true` (codex collaboration modes,
-   * ACP session modes, copilot allow-all/agent/plan). Ignored otherwise.
+   * ACP session modes, copilot allow-all/agent/plan, antigravity
+   * default/accept-edits/plan). Ignored otherwise.
    * Distinct from `mode` (cursor's raw `--mode` passthrough) and `planMode`
    * (the cross-provider read-only abstraction).
    */

package/src/utils/auth.ts

@@ -1,4 +1,5 @@
 import * as fs from "node:fs/promises";
+import { readFileSync } from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
 import type {
@@ -94,6 +95,12 @@ export function detectAuth(providerType: string, env: Record<string, string>): R
       }
       return { method: "subscription", billingType: "subscription" };
     }
+    case "antigravity": {
+      if (hasEnv(env, "GEMINI_API_KEY") && readAgyModelProvider() === "gemini") {
+        return { method: "api_key", billingType: "api" };
+      }
+      return { method: "subscription", billingType: "subscription" };
+    }
     case "opencode":
     case "pi":
       return { method: "api_key", billingType: "api" };
@@ -434,6 +441,74 @@ async function resolveGeminiAuth(ctx?: AuthResolveContext): Promise<AuthReport>
   };
 }
 
+// ---------------------------------------------------------------------------
+// Antigravity — no status subcommand, but `agy models` exits 1 with "Please
+// sign in" when no cached sign-in exists, so its exit status is the CLI's own
+// answer. A GEMINI_API_KEY counts only when settings.json selects the Gemini
+// API (`"modelProvider": "gemini"`); the CLI ignores the variable otherwise.
+// ---------------------------------------------------------------------------
+
+/** Home directory as agy (a Go binary) resolves it: os.UserHomeDir semantics. */
+function agyHomeDir(): string {
+  const fromEnv = process.platform === "win32" ? process.env["USERPROFILE"] : process.env["HOME"];
+  return fromEnv && fromEnv.trim() ? fromEnv : os.homedir();
+}
+
+function agySettingsPath(): string {
+  return path.join(agyHomeDir(), ".gemini", "antigravity-cli", "settings.json");
+}
+
+function readAgyModelProvider(): string | null {
+  try {
+    const settings = JSON.parse(readFileSync(agySettingsPath(), "utf-8")) as Record<string, unknown>;
+    return typeof settings["modelProvider"] === "string" ? settings["modelProvider"] : null;
+  } catch {
+    return null;
+  }
+}
+
+async function resolveAntigravityAuth(ctx?: AuthResolveContext): Promise<AuthReport> {
+  const env = buildEnv(ctx?.env);
+  const binary = await checkBinary("agy", ctx?.command, env);
+  const apiKeyProvider = readAgyModelProvider() === "gemini";
+  let signedIn = false;
+  let usedCli = false;
+  if (binary.installed && binary.resolvedPath) {
+    try {
+      const result = await runChildProcess({
+        runId: "antigravity-auth-status",
+        command: binary.resolvedPath,
+        args: [...binary.prefixArgs, "models"],
+        cwd: process.cwd(),
+        env,
+        timeoutSec: 20,
+      });
+      const output = `${result.stdout}\n${result.stderr}`;
+      signedIn = result.exitCode === 0 && !/sign in|authentication required/i.test(output);
+      usedCli = !result.timedOut;
+    } catch {
+      // Presence stays false; the binary could not be run.
+    }
+  }
+  return {
+    providerType: "antigravity",
+    binary: stripPrefixArgs(binary),
+    options: [
+      {
+        method: "subscription",
+        source: { kind: "cli", command: "agy models" },
+        present: signedIn && !apiKeyProvider,
+      },
+      {
+        method: "api_key",
+        source: { kind: "env", var: "GEMINI_API_KEY" },
+        present: apiKeyProvider && hasEnv(env, "GEMINI_API_KEY"),
+      },
+    ],
+    source: usedCli ? "cli" : "filesystem",
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Cursor uses its selected binary's `status` command. Other providers in this
 // section use environment or native-store presence reports.
@@ -538,6 +613,8 @@ async function resolveInternal(providerType: string, ctx?: AuthResolveContext):
       return resolveGeminiAuth(ctx);
     case "cursor":
       return resolveCursorAuth(ctx);
+    case "antigravity":
+      return resolveAntigravityAuth(ctx);
     case "opencode":
       return resolveOpencodeAuth(ctx);
     case "pi":
@@ -626,7 +703,7 @@ export async function hasBedrock(
  * Shell command a host should surface when an `auth_required` event fires
  * for `providerType`, or when `isLoggedIn` returns false. Values are the
  * provider's canonical CLI subcommand for interactive login — they spawn
- * a browser flow (Claude, Codex, Gemini, Cursor) or print API-key setup
+ * a browser flow (Claude, Codex, Gemini, Cursor, Antigravity) or print API-key setup
  * instructions (OpenCode, Pi).
  *
  * Unknown provider types fall back to `${providerType} login`, which is
@@ -647,6 +724,10 @@ export function loginCommandFor(providerType: string): string {
       return "gemini";
     case "cursor":
       return "cursor-agent login";
+    case "antigravity":
+      // No login subcommand: running `agy` signs in through the browser and
+      // caches the session in the OS keyring for headless runs.
+      return "agy";
     case "opencode":
       return "opencode auth login";
     case "pi":

package/src/utils/binary.ts

@@ -44,6 +44,13 @@ const COMMON_PATHS_UNIX: Record<string, string[]> = {
     "/usr/local/bin/pi",
     path.join(os.homedir(), ".npm-global", "bin", "pi"),
   ],
+  // Antigravity CLI. Its installer writes ~/.local/bin/agy, which GUI apps
+  // launched outside a login shell usually don't have on PATH.
+  agy: [
+    path.join(os.homedir(), ".local", "bin", "agy"),
+    "/usr/local/bin/agy",
+    "/opt/homebrew/bin/agy",
+  ],
 };
 
 function getCommonPathsWindows(name: string): string[] {
@@ -54,6 +61,8 @@ function getCommonPathsWindows(name: string): string[] {
     path.join(appData, "npm", `${name}.cmd`),
     path.join(localAppData, "pnpm", `${name}.cmd`),
     path.join(userProfile, ".local", "bin", `${name}.exe`),
+    // Native installers that keep a per-tool folder (Antigravity: %LOCALAPPDATA%\agy\bin).
+    path.join(localAppData, name, "bin", `${name}.exe`),
   ];
 }
 
@@ -158,6 +167,7 @@ export async function findBinary(name: string, configOverride?: string): Promise
     agent: "Install the Cursor CLI agent",
     opencode: "Install: npm install -g opencode-ai",
     pi: "Install: npm install -g @mariozechner/pi-coding-agent",
+    agy: "Install the Antigravity CLI: curl -fsSL https://antigravity.google/cli/install.sh | bash",
   };
   throw new Error(
     `Could not find "${name}" binary. Searched common install paths and PATH. ` +

package/src/utils/instructions.ts

@@ -77,11 +77,12 @@ const RUNTIME_INSTRUCTIONS: Record<SkillRuntime, RuntimeInstructionSpec> = {
   codex: { projectFile: "AGENTS.md", nativeFile: "AGENTS.md", nativeFileMode: "copy", hasGlobalFile: true },
   opencode: { projectFile: "AGENTS.md", nativeFile: "AGENTS.md", nativeFileMode: "copy", hasGlobalFile: true },
   gemini: { projectFile: "AGENTS.md", nativeFile: "GEMINI.md", nativeFileMode: "copy", hasGlobalFile: true },
+  antigravity: { projectFile: "AGENTS.md", nativeFile: "GEMINI.md", nativeFileMode: "copy", hasGlobalFile: true },
   cursor: { projectFile: "AGENTS.md", nativeFile: "AGENTS.md", nativeFileMode: "copy", hasGlobalFile: false },
   pi: { projectFile: "AGENTS.md", nativeFile: "AGENTS.md", nativeFileMode: "copy", hasGlobalFile: true },
 };
 
-const ALL_RUNTIMES: SkillRuntime[] = ["claude", "codex", "gemini", "cursor", "opencode", "pi"];
+const ALL_RUNTIMES: SkillRuntime[] = ["claude", "codex", "gemini", "antigravity", "cursor", "opencode", "pi"];
 
 const DEFAULT_MANAGED_TAG = "agentex";
 
@@ -235,19 +236,19 @@ export function resolveInstructionTargets(options?: {
     return [...byFile.values()].map((target) => ({ ...target, runtimes: dedupeRuntimes(target.runtimes) }));
   }
 
-  // global: each runtime reads its own native file in its own home dir.
-  const targets: InstructionTarget[] = [];
+  // global: each runtime reads its own native file in its own home dir. Gemini
+  // CLI and Antigravity share ~/.gemini/GEMINI.md, so targets merge by path.
+  const byPath = new Map<string, InstructionTarget>();
   for (const runtime of runtimes) {
     const spec = RUNTIME_INSTRUCTIONS[runtime];
     if (!spec.hasGlobalFile) continue; // e.g. cursor global = app User Rules, not a file
     const home = getDefaultRuntimeHome(runtime, options?.homeDir);
-    targets.push({
-      filename: spec.nativeFile,
-      targetPath: path.join(home, spec.nativeFile),
-      runtimes: [runtime],
-    });
+    const targetPath = path.join(home, spec.nativeFile);
+    const existing = byPath.get(targetPath);
+    if (existing) existing.runtimes.push(runtime);
+    else byPath.set(targetPath, { filename: spec.nativeFile, targetPath, runtimes: [runtime] });
   }
-  return targets;
+  return [...byPath.values()];
 }
 
 function dedupeRuntimes(runtimes: SkillRuntime[]): SkillRuntime[] {

package/src/utils/runtime-homes.ts

@@ -10,6 +10,7 @@ const ENV_VAR_MAP: Record<SkillRuntime, string | null> = {
   claude: "CLAUDE_CONFIG_DIR",
   codex: "CODEX_HOME",
   gemini: "GEMINI_CONFIG_DIR",
+  antigravity: null,  // agy has no home override
   cursor: "CURSOR_CONFIG_DIR",
   opencode: "XDG_CONFIG_HOME",  // affects ~/.config/opencode/
   pi: "PI_HOME",
@@ -22,6 +23,9 @@ const HOME_SUBPATH_MAP: Record<SkillRuntime, string[]> = {
   claude: [".claude"],
   codex: [".codex"],
   gemini: [".gemini"],
+  // Shared with Gemini CLI: agy reads its global GEMINI.md from ~/.gemini and
+  // keeps its own settings and skills in ~/.gemini/antigravity-cli.
+  antigravity: [".gemini"],
   cursor: [".cursor"],
   opencode: [".config", "opencode"],
   pi: [".pi"],