@phnx-labs/agents-cli 1.14.7 → 1.16.0

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,7 +8,7 @@
 import chalk from 'chalk';
 import { buildExecCommand, parseExecEnv, execAgent, runWithFallback, AGENT_COMMANDS, } from '../lib/exec.js';
 import { profileExists, resolveProfileForRun } from '../lib/profiles.js';
-import { readBundle, resolveBundleEnv } from '../lib/secrets/bundles.js';
+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';
 const VALID_AGENTS = Object.keys(AGENT_COMMANDS);
@@ -36,7 +36,7 @@ export function registerRunCommand(program) {
         .option('--cwd <dir>', 'Working directory for the agent (defaults to current directory)')
         .option('--add-dir <dir>', 'Grant access to an additional directory outside the project (Claude only, repeatable)', (val, prev) => [...prev, val], [])
         .option('--json', 'Stream events as JSON lines (for parsing by other tools)')
-        .option('--headless', 'Non-interactive mode (default for run)', true)
+        .option('--headless', 'Non-interactive mode (auto-enabled when prompt provided)', false)
         .option('-i, --interactive', 'Force interactive mode even when a prompt is provided')
         .option('--session-id <id>', 'Resume a previous conversation (Claude only)')
         .option('--verbose', 'Show detailed execution logs')
@@ -197,6 +197,13 @@ Examples:
         for (const bundleName of options.secrets) {
             try {
                 const bundle = readBundle(bundleName);
+                const entries = describeBundle(bundle);
+                const counts = {};
+                for (const e of entries) {
+                    counts[e.kind] = (counts[e.kind] || 0) + 1;
+                }
+                const breakdown = Object.entries(counts).map(([k, v]) => `${v} ${k}`).join(', ');
+                console.log(chalk.gray(`[secrets] Resolved ${bundleName}: ${entries.length} keys (${breakdown})`));
                 secretsEnv = { ...secretsEnv, ...resolveBundleEnv(bundle) };
             }
             catch (err) {

package/dist/commands/fork.js

@@ -15,14 +15,14 @@ import { isPromptCancelled } from './utils.js';
 export function registerForkCommand(program) {
     program
         .command('fork')
-        .description('Copy the default config repo to your own GitHub so you can push changes. Runs once after init.')
+        .description('Copy the default config repo to your own GitHub so you can push changes. Runs once after setup.')
         .addHelpText('after', `
 Examples:
   # Fork the default repo to your GitHub account
   agents fork
 
 When to use:
-  - You initialized with 'agents init' using the default config
+  - You set up with 'agents setup' using the default config
   - You've customized commands, skills, or settings
   - You want to save your changes to your own GitHub repo
 

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

@@ -6,8 +6,8 @@ import { readManifest, writeManifest, createDefaultManifest } from '../lib/manif
 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 { getAgentsDir } from '../lib/state.js';
-import { isPromptCancelled, isInteractiveTerminal, requireInteractiveSelection } from './utils.js';
+import { getUserAgentsDir } from '../lib/state.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) {
@@ -163,7 +163,7 @@ Examples:
             console.log(chalk.gray('HTTP:  agents mcp add <name> <url> --transport http'));
             process.exit(1);
         }
-        const localPath = getAgentsDir();
+        const localPath = getUserAgentsDir();
         const manifest = readManifest(localPath) || createDefaultManifest();
         manifest.mcp = manifest.mcp || {};
         const targetConfig = parseMcpAgentTargets(options.agents);
@@ -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}`);
@@ -400,7 +442,7 @@ Examples:
   agents mcp register --agents codex@0.116.0
 `)
         .action(async (name, options) => {
-        const localPath = getAgentsDir();
+        const localPath = getUserAgentsDir();
         const manifest = readManifest(localPath);
         if (!manifest?.mcp) {
             console.log(chalk.yellow('No MCP servers in manifest'));
@@ -467,7 +509,7 @@ function buildMcpRows(opts) {
     const centralServers = new Map();
     for (const s of listMcpServerConfigs())
         centralServers.set(s.name, s);
-    const manifest = readManifest(getAgentsDir());
+    const manifest = readManifest(getUserAgentsDir());
     const manifestEntries = manifest?.mcp || {};
     const targetPairs = iterMcpCapableVersions({
         agent: opts.filterAgent,

package/dist/commands/plugins.js

@@ -12,7 +12,7 @@ import { PLUGINS_CAPABLE_AGENTS, agentLabel } from '../lib/agents.js';
 import { discoverPlugins, getPlugin, pluginSupportsAgent, removePluginFromVersion } from '../lib/plugins.js';
 import { listInstalledVersions, syncResourcesToVersion, getGlobalDefault, getVersionHomePath, } from '../lib/versions.js';
 import { isPluginSynced } from '../lib/plugins.js';
-import { isPromptCancelled, isInteractiveTerminal, requireDestructiveArg, requireInteractiveSelection, } from './utils.js';
+import { isPromptCancelled, isInteractiveTerminal, requireDestructiveArg, requireInteractiveSelection, promptRemovalTargets, } from './utils.js';
 import { itemPicker } from '../lib/picker.js';
 import { showResourceList, buildTargetsSection, } from './resource-view.js';
 import { getPluginsDir } from '../lib/state.js';
@@ -255,7 +255,7 @@ Examples:
   # Unsync but keep source directory
   agents plugins remove rush-toolkit --keep-source
 `)
-        .action((nameArg, options) => {
+        .action(async (nameArg, options) => {
         if (!nameArg) {
             requireDestructiveArg({
                 argName: 'name',
@@ -275,31 +275,64 @@ Examples:
             console.log(chalk.red(`Plugin '${name}' not found`));
             process.exit(1);
         }
-        let totalSkills = 0;
-        let totalHooks = 0;
-        let totalPerms = 0;
-        let versionsTouched = 0;
+        // Build list of targets that have this plugin synced
+        const availableTargets = [];
         for (const agentId of PLUGINS_CAPABLE_AGENTS) {
+            if (plugin && !pluginSupportsAgent(plugin, agentId))
+                continue;
             const versions = listInstalledVersions(agentId);
             for (const version of versions) {
                 const versionHome = getVersionHomePath(agentId, version);
-                const r = removePluginFromVersion(name, resolvedRoot, agentId, versionHome);
-                if (r.skills.length > 0 || r.hooks.length > 0 || r.permissions > 0) {
-                    versionsTouched += 1;
-                    totalSkills += r.skills.length;
-                    totalHooks += r.hooks.length;
-                    totalPerms += r.permissions;
-                    console.log(chalk.gray(`  ${agentLabel(agentId)}@${version}: ${r.skills.length} skill(s), ${r.hooks.length} hook(s), ${r.permissions} perm(s)`));
+                if (plugin && isPluginSynced(plugin, agentId, versionHome)) {
+                    availableTargets.push({ agent: agentId, version });
                 }
             }
         }
-        console.log(chalk.green(`Unsynced ${name} from ${versionsTouched} version(s) — ${totalSkills} skills, ${totalHooks} hooks, ${totalPerms} permissions`));
-        if (!options.keepSource) {
+        if (availableTargets.length === 0) {
+            console.log(chalk.yellow(`Plugin '${name}' not synced to any version.`));
+            if (!options.keepSource && fs.existsSync(pluginRoot)) {
+                fs.rmSync(pluginRoot, { recursive: true, force: true });
+                console.log(chalk.green(`Deleted ${formatPath(pluginRoot)}`));
+            }
+            return;
+        }
+        // Show multi-select picker for targets
+        const removalTargets = availableTargets.map((t) => ({
+            agent: t.agent,
+            version: t.version,
+            label: `${agentLabel(t.agent)}@${t.version}`,
+        }));
+        const selectedTargets = await promptRemovalTargets(name, removalTargets);
+        if (selectedTargets.length === 0) {
+            console.log(chalk.gray('Cancelled.'));
+            return;
+        }
+        let totalSkills = 0;
+        let totalHooks = 0;
+        let totalPerms = 0;
+        let versionsTouched = 0;
+        for (const target of selectedTargets) {
+            const versionHome = getVersionHomePath(target.agent, target.version);
+            const r = removePluginFromVersion(name, resolvedRoot, target.agent, versionHome);
+            if (r.skills.length > 0 || r.hooks.length > 0 || r.permissions > 0) {
+                versionsTouched += 1;
+                totalSkills += r.skills.length;
+                totalHooks += r.hooks.length;
+                totalPerms += r.permissions;
+                console.log(`  ${chalk.red('-')} ${target.label}: ${r.skills.length} skill(s), ${r.hooks.length} hook(s), ${r.permissions} perm(s)`);
+            }
+        }
+        console.log(chalk.green(`\nUnsynced ${name} from ${versionsTouched} version(s) — ${totalSkills} skills, ${totalHooks} hooks, ${totalPerms} permissions`));
+        // Only delete source if ALL targets were selected
+        if (!options.keepSource && selectedTargets.length === availableTargets.length) {
             if (fs.existsSync(pluginRoot)) {
                 fs.rmSync(pluginRoot, { recursive: true, force: true });
                 console.log(chalk.green(`Deleted ${formatPath(pluginRoot)}`));
             }
         }
+        else if (!options.keepSource && selectedTargets.length < availableTargets.length) {
+            console.log(chalk.gray(`Source kept — plugin still synced to other versions.`));
+        }
         else {
             console.log(chalk.gray(`Kept source at ${formatPath(pluginRoot)}`));
         }

package/dist/commands/prune.d.ts

@@ -1,22 +1,2 @@
-/**
- * Top-level `agents prune` — destructive cleanup across the install.
- *
- * Two kinds of cleanup, one verb:
- *   - Resource orphans: command/skill/hook files inside a version home that no
- *     longer come from any source (deleted from ~/.agents/ but never reconciled
- *     into the version install).
- *   - Version duplicates: older installed versions of an agent that share an
- *     account with a newer installed version of the same agent (the older copy
- *     is redundant; the newer one is what's signed in and active).
- *
- * Sync (additive: copy missing/changed files into version homes) is no longer
- * a user-facing verb — `syncResourcesToVersion` runs at agent launch and
- * applies adds/updates automatically. Pruning, however, is destructive, so it
- * stays explicit.
- *
- * Default scope: each agent's currently-pinned default version for orphan
- * cleanup, plus the standard cross-agent version-dedup pass. Pass `--all`
- * to widen orphan cleanup to every installed version.
- */
 import type { Command } from 'commander';
 export declare function registerPruneCommand(program: Command): void;