@phnx-labs/agents-cli 1.20.59 → 1.20.61

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
@@ -2462,9 +2534,14 @@ export function syncResourcesToVersion(agent, version, selection, options = {})
     // reads only user + system layers (project excluded for the same defense
     // as commands/skills/hooks).
     const subagentsWriter = getWriter('subagents', agent);
-    const subagentsToSync = selection
+    const subagentsGate = supports(agent, 'subagents', version);
+    const subagentsRequested = selection
         ? resolveSelection(selection.subagents, available.subagents)
         : (subagentsWriter ? available.subagents : []);
+    const subagentsToSync = subagentsGate.ok ? subagentsRequested : [];
+    if (subagentsRequested.length > 0 && !subagentsGate.ok) {
+        console.warn(explainSkip(agent, 'subagents', subagentsGate, version) + ' -- skipped');
+    }
     if (subagentsToSync.length > 0 && subagentsWriter) {
         const r = subagentsWriter.write({ version, versionHome, selection: subagentsToSync, cwd });
         result.subagents.push(...r.synced);
@@ -2499,9 +2576,14 @@ export function syncResourcesToVersion(agent, version, selection, options = {})
     }
     // Sync workflows — dispatch through WRITERS.workflows.
     const workflowsWriter = getWriter('workflows', agent);
-    const workflowsToSync = selection
+    const workflowsGate = supports(agent, 'workflows', version);
+    const workflowsRequested = selection
         ? resolveSelection(selection.workflows, available.workflows)
         : (workflowsWriter ? available.workflows : []);
+    const workflowsToSync = workflowsGate.ok ? workflowsRequested : [];
+    if (workflowsRequested.length > 0 && !workflowsGate.ok) {
+        console.warn(explainSkip(agent, 'workflows', workflowsGate, version) + ' -- skipped');
+    }
     if (workflowsToSync.length > 0 && workflowsWriter) {
         const r = workflowsWriter.write({ version, versionHome, selection: workflowsToSync, cwd });
         result.workflows.push(...r.synced);

package/dist/lib/workflows.d.ts

@@ -263,6 +263,17 @@ export declare function resolveAllowedSubagents(available: string[], allowedAgen
 export declare function pruneStaleWorkflowSubagents(sharedAgentsDir: string, workflowSubagentFiles: string[], allowedStems: string[]): string[];
 /** Count subagent .md files in a workflow's subagents/ directory. */
 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.
  *
@@ -291,10 +302,10 @@ export declare function removeWorkflow(name: string): {
     success: boolean;
     error?: string;
 };
-/** List workflow names synced into a specific agent version home (at {versionHome}/workflows/). */
-export declare function listWorkflowsForAgent(_agent: AgentId, versionHome: string): string[];
+/** List workflow names synced into a specific agent version home. */
+export declare function listWorkflowsForAgent(agent: AgentId, versionHome: string): string[];
 /** Copy a workflow directory into a version home at {versionHome}/workflows/<name>/. */
-export declare function syncWorkflowToVersion(workflowPath: string, name: string, _agent: AgentId, versionHome: string): {
+export declare function syncWorkflowToVersion(workflowPath: string, name: string, agent: AgentId, versionHome: string): {
     success: boolean;
     error?: string;
 };

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';
@@ -56,6 +57,19 @@ export function parseWorkflowFrontmatter(workflowDir) {
         return null;
     }
 }
+function readWorkflowBody(workflowDir) {
+    const workflowMdPath = path.join(workflowDir, 'WORKFLOW.md');
+    if (!fs.existsSync(workflowMdPath))
+        return '';
+    const content = fs.readFileSync(workflowMdPath, 'utf-8');
+    const lines = content.split('\n');
+    if (lines[0] !== '---')
+        return content.trim();
+    const endIndex = lines.slice(1).findIndex(l => l === '---');
+    if (endIndex < 0)
+        return content.trim();
+    return lines.slice(endIndex + 2).join('\n').trim();
+}
 /**
  * Defensively coerce a frontmatter `loop:` value into a LoopConfigRaw.
  *
@@ -315,6 +329,67 @@ export function countWorkflowSubagents(workflowDir) {
         return 0;
     }
 }
+function getWorkflowBody(workflowDir) {
+    const workflowMdPath = path.join(workflowDir, 'WORKFLOW.md');
+    if (!fs.existsSync(workflowMdPath))
+        return '';
+    const content = fs.readFileSync(workflowMdPath, 'utf-8');
+    const lines = content.split('\n');
+    if (lines[0] === '---') {
+        const endIndex = lines.slice(1).findIndex(l => l === '---');
+        if (endIndex >= 0)
+            return lines.slice(endIndex + 2).join('\n').trim();
+    }
+    return content.trim();
+}
+function indentD2BlockString(content) {
+    return content
+        .split('\n')
+        .map(line => `  ${line}`)
+        .join('\n');
+}
+function containsFlowDiagram(content) {
+    return /```(?:mermaid|d2)\b/i.test(content);
+}
+const KIMI_WORKFLOW_MARKER = 'agents_workflow';
+/** Convert a canonical agents-cli workflow bundle into a Kimi flow skill. */
+export function transformWorkflowForKimi(workflowPath, name) {
+    const fm = parseWorkflowFrontmatter(workflowPath);
+    if (!fm)
+        throw new Error(`Invalid WORKFLOW.md in ${workflowPath}`);
+    const body = getWorkflowBody(workflowPath);
+    const frontmatter = yaml.stringify({
+        name,
+        description: fm.description,
+        type: 'flow',
+        [KIMI_WORKFLOW_MARKER]: name,
+    }).trim();
+    if (containsFlowDiagram(body)) {
+        return `---\n${frontmatter}\n---\n\n${body.trim()}\n`;
+    }
+    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;
@@ -473,9 +548,65 @@ export function removeWorkflow(name) {
         return { success: false, error: err.message };
     }
 }
-/** List workflow names synced into a specific agent version home (at {versionHome}/workflows/). */
-export function listWorkflowsForAgent(_agent, versionHome) {
-    const workflowsDir = path.join(versionHome, 'workflows');
+/**
+ * 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. */
+export function listWorkflowsForAgent(agent, versionHome) {
+    if (agent === 'kimi') {
+        const skillsDir = workflowTargetRoot(agent, versionHome);
+        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 => 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))
+            return [];
+        try {
+            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));
+        }
+        catch {
+            return [];
+        }
+    }
+    const workflowsDir = workflowTargetRoot(agent, versionHome);
     if (!fs.existsSync(workflowsDir))
         return [];
     try {
@@ -487,11 +618,130 @@ export function listWorkflowsForAgent(_agent, versionHome) {
         return [];
     }
 }
+function parseSubrecipeFrontmatter(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+    if (lines[0] !== '---')
+        return { body: content.trim() };
+    const endIndex = lines.slice(1).findIndex(l => l === '---');
+    if (endIndex < 0)
+        return { body: content.trim() };
+    const frontmatter = lines.slice(1, endIndex + 1).join('\n');
+    let parsed = {};
+    try {
+        const value = yaml.parse(frontmatter);
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            parsed = value;
+        }
+    }
+    catch { /* ignore malformed subagent frontmatter */ }
+    return {
+        name: typeof parsed.name === 'string' ? parsed.name : undefined,
+        description: typeof parsed.description === 'string' ? parsed.description : undefined,
+        body: lines.slice(endIndex + 2).join('\n').trim(),
+    };
+}
+function selectedWorkflowSubagents(workflowPath, allowedAgents) {
+    const subagentsDir = path.join(workflowPath, 'subagents');
+    if (!fs.existsSync(subagentsDir))
+        return [];
+    const allowed = allowedAgents ? new Set(allowedAgents) : null;
+    return fs.readdirSync(subagentsDir, { withFileTypes: true })
+        .filter(e => e.isFile() && e.name.endsWith('.md') && !e.name.startsWith('.'))
+        .map(e => e.name.slice(0, -'.md'.length))
+        .filter(name => !allowed || allowed.has(name))
+        .sort();
+}
+function writeGooseSubrecipe(workflowPath, subrecipeName, destDir) {
+    const sourcePath = path.join(workflowPath, 'subagents', `${subrecipeName}.md`);
+    const parsed = parseSubrecipeFrontmatter(sourcePath);
+    const body = parsed.body || parsed.description || subrecipeName;
+    const recipe = {
+        version: '1.0.0',
+        title: parsed.name || subrecipeName,
+        description: parsed.description || `Subrecipe for ${subrecipeName}`,
+        instructions: body,
+        prompt: body,
+    };
+    fs.mkdirSync(destDir, { recursive: true });
+    fs.writeFileSync(path.join(destDir, `${subrecipeName}.yaml`), yaml.stringify(recipe), 'utf-8');
+}
+function syncWorkflowToGooseRecipe(workflowPath, name, versionHome) {
+    const frontmatter = parseWorkflowFrontmatter(workflowPath);
+    if (!frontmatter) {
+        return { success: false, error: `Workflow '${name}' has invalid WORKFLOW.md frontmatter` };
+    }
+    const recipesDir = path.join(versionHome, '.config', 'goose', 'recipes');
+    const recipePath = path.join(recipesDir, `${name}.yaml`);
+    const subrecipesDir = path.join(recipesDir, `${name}.subrecipes`);
+    const body = readWorkflowBody(workflowPath) || frontmatter.description || name;
+    const subagents = selectedWorkflowSubagents(workflowPath, frontmatter.allowedAgents);
+    const recipe = {
+        version: '1.0.0',
+        title: frontmatter.name || name,
+        description: frontmatter.description || name,
+        instructions: body,
+        prompt: body,
+    };
+    if (frontmatter.model) {
+        recipe.settings = { goose_model: frontmatter.model };
+    }
+    if (subagents.length > 0) {
+        recipe.sub_recipes = subagents.map(subagentName => ({
+            name: subagentName,
+            path: `./${name}.subrecipes/${subagentName}.yaml`,
+            description: `Workflow subrecipe ${subagentName}`,
+        }));
+    }
+    try {
+        fs.mkdirSync(recipesDir, { recursive: true });
+        if (fs.existsSync(subrecipesDir)) {
+            fs.rmSync(subrecipesDir, { recursive: true, force: true });
+        }
+        for (const subagentName of subagents) {
+            writeGooseSubrecipe(workflowPath, subagentName, subrecipesDir);
+        }
+        fs.writeFileSync(recipePath, yaml.stringify(recipe), 'utf-8');
+        return { success: true };
+    }
+    catch (err) {
+        return { success: false, error: err.message };
+    }
+}
 /** Copy a workflow directory into a version home at {versionHome}/workflows/<name>/. */
-export function syncWorkflowToVersion(workflowPath, name, _agent, versionHome) {
-    const targetDir = path.join(versionHome, 'workflows', name);
+export function syncWorkflowToVersion(workflowPath, name, agent, versionHome) {
+    if (agent === 'goose') {
+        return syncWorkflowToGooseRecipe(workflowPath, name, versionHome);
+    }
     try {
-        fs.mkdirSync(path.join(versionHome, 'workflows'), { recursive: true });
+        if (agent === 'kimi') {
+            const targetDir = path.join(workflowTargetRoot(agent, versionHome), name);
+            const targetFile = path.join(targetDir, 'SKILL.md');
+            if (fs.existsSync(targetFile)) {
+                const marker = kimiWorkflowMarker(targetFile);
+                if (marker !== name) {
+                    return { success: false, error: `Kimi skill '${name}' already exists and is not managed by agents-cli` };
+                }
+            }
+            fs.mkdirSync(targetDir, { recursive: true });
+            fs.writeFileSync(targetFile, transformWorkflowForKimi(workflowPath, name), 'utf-8');
+            return { success: true };
+        }
+        if (agent === 'antigravity') {
+            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 });
         if (fs.existsSync(targetDir)) {
             fs.rmSync(targetDir, { recursive: true, force: true });
         }
@@ -505,18 +755,87 @@ export function syncWorkflowToVersion(workflowPath, name, _agent, versionHome) {
 /** Remove a workflow from a specific agent version home. */
 export function removeWorkflowFromVersion(agent, version, name) {
     const versionHome = getVersionHomePath(agent, version);
-    const targetDir = path.join(versionHome, 'workflows', name);
-    if (!fs.existsSync(targetDir)) {
+    if (agent === 'antigravity') {
+        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`);
+        const subrecipesDir = path.join(versionHome, '.config', 'goose', 'recipes', `${name}.subrecipes`);
+        if (!fs.existsSync(recipePath) && !fs.existsSync(subrecipesDir)) {
+            return { success: false, error: `Workflow '${name}' not synced to ${agent}@${version}` };
+        }
+        try {
+            if (fs.existsSync(recipePath))
+                fs.rmSync(recipePath, { force: true });
+            if (fs.existsSync(subrecipesDir))
+                fs.rmSync(subrecipesDir, { recursive: true, force: true });
+            return { success: true };
+        }
+        catch (err) {
+            return { success: false, error: err.message };
+        }
+    }
+    const targetPath = path.join(workflowTargetRoot(agent, versionHome), name);
+    if (!fs.existsSync(targetPath)) {
         return { success: false, error: `Workflow '${name}' not synced to ${agent}@${version}` };
     }
     try {
-        fs.rmSync(targetDir, { recursive: true, force: true });
+        if (agent === 'kimi') {
+            const targetFile = path.join(targetPath, 'SKILL.md');
+            if (kimiWorkflowMarker(targetFile) !== name) {
+                return { success: false, error: `Kimi skill '${name}' is not managed by agents-cli` };
+            }
+        }
+        fs.rmSync(targetPath, { recursive: true, force: true });
         return { success: true };
     }
     catch (err) {
         return { success: false, error: err.message };
     }
 }
+function parseSkillFrontmatter(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+    if (lines[0] !== '---')
+        return null;
+    const endIndex = lines.slice(1).findIndex(l => l === '---');
+    if (endIndex < 0)
+        return null;
+    const frontmatter = lines.slice(1, endIndex + 1).join('\n');
+    const parsed = yaml.parse(frontmatter);
+    return parsed && typeof parsed === 'object' ? parsed : null;
+}
+function kimiWorkflowMarker(filePath) {
+    try {
+        const fm = parseSkillFrontmatter(filePath);
+        return fm?.type === 'flow' && typeof fm.agents_workflow === 'string' ? fm.agents_workflow : null;
+    }
+    catch {
+        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.59",
+  "version": "1.20.61",
   "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",