@phnx-labs/agents-cli 1.20.59 → 1.20.60

package/dist/lib/plugins.js

@@ -21,6 +21,7 @@ import { shouldInstallCommandAsSkill, installCommandSkillToVersion } from './com
 import { copyPluginToMarketplace, syncMarketplaceManifest, registerMarketplace, unregisterMarketplace, addPluginToSettings, removePluginFromSettings, removePluginFromMarketplace, registerDroidInstalledPlugin, unregisterDroidInstalledPlugin, isDroidPluginInstalled, registerCopilotInstalledPlugin, unregisterCopilotInstalledPlugin, marketplaceIsEmpty, removeEmptyMarketplaceDir, isInstalledInMarketplace, marketplaceRoot, discoverMarketplaces, marketplaceNameFor, MARKETPLACE_NAME, PROJECT_MARKETPLACE_NAME, SYSTEM_MARKETPLACE_NAME, } from './plugin-marketplace.js';
 const PLUGIN_MANIFEST_DIR = '.claude-plugin';
 const PLUGIN_MANIFEST_FILE = 'plugin.json';
+const GEMINI_EXTENSION_MANIFEST_FILE = 'gemini-extension.json';
 const USER_CONFIG_FILE = '.user-config.json';
 const SOURCE_FILE = '.source';
 export const PLUGIN_EXEC_SURFACE_LABELS = {
@@ -502,6 +503,27 @@ export function syncPluginToVersion(plugin, agent, versionHome, options = {}) {
             result.skills.push(plugin.name);
         return result;
     }
+    // Gemini CLI loads extensions from $HOME/.gemini/extensions/<name>/.
+    // Copy the plugin bundle as an extension and synthesize gemini-extension.json.
+    if (agent === 'gemini') {
+        const enablePlugin = options.allowExecSurfaces === true || !hasPluginExecSurfaces(inspectPluginCapabilities(plugin.root));
+        if (!enablePlugin) {
+            return result;
+        }
+        const ok = installGeminiPlugin(plugin, versionHome);
+        result.success = ok;
+        if (ok) {
+            result.skills = plugin.skills.map(s => `${plugin.name}:${s}`);
+            result.commands = plugin.commands.map(c => `${plugin.name}:${c}`);
+            result.agentDefs = plugin.agentDefs.map(a => `${plugin.name}:${a}`);
+            result.bin = plugin.bin;
+            result.hooks = plugin.hooks;
+            result.mcp = plugin.hasMcp;
+            result.settings = plugin.hasSettings;
+            result.permissions = pluginHasPermissions(plugin);
+        }
+        return result;
+    }
     // Goose loads Open Plugins from $HOME/.agents/plugins/<name>/ (same layout as
     // agents-cli's source tree). Under the shim HOME is the version home.
     if (agent === 'goose') {
@@ -901,6 +923,82 @@ export function removeOpenCodePlugin(pluginName, versionHome) {
     }
     return removed;
 }
+// ─── Gemini extensions ───────────────────────────────────────────────────────
+/**
+ * Gemini CLI extensions live under `$HOME/.gemini/extensions/<name>/` and
+ * require a `gemini-extension.json` manifest at the extension root.
+ */
+export function geminiExtensionsDir(versionHome) {
+    return path.join(versionHome, '.gemini', 'extensions');
+}
+function readPluginMcpConfigForGemini(pluginRoot) {
+    const mcpPath = path.join(pluginRoot, '.mcp.json');
+    if (!fs.existsSync(mcpPath))
+        return undefined;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(mcpPath, 'utf-8'));
+        if (!parsed.mcpServers || typeof parsed.mcpServers !== 'object')
+            return undefined;
+        return rewriteGeminiExtensionVars(parsed.mcpServers);
+    }
+    catch {
+        return undefined;
+    }
+}
+function rewriteGeminiExtensionVars(value) {
+    if (typeof value === 'string') {
+        return value
+            .replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, '${extensionPath}')
+            .replace(/\$\{CLAUDE_PLUGIN_DATA\}/g, '${extensionPath}/.data');
+    }
+    if (Array.isArray(value))
+        return value.map(rewriteGeminiExtensionVars);
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, rewriteGeminiExtensionVars(item)]));
+    }
+    return value;
+}
+function writeGeminiExtensionManifest(plugin, destRoot) {
+    const manifest = {
+        name: plugin.manifest.name,
+        version: plugin.manifest.version,
+        description: plugin.manifest.description,
+    };
+    const mcpServers = readPluginMcpConfigForGemini(destRoot);
+    if (mcpServers && Object.keys(mcpServers).length > 0) {
+        manifest.mcpServers = mcpServers;
+    }
+    fs.writeFileSync(path.join(destRoot, GEMINI_EXTENSION_MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}\n`, 'utf-8');
+}
+export function installGeminiPlugin(plugin, versionHome) {
+    const destRoot = path.join(geminiExtensionsDir(versionHome), plugin.name);
+    try {
+        if (fs.existsSync(destRoot)) {
+            fs.rmSync(destRoot, { recursive: true, force: true });
+        }
+        fs.cpSync(plugin.root, destRoot, { recursive: true });
+        const userConfig = loadUserConfig(plugin.name);
+        if (Object.keys(userConfig).length > 0) {
+            expandUserConfigInDir(destRoot, userConfig);
+        }
+        writeGeminiExtensionManifest(plugin, destRoot);
+        fs.writeFileSync(path.join(destRoot, '.agents-cli-managed'), `plugin=${plugin.name}\n`, 'utf-8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isGeminiPluginInstalled(pluginName, versionHome) {
+    return fs.existsSync(path.join(geminiExtensionsDir(versionHome), pluginName, GEMINI_EXTENSION_MANIFEST_FILE));
+}
+export function removeGeminiPlugin(pluginName, versionHome) {
+    const destRoot = path.join(geminiExtensionsDir(versionHome), pluginName);
+    if (!fs.existsSync(destRoot))
+        return false;
+    fs.rmSync(destRoot, { recursive: true, force: true });
+    return true;
+}
 // ─── Goose plugins (Open Plugins under .agents/plugins/) ─────────────────────
 /**
  * Goose auto-discovers Open Plugins at `$HOME/.agents/plugins/<name>/`.
@@ -949,6 +1047,9 @@ export function isPluginSynced(plugin, agent, versionHome) {
     if (agent === 'opencode') {
         return isOpenCodePluginInstalled(plugin.name, versionHome);
     }
+    if (agent === 'gemini') {
+        return isGeminiPluginInstalled(plugin.name, versionHome);
+    }
     if (agent === 'goose') {
         return isGoosePluginInstalled(plugin.name, versionHome);
     }
@@ -986,6 +1087,13 @@ export function removePluginFromVersion(pluginName, pluginRoot, agent, versionHo
         }
         return result;
     }
+    // Gemini: remove extension directory from ~/.gemini/extensions/.
+    if (agent === 'gemini') {
+        if (removeGeminiPlugin(pluginName, versionHome)) {
+            result.skills.push(pluginName);
+        }
+        return result;
+    }
     // Goose: remove Open Plugin directory from versionHome/.agents/plugins/.
     if (agent === 'goose') {
         if (removeGoosePlugin(pluginName, versionHome)) {

package/dist/lib/resources/permissions.d.ts

@@ -4,7 +4,7 @@
  * Permissions are stored as YAML files in permissions/ directories at each layer.
  * Resolution: project > user > system (higher layer wins on name conflict).
  * Unlike other resources, permissions merge into agent-specific config files
- * (Claude: settings.json, Codex: config.toml, OpenCode: opencode.jsonc).
+ * (Claude/Gemini: settings.json, Codex: config.toml, OpenCode: opencode.jsonc).
  */
 import type { ResourceHandler } from './types.js';
 import type { PermissionSet } from '../types.js';

package/dist/lib/resources/permissions.js

@@ -4,7 +4,7 @@
  * Permissions are stored as YAML files in permissions/ directories at each layer.
  * Resolution: project > user > system (higher layer wins on name conflict).
  * Unlike other resources, permissions merge into agent-specific config files
- * (Claude: settings.json, Codex: config.toml, OpenCode: opencode.jsonc).
+ * (Claude/Gemini: settings.json, Codex: config.toml, OpenCode: opencode.jsonc).
  */
 import * as fs from 'fs';
 import * as path from 'path';
@@ -65,6 +65,8 @@ function getAgentConfigPath(agent, versionHome) {
             return path.join(versionHome, '.claude', 'settings.json');
         case 'codex':
             return path.join(versionHome, '.codex', 'config.toml');
+        case 'gemini':
+            return path.join(versionHome, '.gemini', 'settings.json');
         case 'opencode':
             return path.join(versionHome, '.config', 'opencode', 'opencode.jsonc');
         case 'kimi':
@@ -73,6 +75,8 @@ function getAgentConfigPath(agent, versionHome) {
             return path.join(versionHome, '.factory', 'settings.json');
         case 'kiro':
             return path.join(versionHome, '.kiro', 'settings', 'permissions.yaml');
+        case 'goose':
+            return path.join(versionHome, '.config', 'goose', 'permission.yaml');
         default:
             return null;
     }

package/dist/lib/resources/types.d.ts

@@ -5,7 +5,7 @@
  * - Union: All resources from all layers are combined
  * - Override on name conflict: Higher layer wins (project > user > system)
  */
-export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'kiro' | 'antigravity' | 'grok' | 'kimi' | 'droid' | 'hermes' | 'forge';
+export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'kiro' | 'goose' | 'antigravity' | 'grok' | 'kimi' | 'droid' | 'hermes' | 'forge';
 export type Layer = 'system' | 'user' | 'project';
 export type ResourceKind = 'command' | 'hook' | 'skill' | 'rule' | 'mcp' | 'permission' | 'subagent' | 'workflow' | 'memory';
 /** A resolved resource with its origin layer. */

package/dist/lib/routines.d.ts

@@ -138,6 +138,22 @@ export declare function readJob(name: string, cwd?: string): JobConfig | null;
  * name, the write fails explicitly so we never choose or drop a sibling.
  */
 export declare function writeJob(config: JobConfig): void;
+/**
+ * Serialize a job config, preserving the on-disk formatting of an existing file.
+ *
+ * A full `yaml.stringify(config)` re-emits the whole document — restyling every
+ * scalar (unquoting `schedule`, re-wrapping the folded `prompt` block, reordering
+ * keys). When a routine is only being toggled (pause/resume) or re-pinned
+ * (`devices --set`), that rewrites the entire file, leaving the git-backed
+ * `~/.agents` tree perpetually dirty so `agents repo pull` refuses to sync across
+ * the fleet. To keep the diff to the field that actually changed, we edit the
+ * existing document in place and only re-render touched nodes; untouched nodes
+ * (notably the large `prompt` block) keep their byte-for-byte formatting.
+ *
+ * `existingText` is the current file contents, or null for a new file. New,
+ * unparseable, and non-mapping documents fall back to canonical `yaml.stringify`.
+ */
+export declare function serializeJob(output: Record<string, unknown>, existingText: string | null): string;
 /** Delete a job config file by name. Returns true if the file existed. */
 export declare function deleteJob(name: string): boolean;
 /** Enable or disable a job by name. */

package/dist/lib/routines.js

@@ -187,7 +187,52 @@ export function writeJob(config) {
     const devArr = output.devices;
     if (!devArr || devArr.length === 0)
         delete output.devices;
-    atomicWriteFileSync(filePath, yaml.stringify(output));
+    let existingText = null;
+    if (ymlExists || yamlExists) {
+        try {
+            existingText = fs.readFileSync(filePath, 'utf-8');
+        }
+        catch {
+            existingText = null;
+        }
+    }
+    atomicWriteFileSync(filePath, serializeJob(output, existingText));
+}
+/**
+ * Serialize a job config, preserving the on-disk formatting of an existing file.
+ *
+ * A full `yaml.stringify(config)` re-emits the whole document — restyling every
+ * scalar (unquoting `schedule`, re-wrapping the folded `prompt` block, reordering
+ * keys). When a routine is only being toggled (pause/resume) or re-pinned
+ * (`devices --set`), that rewrites the entire file, leaving the git-backed
+ * `~/.agents` tree perpetually dirty so `agents repo pull` refuses to sync across
+ * the fleet. To keep the diff to the field that actually changed, we edit the
+ * existing document in place and only re-render touched nodes; untouched nodes
+ * (notably the large `prompt` block) keep their byte-for-byte formatting.
+ *
+ * `existingText` is the current file contents, or null for a new file. New,
+ * unparseable, and non-mapping documents fall back to canonical `yaml.stringify`.
+ */
+export function serializeJob(output, existingText) {
+    if (existingText == null)
+        return yaml.stringify(output);
+    const doc = yaml.parseDocument(existingText);
+    if (doc.errors.length > 0 || !yaml.isMap(doc.contents))
+        return yaml.stringify(output);
+    const existing = (doc.toJS() ?? {});
+    // Update or add only the keys that actually changed; leave the rest untouched
+    // so their original formatting is preserved.
+    for (const [key, value] of Object.entries(output)) {
+        if (JSON.stringify(existing[key]) !== JSON.stringify(value))
+            doc.set(key, value);
+    }
+    // Drop keys that no longer belong (e.g. an omitted default, or `devices`
+    // cleared back to fleet-wide).
+    for (const key of Object.keys(existing)) {
+        if (!(key in output))
+            doc.delete(key);
+    }
+    return doc.toString();
 }
 /** Delete a job config file by name. Returns true if the file existed. */
 export function deleteJob(name) {

package/dist/lib/shims.js

@@ -2024,18 +2024,28 @@ export function releaseAdoptedLauncher(agent, overrides) {
     // records written before this format existed.
     const launcher = lines[1] || getPathShadowingExecutable(agent) || original;
     const shimReal = canonical(path.join(shimsDir, AGENTS[agent].cliCommand));
+    const shimPath = path.resolve(path.join(shimsDir, AGENTS[agent].cliCommand));
     try {
         // Only rewrite the launcher if it currently points at our shim (i.e. we own
         // it). If the user has since replaced it themselves, leave it alone.
         let pointsAtShim = false;
         try {
-            pointsAtShim = fs.lstatSync(launcher).isSymbolicLink()
-                && canonical(launcher) === shimReal;
+            const stat = fs.lstatSync(launcher);
+            if (stat.isSymbolicLink()) {
+                const target = fs.readlinkSync(launcher);
+                const absoluteTarget = path.resolve(path.dirname(launcher), target);
+                pointsAtShim = canonicalOrNull(launcher) === shimReal || absoluteTarget === shimPath;
+            }
         }
         catch { /* launcher gone — recreate below */ }
         if (pointsAtShim || !fs.existsSync(launcher)) {
             try {
-                fs.rmSync(launcher);
+                if (fs.lstatSync(launcher).isSymbolicLink()) {
+                    fs.unlinkSync(launcher);
+                }
+                else {
+                    fs.rmSync(launcher, { force: true });
+                }
             }
             catch { /* may not exist */ }
             fs.symlinkSync(original, launcher);

package/dist/lib/skills.js

@@ -10,7 +10,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import * as yaml from 'yaml';
-import { ensureSkillsDir, agentConfigDirName } from './agents.js';
+import { AGENTS, ensureSkillsDir, agentConfigDirName } from './agents.js';
 import { capableAgents, isCapable } from './capabilities.js';
 import { getUserSkillsDir, getSkillsDir as getSystemSkillsDir, getProjectAgentsDir, getEnabledExtraRepos, getTrashSkillsDir } from './state.js';
 import { getEffectiveHome, getVersionHomePath, listInstalledVersions } from './versions.js';
@@ -432,6 +432,19 @@ function versionSkillMatches(agent, version, skillName) {
  */
 export function diffVersionSkills(agent, version) {
     const available = new Set(listAllSkills());
+    // Goose and other native ~/.agents/skills consumers read central storage
+    // directly. They intentionally have no per-version copy to diff, so every
+    // available central skill is already current for every supported version.
+    if (AGENTS[agent].nativeAgentsSkillsDir) {
+        return {
+            agent,
+            version,
+            toAdd: [],
+            toUpdate: [],
+            matched: Array.from(available).sort(),
+            orphans: [],
+        };
+    }
     const installed = new Set(listSkillsInVersionHome(agent, version));
     const toAdd = [];
     const toUpdate = [];

package/dist/lib/staleness/detectors/permissions.js

@@ -110,8 +110,11 @@ function buildGeminiDetector() {
                 return [];
             try {
                 const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
-                const allowed = settings?.tools?.allowed;
-                if (Array.isArray(allowed) && allowed.length > 0) {
+                const core = settings?.tools?.core;
+                const exclude = settings?.tools?.exclude;
+                const hasCore = Array.isArray(core) && core.length > 0;
+                const hasExclude = Array.isArray(exclude) && exclude.length > 0;
+                if (hasCore || hasExclude) {
                     return discoverPermissionGroups().map(g => g.name);
                 }
             }
@@ -162,6 +165,28 @@ function buildGrokDetector() {
         },
     };
 }
+function buildGooseDetector() {
+    return {
+        kind: 'permissions',
+        agent: 'goose',
+        list({ versionHome }) {
+            const permissionsPath = path.join(versionHome, '.config', 'goose', 'permission.yaml');
+            if (!fs.existsSync(permissionsPath))
+                return [];
+            try {
+                const config = yaml.parse(fs.readFileSync(permissionsPath, 'utf-8'));
+                const user = config?.user;
+                const count = (Array.isArray(user?.always_allow) ? user.always_allow.length : 0) +
+                    (Array.isArray(user?.ask_before) ? user.ask_before.length : 0) +
+                    (Array.isArray(user?.never_allow) ? user.never_allow.length : 0);
+                if (count > 0)
+                    return discoverPermissionGroups().map(g => g.name);
+            }
+            catch { /* parse fail */ }
+            return [];
+        },
+    };
+}
 function buildKimiDetector() {
     return {
         kind: 'permissions',
@@ -248,6 +273,7 @@ const handlers = {
     gemini: buildGeminiDetector,
     antigravity: buildAntigravityDetector,
     grok: buildGrokDetector,
+    goose: buildGooseDetector,
     kimi: buildKimiDetector,
     cursor: buildCursorDetector,
     droid: buildDroidDetector,

package/dist/lib/staleness/detectors/subagents.js

@@ -1,5 +1,5 @@
 /**
- * Subagents detector. Claude: flat .md files under `<agentDir>/agents/`.
+ * Subagents detector. Claude/Gemini/Grok: flat .md files under `<agentDir>/agents/`.
  * Codex: flat .toml files under `<versionHome>/.codex/agents/`.
  * Droid: flat .md files under `<versionHome>/.factory/droids/`.
  * OpenClaw: subdirectories containing AGENTS.md under `<versionHome>/.openclaw/`.
@@ -29,6 +29,9 @@ function buildClaudeDetector() {
 function buildGrokDetector() {
     return buildFlatMdAgentsDetector('grok', '.grok');
 }
+function buildGeminiDetector() {
+    return buildFlatMdAgentsDetector('gemini', '.gemini');
+}
 function buildCodexDetector() {
     return {
         kind: 'subagents',
@@ -128,13 +131,29 @@ function buildOpenCodeDetector() {
         },
     };
 }
+function buildAntigravityDetector() {
+    return {
+        kind: 'subagents',
+        agent: 'antigravity',
+        list({ versionHome }) {
+            const agentsDir = path.join(versionHome, '.gemini', 'config', 'agents');
+            if (!fs.existsSync(agentsDir))
+                return [];
+            return fs.readdirSync(agentsDir, { withFileTypes: true })
+                .filter(d => d.isDirectory() && fs.existsSync(path.join(agentsDir, d.name, 'agent.md')))
+                .map(d => d.name);
+        },
+    };
+}
 const handlers = {
     claude: buildClaudeDetector,
     copilot: buildCopilotDetector,
+    gemini: buildGeminiDetector,
     grok: buildGrokDetector,
     codex: buildCodexDetector,
     kimi: buildKimiDetector,
     opencode: buildOpenCodeDetector,
+    antigravity: buildAntigravityDetector,
     droid: buildDroidDetector,
     openclaw: buildOpenclawDetector,
     kiro: buildKiroDetector,

package/dist/lib/staleness/detectors/workflows.js

@@ -4,6 +4,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import * as yaml from 'yaml';
 import { capableAgents } from '../../capabilities.js';
 import { lazyAgentMap } from '../writers/lazy-map.js';
 function buildWorkflowsDetector(agent) {
@@ -11,6 +12,38 @@ function buildWorkflowsDetector(agent) {
         kind: 'workflows',
         agent,
         list({ versionHome }) {
+            if (agent === 'kimi') {
+                const skillsDir = path.join(versionHome, '.kimi-code', 'skills');
+                if (!fs.existsSync(skillsDir))
+                    return [];
+                return fs.readdirSync(skillsDir, { withFileTypes: true })
+                    .filter(d => d.isDirectory() && fs.existsSync(path.join(skillsDir, d.name, 'SKILL.md')))
+                    .filter(d => {
+                    try {
+                        const skill = fs.readFileSync(path.join(skillsDir, d.name, 'SKILL.md'), 'utf-8');
+                        const lines = skill.split('\n');
+                        if (lines[0] !== '---')
+                            return false;
+                        const endIndex = lines.slice(1).findIndex(l => l === '---');
+                        if (endIndex < 0)
+                            return false;
+                        const parsed = yaml.parse(lines.slice(1, endIndex + 1).join('\n'));
+                        return parsed?.type === 'flow' && parsed.agents_workflow === d.name;
+                    }
+                    catch {
+                        return false;
+                    }
+                })
+                    .map(d => d.name);
+            }
+            if (agent === 'goose') {
+                const recipesDir = path.join(versionHome, '.config', 'goose', 'recipes');
+                if (!fs.existsSync(recipesDir))
+                    return [];
+                return fs.readdirSync(recipesDir, { withFileTypes: true })
+                    .filter(d => d.isFile() && d.name.endsWith('.yaml') && !d.name.startsWith('.'))
+                    .map(d => d.name.slice(0, -'.yaml'.length));
+            }
             const workflowsDir = path.join(versionHome, 'workflows');
             if (!fs.existsSync(workflowsDir))
                 return [];

package/dist/lib/staleness/writers/subagents.js

@@ -1,6 +1,7 @@
 /**
- * Subagents writer. Claude flattens each subagent into a single .md file
- * under `<agentDir>/agents/`. Codex writes TOML under `.codex/agents/`.
+ * Subagents writer. Claude/Gemini/Grok flatten each subagent into a single
+ * .md file under their native agents directory. Codex writes TOML under
+ * `.codex/agents/`.
  * Droid (Factory AI) flattens each into a custom droid .md under
  * `<versionHome>/.factory/droids/`. OpenClaw copies the full subagent
  * directory (with AGENT.md renamed to AGENTS.md) into
@@ -13,7 +14,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { capableAgents } from '../../capabilities.js';
-import { listInstalledSubagents, transformSubagentForClaude, transformSubagentForCodex, transformSubagentForCopilot, writeKimiSubagentFiles, buildKimiSubagentsParentYaml, KIMI_SUBAGENTS_PARENT_FILE, transformSubagentForOpenCode, transformSubagentForDroid, transformSubagentForKiro, syncSubagentToOpenclaw, parseSubagentFrontmatter, } from '../../subagents.js';
+import { listInstalledSubagents, transformSubagentForClaude, transformSubagentForCodex, transformSubagentForCopilot, writeKimiSubagentFiles, buildKimiSubagentsParentYaml, KIMI_SUBAGENTS_PARENT_FILE, transformSubagentForOpenCode, transformSubagentForAntigravity, transformSubagentForDroid, transformSubagentForKiro, syncSubagentToOpenclaw, parseSubagentFrontmatter, } from '../../subagents.js';
 import { safeJoin } from '../../paths.js';
 import { lazyAgentMap } from './lazy-map.js';
 function buildSubagentsWriter(agent) {
@@ -29,8 +30,9 @@ function buildSubagentsWriter(agent) {
                 if (!sub)
                     continue;
                 try {
-                    if (agent === 'claude' || agent === 'grok') {
-                        const agentsDir = path.join(versionHome, agent === 'grok' ? '.grok' : '.claude', 'agents');
+                    if (agent === 'claude' || agent === 'gemini' || agent === 'grok') {
+                        const agentsRoot = agent === 'grok' ? '.grok' : agent === 'gemini' ? '.gemini' : '.claude';
+                        const agentsDir = path.join(versionHome, agentsRoot, 'agents');
                         fs.mkdirSync(agentsDir, { recursive: true });
                         fs.writeFileSync(safeJoin(agentsDir, `${sub.name}.md`), transformSubagentForClaude(sub.path));
                         synced.push(sub.name);
@@ -51,6 +53,12 @@ function buildSubagentsWriter(agent) {
                         fs.writeFileSync(safeJoin(agentsDir, `${sub.name}.md`), transformSubagentForOpenCode(sub.path));
                         synced.push(sub.name);
                     }
+                    else if (agent === 'antigravity') {
+                        const agentDir = safeJoin(path.join(versionHome, '.gemini', 'config', 'agents'), sub.name);
+                        fs.mkdirSync(agentDir, { recursive: true });
+                        fs.writeFileSync(safeJoin(agentDir, 'agent.md'), transformSubagentForAntigravity(sub.path));
+                        synced.push(sub.name);
+                    }
                     else if (agent === 'droid') {
                         const droidsDir = path.join(versionHome, '.factory', 'droids');
                         fs.mkdirSync(droidsDir, { recursive: true });

package/dist/lib/subagents.d.ts

@@ -68,6 +68,15 @@ export declare function transformSubagentForDroid(subagentDir: string): string;
  * See GitHub docs for custom agents.
  */
 export declare const transformSubagentForCopilot: typeof transformSubagentForDroid;
+/**
+ * Transform a subagent into Antigravity's custom-agent markdown shape.
+ *
+ * Antigravity exposes custom agents as Markdown files with YAML frontmatter,
+ * close to Gemini CLI subagents. Keep portable frontmatter fields and flatten
+ * sibling markdown files into the prompt body like the other markdown-backed
+ * agents.
+ */
+export declare function transformSubagentForAntigravity(subagentDir: string): string;
 /**
  * Transform a subagent into an OpenCode agent markdown file.
  *
@@ -157,7 +166,7 @@ export declare function removeSubagentFromAgent(subagentName: string, agent: Age
 export declare function subagentContentMatches(installedDir: string, sourceDir: string): boolean;
 /**
  * List subagents installed to a specific agent's home
- * Claude: scans ~/.claude/agents/{name}.md
+ * Claude/Gemini/Grok: scans ~/.{agent}/agents/{name}.md
  * Kimi: scans ~/.kimi-code/agents/{name}.yaml (+ sibling .system.md)
  * Kiro: scans ~/.kiro/agents/{name}.json
  * OpenClaw: scans ~/.openclaw/{name}/AGENTS.md