@phnx-labs/agents-cli 1.15.0 → 1.17.0

package/dist/commands/cloud.js

@@ -106,6 +106,9 @@ Examples:
         .option('--env <id>', 'Codex Cloud environment ID')
         .option('--computer <name>', 'Factory/Droid computer target')
         .option('--mode <mode>', 'Execution mode (e.g., plan, edit, full)')
+        .option('-b, --balanced', 'Shortcut for --strategy balanced. Route the factory run across all healthy accounts.')
+        .option('--strategy <strategy>', 'Account selection strategy for the factory: balanced. Sends all healthy accounts so the factory pod rotates between them on rate-limit.')
+        .option('--upload-account-tokens', 'Upload Claude OAuth credentials to Rush Cloud on first dispatch (consent recorded for future runs).')
         .option('--json', 'Structured JSON output')
         .option('--no-follow', 'Dispatch and exit without streaming output')
         .addHelpText('after', `
@@ -165,6 +168,11 @@ Examples:
             dispatchOptions.providerOptions.computer = options.computer;
         if (options.mode)
             dispatchOptions.providerOptions.mode = options.mode;
+        if (options.balanced || options.strategy === 'balanced') {
+            dispatchOptions.providerOptions.strategy = 'balanced';
+        }
+        if (options.uploadAccountTokens)
+            dispatchOptions.providerOptions.uploadAccountTokens = true;
         // Dispatch
         const spinner = ora({ text: `Dispatching to ${provider.name}...`, stream: process.stderr }).start();
         let task;

package/dist/commands/commands.js

@@ -4,14 +4,14 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { checkbox } from '@inquirer/prompts';
-import { ALL_AGENT_IDS, resolveAgentName, formatAgentError, agentLabel, } from '../lib/agents.js';
+import { AGENTS, ALL_AGENT_IDS, resolveAgentName, formatAgentError, agentLabel, } from '../lib/agents.js';
 import { cloneRepo } from '../lib/git.js';
-import { discoverCommands, resolveCommandSource, installCommandCentrally, uninstallCommand, listCentralCommands, getCommandInfo, diffVersionCommands, iterCommandsCapableVersions, } from '../lib/commands.js';
+import { discoverCommands, resolveCommandSource, installCommandCentrally, listCentralCommands, listInstalledCommandsWithScope, getCommandInfo, diffVersionCommands, iterCommandsCapableVersions, removeCommandFromVersion, } from '../lib/commands.js';
 import { getCommandsDir } from '../lib/state.js';
 import { showResourceList, buildTargetsSection, } from './resource-view.js';
-import { getGlobalDefault, resolveVersionAlias, syncResourcesToVersion, promptAgentVersionSelection, resolveAgentVersionTargets, } from '../lib/versions.js';
+import { getGlobalDefault, resolveVersionAlias, syncResourcesToVersion, promptAgentVersionSelection, getVersionHomePath, resolveAgentVersionTargets, } from '../lib/versions.js';
 import { recordVersionResources } from '../lib/state.js';
-import { isPromptCancelled, isInteractiveTerminal, parseCommaSeparatedList, printWithPager, requireInteractiveSelection, } from './utils.js';
+import { isPromptCancelled, isInteractiveTerminal, parseCommaSeparatedList, printWithPager, requireInteractiveSelection, promptRemovalTargets, } from './utils.js';
 /** Register the `agents commands` command tree (list, add, remove, sync, prune, view). */
 export function registerCommandsCommands(program) {
     const commandsCmd = program
@@ -271,15 +271,29 @@ Examples:
   agents commands remove
 `)
         .action(async (name, options) => {
+        const cmdTargetMap = new Map();
+        for (const { agent, version } of iterCommandsCapableVersions()) {
+            const home = getVersionHomePath(agent, version);
+            const commands = listInstalledCommandsWithScope(agent, process.cwd(), { home });
+            for (const cmd of commands) {
+                if (cmd.scope !== 'user')
+                    continue;
+                const existing = cmdTargetMap.get(cmd.name);
+                if (existing) {
+                    existing.targets.push({ agent, version });
+                }
+                else {
+                    cmdTargetMap.set(cmd.name, { name: cmd.name, targets: [{ agent, version }] });
+                }
+            }
+        }
         let commandsToRemove;
         if (name) {
             commandsToRemove = [name];
         }
         else {
-            // Interactive picker
-            const centralCommands = listCentralCommands();
-            if (centralCommands.length === 0) {
-                console.log(chalk.yellow('No commands installed.'));
+            if (cmdTargetMap.size === 0) {
+                console.log(chalk.yellow('No commands installed in any version.'));
                 return;
             }
             if (!isInteractiveTerminal()) {
@@ -288,12 +302,16 @@ Examples:
                 ]);
             }
             try {
+                const choices = Array.from(cmdTargetMap.values()).map((cmd) => {
+                    const agents = [...new Set(cmd.targets.map((t) => AGENTS[t.agent].name))];
+                    return {
+                        value: cmd.name,
+                        name: `${cmd.name} (${agents.join(', ')})`,
+                    };
+                });
                 const selected = await checkbox({
                     message: 'Select commands to remove',
-                    choices: centralCommands.map((cmd) => ({
-                        value: cmd,
-                        name: cmd,
-                    })),
+                    choices,
                 });
                 if (selected.length === 0) {
                     console.log(chalk.gray('No commands selected.'));
@@ -309,20 +327,52 @@ Examples:
                 throw err;
             }
         }
-        const agents = options?.agents
-            ? options.agents.split(',')
-            : ALL_AGENT_IDS;
+        let removed = 0;
         for (const cmdName of commandsToRemove) {
-            let removed = 0;
-            for (const agentId of agents) {
-                if (uninstallCommand(agentId, cmdName)) {
-                    console.log(`  ${chalk.red('-')} ${agentLabel(agentId)}: ${cmdName}`);
+            const cmdInfo = cmdTargetMap.get(cmdName);
+            if (!cmdInfo || cmdInfo.targets.length === 0) {
+                console.log(chalk.yellow(`  Command '${cmdName}' not found in any version.`));
+                continue;
+            }
+            // Filter by --agents if specified
+            let availableTargets = cmdInfo.targets;
+            if (options?.agents) {
+                const requestedAgents = new Set(options.agents.split(','));
+                availableTargets = availableTargets.filter((t) => requestedAgents.has(t.agent));
+            }
+            if (availableTargets.length === 0) {
+                console.log(chalk.yellow(`  Command '${cmdName}' not found in specified agents.`));
+                continue;
+            }
+            const removalTargets = availableTargets.map((t) => ({
+                agent: t.agent,
+                version: t.version,
+                label: `${agentLabel(t.agent)}@${t.version}`,
+            }));
+            const selectedTargets = await promptRemovalTargets(cmdName, removalTargets, {
+                skipPrompt: !!options?.agents,
+            });
+            if (selectedTargets.length === 0) {
+                console.log(chalk.gray(`  Skipped '${cmdName}'.`));
+                continue;
+            }
+            for (const target of selectedTargets) {
+                const result = removeCommandFromVersion(target.agent, target.version, cmdName);
+                if (result.success) {
+                    console.log(`  ${chalk.red('-')} ${target.label}: ${cmdName}`);
                     removed++;
                 }
+                else if (result.error) {
+                    console.log(`  ${chalk.yellow('!')} ${target.label}: ${result.error}`);
+                }
             }
-            if (removed === 0) {
-                console.log(chalk.yellow(`Command '${cmdName}' not found for any agent`));
-            }
+        }
+        if (removed === 0) {
+            console.log(chalk.yellow('No commands removed.'));
+        }
+        else {
+            console.log(chalk.green(`\nRemoved ${removed} command(s) from version homes.`));
+            console.log(chalk.gray('Central source unchanged. Commands will re-sync on next agent launch.'));
         }
     });
     // `commands sync` is gone — sync runs automatically when the agent launches.

package/dist/commands/daemon.js

@@ -91,8 +91,8 @@ you never need to start it manually.
         .action(async (options) => {
         warnDeprecated('logs', 'agents routines scheduler-logs');
         if (options.follow) {
-            const { getAgentsDir } = await import('../lib/state.js');
-            const logPath = path.join(getAgentsDir(), 'helpers/daemon/logs.jsonl');
+            const { getDaemonDir } = await import('../lib/state.js');
+            const logPath = path.join(getDaemonDir(), 'logs.jsonl');
             const child = spawn('tail', ['-f', logPath], { stdio: ['ignore', 'pipe', 'pipe'] });
             child.stdout.pipe(process.stdout);
             child.stderr.pipe(process.stderr);

package/dist/commands/exec.js

@@ -8,9 +8,22 @@
 import chalk from 'chalk';
 import { buildExecCommand, parseExecEnv, execAgent, runWithFallback, AGENT_COMMANDS, } from '../lib/exec.js';
 import { profileExists, resolveProfileForRun } from '../lib/profiles.js';
+import { getSystemAgentsDir, getUserAgentsDir } from '../lib/state.js';
+/** Resolve a workflow by name. User repo wins over system repo. Returns the workflow dir or null. */
+function resolveWorkflow(name) {
+    for (const base of [getUserAgentsDir(), getSystemAgentsDir()]) {
+        const dir = path.join(base, 'workflows', name);
+        if (fs.existsSync(path.join(dir, 'WORKFLOW.md')))
+            return dir;
+    }
+    return null;
+}
 import { readBundle, resolveBundleEnv, describeBundle } from '../lib/secrets/bundles.js';
 import { getConfiguredRunStrategy, normalizeRunStrategy, resolveRunVersion, RUN_STRATEGIES, } from '../lib/rotate.js';
-import { resolveVersionAlias } from '../lib/versions.js';
+import { getGlobalDefault, getVersionHomePath, resolveVersionAlias } from '../lib/versions.js';
+import { buildDiscoveredPlugin, loadPluginManifest, syncPluginToVersion } from '../lib/plugins.js';
+import * as fs from 'fs';
+import * as path from 'path';
 const VALID_AGENTS = Object.keys(AGENT_COMMANDS);
 /** Type guard that narrows a string to a known AgentId. */
 function isValidAgent(agent) {
@@ -122,6 +135,62 @@ Examples:
                 process.exit(1);
             }
         }
+        else if (resolveWorkflow(rawAgent)) {
+            // Workflow: ~/.agents-system/workflows/<name>/ or ~/.agents/workflows/<name>/
+            // Resolution: user repo wins over system repo (same precedence as all resources).
+            // Structure:
+            //   WORKFLOW.md        ← orchestrator instructions fed to claude as system prompt
+            //   subagents/*.md     ← flat .md files copied to ~/.claude/agents/ for Agent tool discovery
+            const workflowDir = resolveWorkflow(rawAgent);
+            agent = 'claude';
+            const resolvedVersion = resolveVersionAlias('claude', version);
+            const versionHome = getVersionHomePath('claude', resolvedVersion ?? getGlobalDefault('claude') ?? '');
+            const claudeAgentsDir = path.join(versionHome, '.claude', 'agents');
+            // Copy subagents/*.md into ~/.claude/agents/ so Claude's Agent tool finds them.
+            const subagentsDir = path.join(workflowDir, 'subagents');
+            if (fs.existsSync(subagentsDir)) {
+                fs.mkdirSync(claudeAgentsDir, { recursive: true });
+                for (const file of fs.readdirSync(subagentsDir).filter(f => f.endsWith('.md'))) {
+                    fs.copyFileSync(path.join(subagentsDir, file), path.join(claudeAgentsDir, file));
+                }
+            }
+            // Feed WORKFLOW.md body (strip frontmatter) as orchestrator system context.
+            const workflowMd = path.join(workflowDir, 'WORKFLOW.md');
+            const orchestratorBody = fs.existsSync(workflowMd)
+                ? fs.readFileSync(workflowMd, 'utf-8').replace(/^---[\s\S]*?---\n/, '').trim()
+                : '';
+            if (orchestratorBody && prompt !== undefined) {
+                prompt = `${orchestratorBody}\n\n---\n\n${prompt}`;
+            }
+            // Sync workflow-scoped skills into the version home's skills dir.
+            const workflowSkillsDir = path.join(workflowDir, 'skills');
+            if (fs.existsSync(workflowSkillsDir)) {
+                const skillsTarget = path.join(claudeAgentsDir, '..', 'skills');
+                fs.mkdirSync(skillsTarget, { recursive: true });
+                for (const entry of fs.readdirSync(workflowSkillsDir, { withFileTypes: true })) {
+                    if (!entry.isDirectory())
+                        continue;
+                    fs.cpSync(path.join(workflowSkillsDir, entry.name), path.join(skillsTarget, entry.name), { recursive: true });
+                }
+            }
+            // Sync workflow-scoped plugins into the version home.
+            const workflowPluginsDir = path.join(workflowDir, 'plugins');
+            if (fs.existsSync(workflowPluginsDir)) {
+                for (const entry of fs.readdirSync(workflowPluginsDir, { withFileTypes: true })) {
+                    if (!entry.isDirectory())
+                        continue;
+                    const pluginRoot = path.join(workflowPluginsDir, entry.name);
+                    const manifest = loadPluginManifest(pluginRoot);
+                    if (!manifest)
+                        continue;
+                    syncPluginToVersion(buildDiscoveredPlugin(pluginRoot, manifest), 'claude', versionHome);
+                }
+            }
+            const subagentCount = fs.existsSync(subagentsDir)
+                ? fs.readdirSync(subagentsDir).filter(f => f.endsWith('.md')).length
+                : 0;
+            process.stderr.write(chalk.gray(`Workflow '${rawAgent}' → claude (${subagentCount} subagents)\n`));
+        }
         else {
             console.error(chalk.red(`Unknown agent: ${rawAgent}`));
             console.error(chalk.gray(`Available agents: ${VALID_AGENTS.join(', ')}`));

package/dist/commands/hooks.js

@@ -7,10 +7,10 @@ import { checkbox } from '@inquirer/prompts';
 import { AGENTS, HOOKS_CAPABLE_AGENTS, resolveAgentName, formatAgentError, agentLabel, } from '../lib/agents.js';
 import { supports } from '../lib/capabilities.js';
 import { cloneRepo } from '../lib/git.js';
-import { discoverHooksFromRepo, installHooksCentrally, listCentralHooks, listInstalledHooksWithScope, removeHook, getHookInfo, parseHookManifest, } from '../lib/hooks.js';
+import { discoverHooksFromRepo, installHooksCentrally, listCentralHooks, listInstalledHooksWithScope, getHookInfo, parseHookManifest, iterHooksCapableVersions, removeHookFromVersion, } from '../lib/hooks.js';
 import { listInstalledVersions, getGlobalDefault, resolveVersionAlias, syncResourcesToVersion, promptAgentVersionSelection, getVersionHomePath, resolveAgentVersionTargets, } from '../lib/versions.js';
 import { recordVersionResources } from '../lib/state.js';
-import { isPromptCancelled, isInteractiveTerminal, parseCommaSeparatedList, printWithPager, requireInteractiveSelection, } from './utils.js';
+import { isPromptCancelled, isInteractiveTerminal, parseCommaSeparatedList, printWithPager, requireInteractiveSelection, promptRemovalTargets, } from './utils.js';
 /** Register the `agents hooks` command tree (list, add, remove, sync, prune, view). */
 export function registerHooksCommands(program) {
     const hooksCmd = program.command('hooks')
@@ -396,15 +396,29 @@ Examples:
   agents hooks remove
 `)
         .action(async (name, options) => {
+        const hookTargetMap = new Map();
+        for (const { agent, version } of iterHooksCapableVersions()) {
+            const home = getVersionHomePath(agent, version);
+            const hooks = listInstalledHooksWithScope(agent, process.cwd(), { home });
+            for (const hook of hooks) {
+                if (hook.scope !== 'user')
+                    continue;
+                const existing = hookTargetMap.get(hook.name);
+                if (existing) {
+                    existing.targets.push({ agent, version });
+                }
+                else {
+                    hookTargetMap.set(hook.name, { name: hook.name, targets: [{ agent, version }] });
+                }
+            }
+        }
         let hooksToRemove;
         if (name) {
             hooksToRemove = [name];
         }
         else {
-            // Interactive picker
-            const centralHooks = listCentralHooks();
-            if (centralHooks.length === 0) {
-                console.log(chalk.yellow('No hooks installed.'));
+            if (hookTargetMap.size === 0) {
+                console.log(chalk.yellow('No hooks installed in any version.'));
                 return;
             }
             if (!isInteractiveTerminal()) {
@@ -413,12 +427,16 @@ Examples:
                 ]);
             }
             try {
+                const choices = Array.from(hookTargetMap.values()).map((hook) => {
+                    const agents = [...new Set(hook.targets.map((t) => AGENTS[t.agent].name))];
+                    return {
+                        value: hook.name,
+                        name: `${hook.name} (${agents.join(', ')})`,
+                    };
+                });
                 const selected = await checkbox({
                     message: 'Select hooks to remove',
-                    choices: centralHooks.map((hook) => ({
-                        value: hook.name,
-                        name: hook.name,
-                    })),
+                    choices,
                 });
                 if (selected.length === 0) {
                     console.log(chalk.gray('No hooks selected.'));
@@ -434,26 +452,53 @@ Examples:
                 throw err;
             }
         }
-        const agents = options?.agents
-            ? options.agents.split(',')
-            : Array.from(HOOKS_CAPABLE_AGENTS);
+        let removed = 0;
         for (const hookName of hooksToRemove) {
-            const result = await removeHook(hookName, agents);
-            let removed = 0;
-            for (const item of result.removed) {
-                const [, agentId] = item.split(':');
-                console.log(`  ${chalk.red('-')} ${agentLabel(agentId)}: ${hookName}`);
-                removed++;
-            }
-            if (result.errors.length > 0) {
-                for (const error of result.errors) {
-                    console.log(chalk.red(`  ${error}`));
-                }
+            const hookInfo = hookTargetMap.get(hookName);
+            if (!hookInfo || hookInfo.targets.length === 0) {
+                console.log(chalk.yellow(`  Hook '${hookName}' not found in any version.`));
+                continue;
+            }
+            // Filter by --agents if specified
+            let availableTargets = hookInfo.targets;
+            if (options?.agents) {
+                const requestedAgents = new Set(options.agents.split(','));
+                availableTargets = availableTargets.filter((t) => requestedAgents.has(t.agent));
+            }
+            if (availableTargets.length === 0) {
+                console.log(chalk.yellow(`  Hook '${hookName}' not found in specified agents.`));
+                continue;
+            }
+            const removalTargets = availableTargets.map((t) => ({
+                agent: t.agent,
+                version: t.version,
+                label: `${agentLabel(t.agent)}@${t.version}`,
+            }));
+            const selectedTargets = await promptRemovalTargets(hookName, removalTargets, {
+                skipPrompt: !!options?.agents,
+            });
+            if (selectedTargets.length === 0) {
+                console.log(chalk.gray(`  Skipped '${hookName}'.`));
+                continue;
             }
-            if (removed === 0) {
-                console.log(chalk.yellow(`Hook '${hookName}' not found for any agent`));
+            for (const target of selectedTargets) {
+                const result = removeHookFromVersion(target.agent, target.version, hookName);
+                if (result.success) {
+                    console.log(`  ${chalk.red('-')} ${target.label}: ${hookName}`);
+                    removed++;
+                }
+                else if (result.error) {
+                    console.log(`  ${chalk.yellow('!')} ${target.label}: ${result.error}`);
+                }
             }
         }
+        if (removed === 0) {
+            console.log(chalk.yellow('No hooks removed.'));
+        }
+        else {
+            console.log(chalk.green(`\nRemoved ${removed} hook(s) from version homes.`));
+            console.log(chalk.gray('Central source unchanged. Hooks will re-sync on next agent launch.'));
+        }
     });
     // `hooks sync` is gone — sync runs automatically when the agent launches.
     hooksCmd

package/dist/commands/mcp.js

@@ -7,7 +7,7 @@ import { listMcpServerConfigs } from '../lib/mcp.js';
 import { getMcpDir } from '../lib/state.js';
 import { getEffectiveHome, getGlobalDefault, listInstalledVersions, getVersionHomePath, resolveInstalledAgentTargets, resolveConfiguredAgentTargets, resolveVersionAlias, } from '../lib/versions.js';
 import { getUserAgentsDir } from '../lib/state.js';
-import { isPromptCancelled, isInteractiveTerminal, requireInteractiveSelection } from './utils.js';
+import { isPromptCancelled, isInteractiveTerminal, requireInteractiveSelection, promptRemovalTargets } from './utils.js';
 import { showResourceList, buildTargetsSection, } from './resource-view.js';
 /** Parse a comma-separated --agents string into validated agent IDs and optional version targets. */
 function parseMcpAgentTargets(value) {
@@ -219,20 +219,33 @@ Examples:
         .action(async (name, options) => {
         const cwd = process.cwd();
         const cliStates = await getAllCliStates();
+        const mcpTargetMap = new Map();
+        for (const agentId of MCP_CAPABLE_AGENTS) {
+            if (!cliStates[agentId]?.installed && listInstalledVersions(agentId).length === 0)
+                continue;
+            for (const version of listInstalledVersions(agentId)) {
+                const home = getVersionHomePath(agentId, version);
+                const configPath = getMcpConfigPathForHome(agentId, home);
+                const mcps = parseMcpConfig(agentId, configPath);
+                for (const mcpName of Object.keys(mcps)) {
+                    const existing = mcpTargetMap.get(mcpName);
+                    if (existing) {
+                        existing.targets.push({ agentId, version, home });
+                    }
+                    else {
+                        mcpTargetMap.set(mcpName, { name: mcpName, targets: [{ agentId, version, home }] });
+                    }
+                }
+            }
+        }
         let mcpsToRemove;
-        let targets;
         if (name) {
             mcpsToRemove = [name];
-            const installedAgents = MCP_CAPABLE_AGENTS.filter((agentId) => cliStates[agentId]?.installed || listInstalledVersions(agentId).length > 0);
-            targets = options?.agents
-                ? resolveInstalledAgentTargets(options.agents, MCP_CAPABLE_AGENTS)
-                : resolveConfiguredAgentTargets(installedAgents, undefined, MCP_CAPABLE_AGENTS);
         }
         else {
-            // Interactive picker: collect all MCPs across all installed agents
-            const installedAgents = MCP_CAPABLE_AGENTS.filter((agentId) => cliStates[agentId]?.installed);
-            if (installedAgents.length === 0) {
-                console.log(chalk.yellow('No MCP-capable agents installed.'));
+            // Interactive picker for MCP selection
+            if (mcpTargetMap.size === 0) {
+                console.log(chalk.yellow('No MCP servers configured.'));
                 return;
             }
             if (!isInteractiveTerminal()) {
@@ -241,42 +254,22 @@ Examples:
                     'agents mcp remove my-server --agents codex,claude',
                 ]);
             }
-            // Gather all unique MCPs across agents (with agent info for display)
-            const mcpMap = new Map();
-            for (const agentId of installedAgents) {
-                const mcps = listInstalledMcpsWithScope(agentId, cwd, { home: getEffectiveHome(agentId) });
-                for (const mcp of mcps) {
-                    const existing = mcpMap.get(mcp.name);
-                    if (existing) {
-                        existing.agents.push(AGENTS[agentId].name);
-                    }
-                    else {
-                        mcpMap.set(mcp.name, {
-                            name: mcp.name,
-                            agents: [AGENTS[agentId].name],
-                            command: mcp.command,
-                        });
-                    }
-                }
-            }
-            if (mcpMap.size === 0) {
-                console.log(chalk.yellow('No MCP servers configured.'));
-                return;
-            }
             try {
                 const selected = await checkbox({
                     message: 'Select MCP servers to remove',
-                    choices: Array.from(mcpMap.values()).map((mcp) => ({
-                        value: mcp.name,
-                        name: `${mcp.name} (${mcp.agents.join(', ')})`,
-                    })),
+                    choices: Array.from(mcpTargetMap.values()).map((mcp) => {
+                        const agents = [...new Set(mcp.targets.map((t) => AGENTS[t.agentId].name))];
+                        return {
+                            value: mcp.name,
+                            name: `${mcp.name} (${agents.join(', ')})`,
+                        };
+                    }),
                 });
                 if (selected.length === 0) {
                     console.log(chalk.gray('No MCPs selected.'));
                     return;
                 }
                 mcpsToRemove = selected;
-                targets = resolveConfiguredAgentTargets(installedAgents, undefined, MCP_CAPABLE_AGENTS);
             }
             catch (err) {
                 if (isPromptCancelled(err)) {
@@ -286,10 +279,59 @@ Examples:
                 throw err;
             }
         }
-        // Execute removals - try each MCP on each target agent
+        // Execute removals with target selection
         let removed = 0;
         for (const mcpName of mcpsToRemove) {
-            const results = await unregisterMcpFromTargets(targets, mcpName);
+            const mcpInfo = mcpTargetMap.get(mcpName);
+            if (!mcpInfo || mcpInfo.targets.length === 0) {
+                console.log(chalk.yellow(`  MCP '${mcpName}' not found in any agent.`));
+                continue;
+            }
+            // If --agents was specified, filter targets
+            let availableTargets = mcpInfo.targets;
+            if (options?.agents) {
+                const requestedTargets = resolveInstalledAgentTargets(options.agents, MCP_CAPABLE_AGENTS);
+                const requested = new Set();
+                for (const aid of requestedTargets.directAgents) {
+                    for (const ver of listInstalledVersions(aid)) {
+                        requested.add(`${aid}@${ver}`);
+                    }
+                }
+                for (const [aid, versions] of requestedTargets.versionSelections) {
+                    for (const ver of versions) {
+                        requested.add(`${aid}@${ver}`);
+                    }
+                }
+                availableTargets = availableTargets.filter((t) => requested.has(`${t.agentId}@${t.version}`));
+            }
+            if (availableTargets.length === 0) {
+                console.log(chalk.yellow(`  MCP '${mcpName}' not found in specified agents.`));
+                continue;
+            }
+            // Show target picker if multiple targets and no --agents flag
+            const removalTargets = availableTargets.map((t) => ({
+                agent: t.agentId,
+                version: t.version,
+                label: formatTargetLabel(t.agentId, t.version),
+            }));
+            const selectedTargets = await promptRemovalTargets(mcpName, removalTargets, {
+                skipPrompt: !!options?.agents,
+            });
+            if (selectedTargets.length === 0) {
+                console.log(chalk.gray(`  Skipped '${mcpName}'.`));
+                continue;
+            }
+            // Build targets structure for unregister
+            const versionSelections = new Map();
+            for (const t of selectedTargets) {
+                const versions = versionSelections.get(t.agent) || [];
+                if (!versions.includes(t.version)) {
+                    versions.push(t.version);
+                    versionSelections.set(t.agent, versions);
+                }
+            }
+            const targetsToRemove = { directAgents: [], versionSelections };
+            const results = await unregisterMcpFromTargets(targetsToRemove, mcpName);
             for (const result of results) {
                 if (result.success) {
                     console.log(`  ${chalk.red('-')} ${formatTargetLabel(result.agentId, result.version)}: ${mcpName}`);