@phnx-labs/agents-cli 1.20.60 → 1.20.62

package/dist/lib/subagents.js

@@ -274,6 +274,27 @@ export function transformSubagentForDroid(subagentDir) {
  * See GitHub docs for custom agents.
  */
 export const transformSubagentForCopilot = transformSubagentForDroid;
+/**
+ * Transform a subagent into a Cursor CLI custom subagent `.md` file.
+ *
+ * Cursor loads subagents from `.cursor/agents/*.md` (project) or
+ * `~/.cursor/agents/*.md` (user) — Markdown with YAML frontmatter
+ * (name, description, model; also readonly/is_background, which our
+ * frontmatter schema doesn't carry). Cursor has no `color` field, so this is
+ * an alias of transformSubagentForDroid, same as Copilot.
+ * See https://cursor.com/docs/subagents.
+ */
+export const transformSubagentForCursor = transformSubagentForDroid;
+/**
+ * Transform a subagent into a ForgeCode custom subagent `.md` file.
+ *
+ * ForgeCode loads named agents from `.forge/agents/*.md` (project) or
+ * `~/.forge/agents/*.md` (user) — Markdown with YAML frontmatter (id, title,
+ * description, tools, model, temperature) + a system-prompt body. ForgeCode has
+ * no `color` field, so this is an alias of transformSubagentForDroid, same as
+ * Copilot/Cursor. See https://forgecode.dev/docs/agent-definition-guide/.
+ */
+export const transformSubagentForForge = transformSubagentForDroid;
 /**
  * Transform a subagent into Antigravity's custom-agent markdown shape.
  *
@@ -493,6 +514,45 @@ export function transformSubagentForKiro(subagentDir) {
     }
     return JSON.stringify(config, null, 2);
 }
+/**
+ * Transform a subagent into a Goose recipe YAML file.
+ *
+ * Goose has no dedicated subagent file format — a named subagent IS a recipe.
+ * Goose resolves named agents from `~/.config/goose/agents/<name>.yaml` (global)
+ * and delegates to them by name in autonomous mode. The recipe schema mirrors the
+ * one agents-cli already emits for Goose workflow recipes (`writeGooseSubrecipe`):
+ * `version`, `title`, `description`, `instructions`, `prompt`, plus an optional
+ * `settings.goose_model`. See goose-docs.ai context-engineering/subagents.
+ */
+export function transformSubagentForGoose(subagentDir) {
+    const agentMd = path.join(subagentDir, 'AGENT.md');
+    const frontmatter = parseSubagentFrontmatter(agentMd);
+    const body = getSubagentBody(agentMd);
+    if (!frontmatter) {
+        throw new Error(`Invalid AGENT.md in ${subagentDir}`);
+    }
+    const files = fs.readdirSync(subagentDir)
+        .filter(f => f.endsWith('.md') && f !== 'AGENT.md')
+        .sort();
+    let prompt = body || frontmatter.description || frontmatter.name;
+    for (const file of files) {
+        const content = fs.readFileSync(path.join(subagentDir, file), 'utf-8').trim();
+        const sectionName = file.replace('.md', '');
+        const title = sectionName.charAt(0).toUpperCase() + sectionName.slice(1).toLowerCase();
+        prompt += `\n\n## ${title}\n\n${content}`;
+    }
+    const recipe = {
+        version: '1.0.0',
+        title: frontmatter.name || path.basename(subagentDir),
+        description: frontmatter.description || frontmatter.name || path.basename(subagentDir),
+        instructions: prompt,
+        prompt,
+    };
+    if (frontmatter.model) {
+        recipe.settings = { goose_model: frontmatter.model };
+    }
+    return yaml.stringify(recipe);
+}
 /**
  * Sync a subagent to an OpenClaw workspace
  * Copies full directory, renames AGENT.md to AGENTS.md
@@ -609,6 +669,51 @@ export function installSubagentToAgent(subagentDir, subagentName, agent, agentHo
             return { success: false, error: String(err) };
         }
     }
+    else if (agent === 'cursor') {
+        // Cursor: flattened .md custom subagent under ~/.cursor/agents/
+        const agentsDir = path.join(agentHome, '.cursor', 'agents');
+        if (!fs.existsSync(agentsDir)) {
+            fs.mkdirSync(agentsDir, { recursive: true });
+        }
+        try {
+            const transformed = transformSubagentForCursor(subagentDir);
+            fs.writeFileSync(safeJoin(agentsDir, `${subagentName}.md`), transformed);
+            return { success: true };
+        }
+        catch (err) {
+            return { success: false, error: String(err) };
+        }
+    }
+    else if (agent === 'forge') {
+        // ForgeCode: flattened .md custom subagent under ~/.forge/agents/
+        const agentsDir = path.join(agentHome, '.forge', 'agents');
+        if (!fs.existsSync(agentsDir)) {
+            fs.mkdirSync(agentsDir, { recursive: true });
+        }
+        try {
+            const transformed = transformSubagentForForge(subagentDir);
+            fs.writeFileSync(safeJoin(agentsDir, `${subagentName}.md`), transformed);
+            return { success: true };
+        }
+        catch (err) {
+            return { success: false, error: String(err) };
+        }
+    }
+    else if (agent === 'goose') {
+        // Goose: recipe YAML custom-agent file under ~/.config/goose/agents/
+        const agentsDir = path.join(agentHome, '.config', 'goose', 'agents');
+        if (!fs.existsSync(agentsDir)) {
+            fs.mkdirSync(agentsDir, { recursive: true });
+        }
+        try {
+            const transformed = transformSubagentForGoose(subagentDir);
+            fs.writeFileSync(safeJoin(agentsDir, `${subagentName}.yaml`), transformed);
+            return { success: true };
+        }
+        catch (err) {
+            return { success: false, error: String(err) };
+        }
+    }
     else {
         // Other agents don't support subagents yet
         return { success: false, error: `Agent '${agent}' does not support subagents` };
@@ -670,6 +775,27 @@ export function removeSubagentFromAgent(subagentName, agent, agentHome) {
             }
             return { success: true };
         }
+        else if (agent === 'cursor') {
+            const targetPath = safeJoin(path.join(agentHome, '.cursor', 'agents'), `${subagentName}.md`);
+            if (fs.existsSync(targetPath)) {
+                fs.unlinkSync(targetPath);
+            }
+            return { success: true };
+        }
+        else if (agent === 'forge') {
+            const targetPath = safeJoin(path.join(agentHome, '.forge', 'agents'), `${subagentName}.md`);
+            if (fs.existsSync(targetPath)) {
+                fs.unlinkSync(targetPath);
+            }
+            return { success: true };
+        }
+        else if (agent === 'goose') {
+            const targetPath = safeJoin(path.join(agentHome, '.config', 'goose', 'agents'), `${subagentName}.yaml`);
+            if (fs.existsSync(targetPath)) {
+                fs.unlinkSync(targetPath);
+            }
+            return { success: true };
+        }
         else {
             return { success: true }; // No-op for unsupported agents
         }
@@ -886,6 +1012,61 @@ export function listSubagentsForAgent(agentId, home) {
             });
         }
     }
+    else if (agentId === 'cursor') {
+        // Cursor: flat `<name>.md` files under ~/.cursor/agents/
+        const agentsDir = path.join(home, '.cursor', 'agents');
+        if (!fs.existsSync(agentsDir))
+            return subagents;
+        for (const file of fs.readdirSync(agentsDir)) {
+            if (!file.endsWith('.md'))
+                continue;
+            const filePath = path.join(agentsDir, file);
+            if (!fs.statSync(filePath).isFile())
+                continue;
+            const name = file.replace(/\.md$/, '');
+            const frontmatter = parseSubagentFrontmatter(filePath) ?? { name, description: '' };
+            subagents.push({ name, path: filePath, files: [file], frontmatter });
+        }
+    }
+    else if (agentId === 'forge') {
+        // ForgeCode: flat `<name>.md` files under ~/.forge/agents/
+        const agentsDir = path.join(home, '.forge', 'agents');
+        if (!fs.existsSync(agentsDir))
+            return subagents;
+        for (const file of fs.readdirSync(agentsDir)) {
+            if (!file.endsWith('.md'))
+                continue;
+            const filePath = path.join(agentsDir, file);
+            if (!fs.statSync(filePath).isFile())
+                continue;
+            const name = file.replace(/\.md$/, '');
+            const frontmatter = parseSubagentFrontmatter(filePath) ?? { name, description: '' };
+            subagents.push({ name, path: filePath, files: [file], frontmatter });
+        }
+    }
+    else if (agentId === 'goose') {
+        // Goose: recipe YAML files under ~/.config/goose/agents/
+        const agentsDir = path.join(home, '.config', 'goose', 'agents');
+        if (!fs.existsSync(agentsDir))
+            return subagents;
+        for (const file of fs.readdirSync(agentsDir)) {
+            if (!file.endsWith('.yaml'))
+                continue;
+            const filePath = path.join(agentsDir, file);
+            if (!fs.statSync(filePath).isFile())
+                continue;
+            const name = file.replace(/\.yaml$/, '');
+            let frontmatter;
+            try {
+                const recipe = yaml.parse(fs.readFileSync(filePath, 'utf-8'));
+                frontmatter = { name: recipe?.title || name, description: recipe?.description || '' };
+            }
+            catch {
+                continue;
+            }
+            subagents.push({ name, path: filePath, files: [file], frontmatter });
+        }
+    }
     return subagents;
 }
 /**
@@ -984,6 +1165,42 @@ export function diffVersionSubagents(agent, version) {
             }
         }
     }
+    else if (agent === 'cursor') {
+        const agentsDir = path.join(versionHome, '.cursor', 'agents');
+        if (fs.existsSync(agentsDir)) {
+            for (const file of fs.readdirSync(agentsDir)) {
+                if (!file.endsWith('.md'))
+                    continue;
+                const name = path.basename(file, '.md');
+                if (!discovered.has(name))
+                    orphans.push(name);
+            }
+        }
+    }
+    else if (agent === 'forge') {
+        const agentsDir = path.join(versionHome, '.forge', 'agents');
+        if (fs.existsSync(agentsDir)) {
+            for (const file of fs.readdirSync(agentsDir)) {
+                if (!file.endsWith('.md'))
+                    continue;
+                const name = path.basename(file, '.md');
+                if (!discovered.has(name))
+                    orphans.push(name);
+            }
+        }
+    }
+    else if (agent === 'goose') {
+        const agentsDir = path.join(versionHome, '.config', 'goose', 'agents');
+        if (fs.existsSync(agentsDir)) {
+            for (const file of fs.readdirSync(agentsDir)) {
+                if (!file.endsWith('.yaml'))
+                    continue;
+                const name = path.basename(file, '.yaml');
+                if (!discovered.has(name))
+                    orphans.push(name);
+            }
+        }
+    }
     return { agent, version, orphans: orphans.sort() };
 }
 /**
@@ -1071,6 +1288,27 @@ export function removeSubagentFromVersion(agent, version, subagentName) {
                 fs.renameSync(targetPath, path.join(trashDir, `${subagentName}.json.${stamp}`));
             }
         }
+        else if (agent === 'cursor') {
+            const targetPath = path.join(versionHome, '.cursor', 'agents', `${subagentName}.md`);
+            if (fs.existsSync(targetPath)) {
+                fs.mkdirSync(trashDir, { recursive: true, mode: 0o700 });
+                fs.renameSync(targetPath, path.join(trashDir, `${subagentName}.md.${stamp}`));
+            }
+        }
+        else if (agent === 'forge') {
+            const targetPath = path.join(versionHome, '.forge', 'agents', `${subagentName}.md`);
+            if (fs.existsSync(targetPath)) {
+                fs.mkdirSync(trashDir, { recursive: true, mode: 0o700 });
+                fs.renameSync(targetPath, path.join(trashDir, `${subagentName}.md.${stamp}`));
+            }
+        }
+        else if (agent === 'goose') {
+            const targetPath = path.join(versionHome, '.config', 'goose', 'agents', `${subagentName}.yaml`);
+            if (fs.existsSync(targetPath)) {
+                fs.mkdirSync(trashDir, { recursive: true, mode: 0o700 });
+                fs.renameSync(targetPath, path.join(trashDir, `${subagentName}.yaml.${stamp}`));
+            }
+        }
         return { success: true };
     }
     catch (err) {

package/dist/lib/tmux/session.d.ts

@@ -146,19 +146,25 @@ export declare function setSessionHook(name: string, hook: string, command: stri
  *        in the tmux server instead of launching a second tmux client against
  *        the same socket from inside the hook. That self-client could race the
  *        server under load and leave the dead split behind.
+ *   v5 — `run-shell -b -C "kill-pane -t #{hook_pane}"` runs the targeted kill-pane
+ *        in the background inside the server command queue. The synchronous
+ *        variant could stall the hook on a loaded CI runner, letting the dead
+ *        split survive until the test's wait timeout expired (flake in CI shard
+ *        3: pane-guarded pane-died hook / user split exit).
  */
-export declare const AGENT_HOOK_SCHEMA = 4;
+export declare const AGENT_HOOK_SCHEMA = 5;
 /**
  * The guarded `pane-died` hook. Detach the client ONLY when the agent pane dies
  * (so the blocking attach in runInTmux returns and the exit status can be read);
  * a user split's death runs the else-branch, closing just that split. The
- * else-branch goes through `run-shell -C` with an explicit `-t #{hook_pane}`
+ * else-branch goes through `run-shell -b -C` with an explicit `-t #{hook_pane}`
  * target: tmux format-expands the command at fire time and executes it inside
- * the server command queue, so the event pane is always the one killed without
- * launching a second tmux client against the same socket. A bare `kill-pane`
- * relied on the hook context supplying a "current pane", while an external
- * self-client could race the server under load. Single source of truth: both
- * the spawn-wrap (exec.ts) and the daemon reconcile build the hook here, so the
+ * the server command queue in the background, so the event pane is always the
+ * one killed without launching a second tmux client against the same socket and
+ * without stalling the hook on a loaded runner. A bare `kill-pane` relied on
+ * the hook context supplying a "current pane", while an external self-client
+ * could race the server under load. Single source of truth: both the
+ * spawn-wrap (exec.ts) and the daemon reconcile build the hook here, so the
  * two can never drift.
  */
 export declare function agentPaneDiedHook(sessionName: string, agentPane: string): string;

package/dist/lib/tmux/session.js

@@ -93,6 +93,15 @@ export async function createSession(opts) {
     const res = await runTmux({ socket, args, env: opts.env });
     // Only the new-session command in the `;`-chained invocation emits output.
     const pane = /^%\d+$/.test(res.stdout.trim()) ? res.stdout.trim() : undefined;
+    // Keep the agent pane around after its process exits (so runInTmux can read
+    // the exit status and capture the final error), but do NOT keep that behavior
+    // for user-created splits. Apply remain-on-exit to the agent pane only, then
+    // revert the global default so future splits close automatically when their
+    // command finishes. The global-on above protects a fast-exiting agent during
+    // the brief window before the pane option is stamped.
+    if (pane) {
+        await runTmux({ socket, args: ['set-option', '-pt', pane, 'remain-on-exit', 'on', ';', 'set-option', '-g', 'remain-on-exit', 'off'], throwOnError: false }).catch(() => { });
+    }
     const meta = {
         name: opts.name,
         socket,
@@ -294,25 +303,31 @@ export async function setSessionHook(name, hook, command, socket) {
  *        in the tmux server instead of launching a second tmux client against
  *        the same socket from inside the hook. That self-client could race the
  *        server under load and leave the dead split behind.
+ *   v5 — `run-shell -b -C "kill-pane -t #{hook_pane}"` runs the targeted kill-pane
+ *        in the background inside the server command queue. The synchronous
+ *        variant could stall the hook on a loaded CI runner, letting the dead
+ *        split survive until the test's wait timeout expired (flake in CI shard
+ *        3: pane-guarded pane-died hook / user split exit).
  */
-export const AGENT_HOOK_SCHEMA = 4;
+export const AGENT_HOOK_SCHEMA = 5;
 /** Per-session tmux user-option that records which AGENT_HOOK_SCHEMA a session's hook is at. */
 const HOOK_SCHEMA_OPTION = '@ag_hook_schema';
 /**
  * The guarded `pane-died` hook. Detach the client ONLY when the agent pane dies
  * (so the blocking attach in runInTmux returns and the exit status can be read);
  * a user split's death runs the else-branch, closing just that split. The
- * else-branch goes through `run-shell -C` with an explicit `-t #{hook_pane}`
+ * else-branch goes through `run-shell -b -C` with an explicit `-t #{hook_pane}`
  * target: tmux format-expands the command at fire time and executes it inside
- * the server command queue, so the event pane is always the one killed without
- * launching a second tmux client against the same socket. A bare `kill-pane`
- * relied on the hook context supplying a "current pane", while an external
- * self-client could race the server under load. Single source of truth: both
- * the spawn-wrap (exec.ts) and the daemon reconcile build the hook here, so the
+ * the server command queue in the background, so the event pane is always the
+ * one killed without launching a second tmux client against the same socket and
+ * without stalling the hook on a loaded runner. A bare `kill-pane` relied on
+ * the hook context supplying a "current pane", while an external self-client
+ * could race the server under load. Single source of truth: both the
+ * spawn-wrap (exec.ts) and the daemon reconcile build the hook here, so the
  * two can never drift.
  */
 export function agentPaneDiedHook(sessionName, agentPane) {
-    return `if -F '#{==:#{hook_pane},${agentPane}}' 'detach-client -s =${sessionName}' 'run-shell -C "kill-pane -t #{hook_pane}"'`;
+    return `if -F '#{==:#{hook_pane},${agentPane}}' 'detach-client -s =${sessionName}' 'run-shell -b -C "kill-pane -t #{hook_pane}"'`;
 }
 /** Stamp a session's hook-schema marker to the current version. */
 export async function markSessionHookSchema(name, socket) {

package/dist/lib/versions.js

@@ -1148,6 +1148,72 @@ export function setGlobalDefault(agent, version) {
     }
     writeMeta(meta);
 }
+/**
+ * Grok's official installer writes into ~/.grok/downloads, which (because we
+ * symlink ~/.grok to the active version home) resolves to the PREVIOUS default
+ * home during `agents add grok@<new>`. Move the freshly-downloaded binary and
+ * its generic platform copy into the target version's isolated home so
+ * `listInstalledVersions` and the shim resolve the right binary.
+ */
+function relocateGrokBinaryToVersionHome(installedVersion) {
+    const hostGrokLink = path.join(getHomeDir(), agentConfigDirName('grok'));
+    let sourceDownloads;
+    try {
+        sourceDownloads = path.join(fs.readlinkSync(hostGrokLink), 'downloads');
+    }
+    catch {
+        sourceDownloads = path.join(hostGrokLink, 'downloads');
+    }
+    const targetDownloads = path.join(getVersionHomePath('grok', installedVersion), agentConfigDirName('grok'), 'downloads');
+    if (!fs.existsSync(sourceDownloads))
+        return;
+    if (path.resolve(sourceDownloads) === path.resolve(targetDownloads))
+        return;
+    const entries = fs.readdirSync(sourceDownloads).filter((e) => e.startsWith('grok-'));
+    if (entries.length === 0)
+        return;
+    fs.mkdirSync(targetDownloads, { recursive: true });
+    const escapedVersion = installedVersion.replace(/\./g, '\\.');
+    const versionedPattern = new RegExp(`^grok-${escapedVersion}-`);
+    const movedPaths = [];
+    // Move the versioned binary first.
+    for (const entry of entries) {
+        if (!versionedPattern.test(entry))
+            continue;
+        const src = path.join(sourceDownloads, entry);
+        const dst = path.join(targetDownloads, entry);
+        if (fs.existsSync(dst))
+            continue;
+        try {
+            fs.renameSync(src, dst);
+            movedPaths.push(dst);
+        }
+        catch {
+            /* ignore per-file failures */
+        }
+    }
+    if (movedPaths.length === 0)
+        return;
+    // The installer also creates a generic platform binary (e.g. grok-macos-aarch64)
+    // that is a copy of the versioned binary. Move it too if its size matches.
+    const movedSize = fs.statSync(movedPaths[0]).size;
+    for (const entry of entries) {
+        if (versionedPattern.test(entry))
+            continue; // already handled
+        const src = path.join(sourceDownloads, entry);
+        const dst = path.join(targetDownloads, entry);
+        if (fs.existsSync(dst))
+            continue;
+        try {
+            if (fs.statSync(src).size === movedSize) {
+                fs.renameSync(src, dst);
+            }
+        }
+        catch {
+            /* ignore per-file failures */
+        }
+    }
+}
 /**
  * Install a specific version of an agent.
  */
@@ -1204,6 +1270,12 @@ export async function installVersion(agent, version, onProgress, opts) {
         const versionDir = getVersionDir(agent, installedVersion);
         fs.mkdirSync(versionDir, { recursive: true });
         fs.mkdirSync(path.join(versionDir, 'home'), { recursive: true });
+        // Grok's installer drops the binary into ~/.grok/downloads, which currently
+        // resolves to the PREVIOUS default home. Move it into the target version home
+        // so version isolation is correct.
+        if (agent === 'grok') {
+            relocateGrokBinaryToVersionHome(installedVersion);
+        }
         // Symlink the installed binary into the version's node_modules/.bin so
         // listInstalledVersions (which checks getBinaryPath) sees this version as
         // installed. Without this, `agents add antigravity@latest` succeeds

package/dist/lib/workflows.d.ts

@@ -265,6 +265,15 @@ export declare function pruneStaleWorkflowSubagents(sharedAgentsDir: string, wor
 export declare function countWorkflowSubagents(workflowDir: string): number;
 /** Convert a canonical agents-cli workflow bundle into a Kimi flow skill. */
 export declare function transformWorkflowForKimi(workflowPath: string, name: string): string;
+/**
+ * Convert a canonical agents-cli workflow bundle into an Antigravity workflow
+ * markdown file. Antigravity discovers workflows as flat `<name>.md` files under
+ * `~/.gemini/config/global_workflows/` (scanned by `agy` at startup) and exposes
+ * each as a `/<name>` slash command. Frontmatter carries the required `description`
+ * plus the shared `agents_workflow` ownership marker so agents-cli never clobbers a
+ * user-authored workflow of the same name.
+ */
+export declare function transformWorkflowForAntigravity(workflowPath: string, name: string): string;
 /**
  * Resolve an `agents run <workflow>` reference.
  *

package/dist/lib/workflows.js

@@ -6,6 +6,7 @@
  * are composed at runtime by `agents run <workflow>`.
  */
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 import * as yaml from 'yaml';
 import { capableAgents } from './capabilities.js';
@@ -369,6 +370,26 @@ export function transformWorkflowForKimi(workflowPath, name) {
     const instructions = (body || fm.description).trim();
     return `---\n${frontmatter}\n---\n\n\`\`\`d2\nBEGIN -> step -> END\nstep: |md\n${indentD2BlockString(instructions)}\n|\n\`\`\`\n`;
 }
+/**
+ * Convert a canonical agents-cli workflow bundle into an Antigravity workflow
+ * markdown file. Antigravity discovers workflows as flat `<name>.md` files under
+ * `~/.gemini/config/global_workflows/` (scanned by `agy` at startup) and exposes
+ * each as a `/<name>` slash command. Frontmatter carries the required `description`
+ * plus the shared `agents_workflow` ownership marker so agents-cli never clobbers a
+ * user-authored workflow of the same name.
+ */
+export function transformWorkflowForAntigravity(workflowPath, name) {
+    const fm = parseWorkflowFrontmatter(workflowPath);
+    if (!fm)
+        throw new Error(`Invalid WORKFLOW.md in ${workflowPath}`);
+    const body = getWorkflowBody(workflowPath) || fm.description;
+    const frontmatter = yaml.stringify({
+        description: fm.description,
+        name: fm.name || name,
+        [KIMI_WORKFLOW_MARKER]: name,
+    }).trim();
+    return `---\n${frontmatter}\n---\n\n${body.trim()}\n`;
+}
 function expandWorkflowPath(ref) {
     if (ref === '~')
         return process.env.HOME ?? ref;
@@ -527,9 +548,24 @@ export function removeWorkflow(name) {
         return { success: false, error: err.message };
     }
 }
+/**
+ * Antigravity user workflows are NOT version-isolated. `agy` scans a single,
+ * shared, HOME-global directory at startup — `~/.gemini/config/global_workflows/`
+ * — and that dir is a real directory in the user's home, never symlinked into a
+ * per-version home (only `~/.gemini/antigravity-cli` is version-scoped). Writing
+ * into a version home therefore lands somewhere agy never reads. So every
+ * antigravity version resolves to the same real shared dir; `versionHome` is
+ * intentionally ignored. (Verified via strace of `agy`: it opens
+ * `$HOME/.gemini/config/global_workflows/<name>.md` and never the version home.)
+ */
+function antigravityWorkflowsDir() {
+    return path.join(process.env.HOME ?? os.homedir(), '.gemini', 'config', 'global_workflows');
+}
 function workflowTargetRoot(agent, versionHome) {
     if (agent === 'kimi')
         return path.join(versionHome, '.kimi-code', 'skills');
+    if (agent === 'antigravity')
+        return antigravityWorkflowsDir();
     return path.join(versionHome, 'workflows');
 }
 /** List workflow names synced into a specific agent version home. */
@@ -543,6 +579,20 @@ export function listWorkflowsForAgent(agent, versionHome) {
             .filter(d => kimiWorkflowMarker(path.join(skillsDir, d.name, 'SKILL.md')) === d.name)
             .map(d => d.name);
     }
+    if (agent === 'antigravity') {
+        const dir = workflowTargetRoot(agent, versionHome);
+        if (!fs.existsSync(dir))
+            return [];
+        try {
+            return fs.readdirSync(dir, { withFileTypes: true })
+                .filter(d => d.isFile() && d.name.endsWith('.md') && !d.name.startsWith('.'))
+                .map(d => d.name.slice(0, -'.md'.length))
+                .filter(base => antigravityWorkflowMarker(path.join(dir, `${base}.md`)) === base);
+        }
+        catch {
+            return [];
+        }
+    }
     if (agent === 'goose') {
         const recipesDir = path.join(versionHome, '.config', 'goose', 'recipes');
         if (!fs.existsSync(recipesDir))
@@ -678,7 +728,17 @@ export function syncWorkflowToVersion(workflowPath, name, agent, versionHome) {
             return { success: true };
         }
         if (agent === 'antigravity') {
-            return { success: false, error: 'Antigravity workflow sync is not supported for version homes' };
+            const targetDir = workflowTargetRoot(agent, versionHome);
+            const targetFile = path.join(targetDir, `${name}.md`);
+            if (fs.existsSync(targetFile)) {
+                const marker = antigravityWorkflowMarker(targetFile);
+                if (marker !== name) {
+                    return { success: false, error: `Antigravity workflow '${name}' already exists and is not managed by agents-cli` };
+                }
+            }
+            fs.mkdirSync(targetDir, { recursive: true });
+            fs.writeFileSync(targetFile, transformWorkflowForAntigravity(workflowPath, name), 'utf-8');
+            return { success: true };
         }
         const targetDir = path.join(workflowTargetRoot(agent, versionHome), name);
         fs.mkdirSync(workflowTargetRoot(agent, versionHome), { recursive: true });
@@ -696,7 +756,20 @@ export function syncWorkflowToVersion(workflowPath, name, agent, versionHome) {
 export function removeWorkflowFromVersion(agent, version, name) {
     const versionHome = getVersionHomePath(agent, version);
     if (agent === 'antigravity') {
-        return { success: false, error: 'Antigravity workflow sync is not supported for version homes' };
+        const targetFile = path.join(workflowTargetRoot(agent, versionHome), `${name}.md`);
+        if (!fs.existsSync(targetFile)) {
+            return { success: false, error: `Workflow '${name}' not synced to ${agent}@${version}` };
+        }
+        if (antigravityWorkflowMarker(targetFile) !== name) {
+            return { success: false, error: `Antigravity workflow '${name}' is not managed by agents-cli` };
+        }
+        try {
+            fs.rmSync(targetFile, { force: true });
+            return { success: true };
+        }
+        catch (err) {
+            return { success: false, error: err.message };
+        }
     }
     if (agent === 'goose') {
         const recipePath = path.join(versionHome, '.config', 'goose', 'recipes', `${name}.yaml`);
@@ -754,6 +827,15 @@ function kimiWorkflowMarker(filePath) {
         return null;
     }
 }
+function antigravityWorkflowMarker(filePath) {
+    try {
+        const fm = parseSkillFrontmatter(filePath);
+        return typeof fm?.agents_workflow === 'string' ? fm.agents_workflow : null;
+    }
+    catch {
+        return null;
+    }
+}
 /** Iterate all installed (agent, version) pairs that support workflows. */
 export function iterWorkflowsCapableVersions(filter) {
     const result = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.20.60",
+  "version": "1.20.62",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",