@proletariat/cli 0.2.0 → 0.3.1

package/dist/commands/agent/shell.js

@@ -0,0 +1,378 @@
+import { Args, Flags } from '@oclif/core';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { execSync, spawn } from 'node:child_process';
+import inquirer from 'inquirer';
+import Database from 'better-sqlite3';
+import { colors } from '../../lib/colors.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { hasDevcontainerConfig } from '../../lib/execution/devcontainer.js';
+import { getTerminalApp } from '../../lib/execution/config.js';
+import { isDockerRunning } from '../../lib/execution/runners.js';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class Shell extends PMOCommand {
+    static description = 'Open an interactive shell in an agent workspace';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> altman',
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Agent name to open shell in',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(Shell);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Helper to handle errors in JSON mode
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('agent shell', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get workspace information
+        const workspaceInfo = getWorkspaceInfo();
+        if (workspaceInfo.agents.length === 0) {
+            if (jsonMode) {
+                outputErrorAsJson('NO_AGENTS', 'No agents found. Add agents with "prlt agent add"', createMetadata('agent shell', flags));
+                return;
+            }
+            this.log(colors.warning('No agents found. Add agents with "prlt agent add"'));
+            return;
+        }
+        let agentName = args.name;
+        // Interactive mode if no agent specified
+        if (!agentName) {
+            // Build choices once, use for both JSON and interactive modes
+            const agentChoices = workspaceInfo.agents.map((agent) => ({ name: agent.name, value: agent.name }));
+            const selectMessage = 'Select agent to open shell in:';
+            // In JSON mode, output agent selection prompt and exit
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'name', selectMessage, agentChoices), createMetadata('agent shell', flags));
+            }
+            const { selected } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'selected',
+                    message: selectMessage,
+                    choices: agentChoices
+                }
+            ]);
+            agentName = selected;
+        }
+        // Validate agent exists
+        const agent = workspaceInfo.agents.find(a => a.name === agentName);
+        if (!agent) {
+            return handleError('AGENT_NOT_FOUND', `Agent "${agentName}" not found. Available agents: ${workspaceInfo.agents.map(a => a.name).join(', ')}`);
+        }
+        const agentDir = path.join(workspaceInfo.agentsPath, agentName);
+        // Check if agent has devcontainer
+        const hasDevcontainer = hasDevcontainerConfig(agentDir);
+        // In JSON mode with agent name provided, output config choices prompt and exit
+        if (jsonMode) {
+            const configChoices = [
+                { name: 'terminal - safe - devcontainer', value: 'terminal-safe-devcontainer' },
+                { name: 'terminal - safe - host', value: 'terminal-safe-host' },
+                { name: 'terminal - danger - devcontainer', value: 'terminal-danger-devcontainer' },
+                { name: 'terminal - danger - host', value: 'terminal-danger-host' },
+                { name: 'foreground - safe - devcontainer', value: 'foreground-safe-devcontainer' },
+                { name: 'foreground - safe - host', value: 'foreground-safe-host' },
+                { name: 'foreground - danger - devcontainer', value: 'foreground-danger-devcontainer' },
+                { name: 'foreground - danger - host', value: 'foreground-danger-host' },
+            ];
+            outputPromptAsJson({
+                ...buildPromptConfig('list', 'config', 'Select shell configuration (displayMode-permissionMode-environment):', hasDevcontainer ? configChoices : configChoices.filter(c => c.value.endsWith('-host'))),
+                context: { agentName, hasDevcontainer },
+            }, createMetadata('agent shell', flags));
+        }
+        // Prompt for environment
+        let environment = 'host';
+        if (hasDevcontainer) {
+            const { selectedEnvironment } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'selectedEnvironment',
+                    message: 'Where should the shell run?',
+                    choices: [
+                        { name: '🐳 devcontainer (recommended)', value: 'devcontainer' },
+                        { name: '💻 host (agent worktree on your machine)', value: 'host' },
+                    ],
+                    default: 'devcontainer',
+                },
+            ]);
+            environment = selectedEnvironment;
+        }
+        // Prompt for display mode and permission mode
+        const { displayMode, permissionMode } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'displayMode',
+                message: 'How should the shell be opened?',
+                choices: [
+                    { name: 'terminal     - New terminal window', value: 'terminal' },
+                    { name: 'foreground   - Run in current terminal', value: 'foreground' },
+                ],
+                default: 'terminal',
+            },
+            {
+                type: 'list',
+                name: 'permissionMode',
+                message: 'Permission mode for Claude Code:',
+                choices: [
+                    { name: '🔒 safe   - Requires approval for dangerous operations', value: 'safe' },
+                    { name: '⚠️  danger - Skip permission checks', value: 'danger' },
+                ],
+                default: 'safe',
+            },
+        ]);
+        this.log('');
+        this.log(colors.primary(`🐚 Opening shell for agent: ${agentName}`));
+        this.log('');
+        const dangerMode = permissionMode === 'danger';
+        if (environment === 'devcontainer') {
+            await this.openDevcontainerShell(workspaceInfo.path, agentDir, agentName, displayMode, dangerMode);
+        }
+        else {
+            await this.openHostShell(workspaceInfo.path, agentDir, agentName, displayMode, dangerMode);
+        }
+    }
+    async openDevcontainerShell(hqPath, agentDir, agentName, displayMode, dangerMode) {
+        // Check Docker is running
+        if (!isDockerRunning()) {
+            this.error('Docker is not running. Please start Docker Desktop and try again.');
+        }
+        // Start or ensure container is running
+        try {
+            execSync(`devcontainer up --workspace-folder "${agentDir}"`, {
+                stdio: 'pipe',
+            });
+        }
+        catch (error) {
+            this.error(`Failed to start devcontainer: ${error instanceof Error ? error.message : error}`);
+        }
+        // Get container ID
+        let containerId = null;
+        try {
+            containerId = execSync(`docker ps -q --filter "label=devcontainer.local_folder=${agentDir}"`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        }
+        catch {
+            // Ignore
+        }
+        if (!containerId) {
+            this.error('Failed to find running container.');
+        }
+        this.log(colors.success(`✓ Container running: ${containerId}`));
+        this.log('');
+        // The command to run inside the container
+        const claudeArgs = dangerMode ? ['exec', '-it', '-w', '/workspace', containerId, 'claude', '--dangerously-skip-permissions'] : ['exec', '-it', '-w', '/workspace', containerId, 'claude'];
+        if (displayMode === 'foreground') {
+            // Run Claude directly in current terminal
+            this.log(colors.text('Starting Claude Code in devcontainer...'));
+            this.log('');
+            const child = spawn('docker', claudeArgs, {
+                stdio: 'inherit'
+            });
+            await new Promise((resolve, reject) => {
+                child.on('close', (code) => {
+                    if (code === 0) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error(`Claude exited with code ${code}`));
+                    }
+                });
+                child.on('error', reject);
+            });
+        }
+        else {
+            // Open in new terminal window using the same method as work start
+            const dbPath = path.join(hqPath, '.proletariat', 'workspace.db');
+            const db = new Database(dbPath);
+            try {
+                const terminalApp = await getTerminalApp(db);
+                // Create script file (same pattern as runDevcontainerInTerminal)
+                const baseDir = path.join(hqPath, '.proletariat', 'scripts');
+                fs.mkdirSync(baseDir, { recursive: true });
+                const scriptPath = path.join(baseDir, `shell-${agentName}-${Date.now()}.sh`);
+                // Launch claude inside the container
+                const claudeCmd = dangerMode
+                    ? `docker exec -it -w /workspace ${containerId} claude --dangerously-skip-permissions`
+                    : `docker exec -it -w /workspace ${containerId} claude`;
+                const scriptContent = `#!/bin/bash
+# Shell for agent ${agentName}
+
+echo "======================================"
+echo "Agent Shell: ${agentName} (devcontainer)"
+echo "======================================"
+echo ""
+
+# Run Claude Code
+${claudeCmd}
+
+# Clean up script file
+rm -f "${scriptPath}"
+
+# Keep shell open after Claude exits
+exec bash
+`;
+                fs.writeFileSync(scriptPath, scriptContent, { mode: 0o755 });
+                await this.runInTerminal(terminalApp, scriptPath);
+                this.log(colors.success('✓ Opened new terminal window'));
+                this.log(colors.textSecondary('An interactive shell is now available in the devcontainer.'));
+            }
+            finally {
+                db.close();
+            }
+        }
+    }
+    async openHostShell(hqPath, agentDir, agentName, displayMode, dangerMode) {
+        if (displayMode === 'foreground') {
+            this.log(colors.text(`Starting Claude Code in ${agentDir}...`));
+            this.log('');
+            const claudeArgs = dangerMode ? ['--dangerously-skip-permissions'] : [];
+            const child = spawn('claude', claudeArgs, {
+                stdio: 'inherit',
+                cwd: agentDir,
+            });
+            await new Promise((resolve, reject) => {
+                child.on('close', (code) => {
+                    if (code === 0) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error(`Claude exited with code ${code}`));
+                    }
+                });
+                child.on('error', reject);
+            });
+        }
+        else {
+            // Open in new terminal window
+            const dbPath = path.join(hqPath, '.proletariat', 'workspace.db');
+            const db = new Database(dbPath);
+            try {
+                const terminalApp = await getTerminalApp(db);
+                // Create script file
+                const baseDir = path.join(hqPath, '.proletariat', 'scripts');
+                fs.mkdirSync(baseDir, { recursive: true });
+                const scriptPath = path.join(baseDir, `shell-${agentName}-${Date.now()}.sh`);
+                const claudeCmd = dangerMode ? 'claude --dangerously-skip-permissions' : 'claude';
+                const scriptContent = `#!/bin/bash
+# Shell for agent ${agentName}
+
+echo "======================================"
+echo "Agent Shell: ${agentName} (host)"
+echo "======================================"
+echo ""
+
+cd "${agentDir}"
+
+# Run Claude Code
+${claudeCmd}
+
+# Clean up script file
+rm -f "${scriptPath}"
+
+# Keep shell open after Claude exits
+exec bash
+`;
+                fs.writeFileSync(scriptPath, scriptContent, { mode: 0o755 });
+                await this.runInTerminal(terminalApp, scriptPath);
+                this.log(colors.success('✓ Opened new terminal window'));
+                this.log(colors.textSecondary(`Directory: ${agentDir}`));
+            }
+            finally {
+                db.close();
+            }
+        }
+    }
+    /**
+     * Run a script in a new terminal window using the same method as work start.
+     * Uses osascript with proper iTerm/Terminal handling.
+     */
+    async runInTerminal(terminalApp, scriptPath) {
+        switch (terminalApp) {
+            case 'iTerm':
+                // Same pattern as runDevcontainerInTerminal in runners.ts
+                execSync(`osascript -e '
+          tell application "iTerm"
+            activate
+            tell current window
+              set newTab to (create tab with default profile)
+              tell current session of newTab
+                write text "${scriptPath}"
+              end tell
+            end tell
+          end tell
+        '`);
+                break;
+            case 'Ghostty':
+                execSync(`osascript -e '
+          tell application "Ghostty"
+            activate
+          end tell
+          tell application "System Events"
+            tell process "Ghostty"
+              keystroke "t" using command down
+              delay 0.3
+              keystroke "source ${scriptPath}"
+              keystroke return
+            end tell
+          end tell
+        '`);
+                break;
+            case 'WezTerm':
+                execSync(`wezterm cli spawn --new-window -- bash -c 'source ${scriptPath}'`);
+                break;
+            case 'Kitty':
+                execSync(`kitty @ launch --type=tab -- bash -c 'source ${scriptPath}'`);
+                break;
+            case 'Alacritty':
+                execSync(`osascript -e '
+          tell application "Alacritty"
+            activate
+          end tell
+          tell application "System Events"
+            tell process "Alacritty"
+              keystroke "n" using command down
+              delay 0.3
+              keystroke "source ${scriptPath}"
+              keystroke return
+            end tell
+          end tell
+        '`);
+                break;
+            case 'Terminal':
+            default:
+                // Same pattern as runDevcontainerInTerminal in runners.ts
+                execSync(`osascript -e '
+          tell application "Terminal"
+            activate
+            tell application "System Events"
+              tell process "Terminal"
+                keystroke "t" using command down
+              end tell
+            end tell
+            delay 0.3
+            do script "source ${scriptPath}" in front window
+          end tell
+        '`);
+                break;
+        }
+    }
+}

package/dist/commands/agent/staff/add.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class Add extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        names: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        'no-container': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        theme: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static strict: boolean;
+    run(): Promise<void>;
+}

package/dist/commands/agent/staff/add.js

@@ -0,0 +1,281 @@
+import { Command, Args, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { getWorkspaceInfo, validateAgentNames, addAgentsToWorkspace } from '../../../lib/agents/commands.js';
+import { ensureBuiltinThemes, BUILTIN_THEMES, isValidAgentName, normalizeAgentName } from '../../../lib/themes.js';
+import { getTheme, getThemes, getAvailableThemeNames, markThemeNameUsed, getActiveTheme } from '../../../lib/database/index.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../../lib/prompt-json.js';
+export default class Add extends Command {
+    static description = 'Add new agents to the workspace';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> zeus',
+        '<%= config.bin %> <%= command.id %> agent-1 agent-2',
+        '<%= config.bin %> <%= command.id %> --theme billionaires',
+        '<%= config.bin %> <%= command.id %> my-agent --no-container',
+    ];
+    static args = {
+        names: Args.string({
+            description: 'Agent names to add (space-separated)',
+            required: false,
+        }),
+    };
+    static flags = {
+        'no-container': Flags.boolean({
+            description: 'Skip devcontainer setup (not recommended for autonomous agents)',
+            default: false,
+        }),
+        theme: Flags.string({
+            char: 't',
+            description: 'Pick agent name(s) from a theme (billionaires, toyotas, companies, or custom)',
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    static strict = false; // Allow multiple agent names
+    async run() {
+        const { argv, flags } = await this.parse(Add);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        try {
+            // Get workspace information
+            const workspaceInfo = getWorkspaceInfo();
+            let agentNames = argv;
+            let themeId;
+            // Theme mode: pick from a specific theme
+            if (flags.theme) {
+                // Ensure built-in themes are seeded
+                ensureBuiltinThemes(workspaceInfo.path);
+                // Validate theme exists
+                const theme = getTheme(workspaceInfo.path, flags.theme);
+                if (!theme) {
+                    const available = BUILTIN_THEMES.map(t => t.name).join(', ');
+                    if (jsonMode) {
+                        outputErrorAsJson('THEME_NOT_FOUND', `Theme "${flags.theme}" not found. Available: ${available}`, createMetadata('agent add', flags));
+                        return;
+                    }
+                    this.error(`Theme "${flags.theme}" not found. Available: ${available}`);
+                }
+                themeId = theme.id;
+                // Get available names from theme
+                const availableNames = getAvailableThemeNames(workspaceInfo.path, themeId);
+                if (availableNames.length === 0) {
+                    if (jsonMode) {
+                        outputErrorAsJson('NO_AVAILABLE_NAMES', `No available names in theme "${theme.display_name}". All names are in use.`, createMetadata('agent add', flags));
+                        return;
+                    }
+                    this.error(`No available names in theme "${theme.display_name}". All names are in use.`);
+                }
+                // Build choices once, use for both JSON and interactive modes
+                const nameChoices = availableNames.map(name => ({ name, value: name }));
+                const selectMessage = `Select agent names from ${theme.display_name}:`;
+                // In JSON mode, output theme names selection prompt
+                if (jsonMode) {
+                    outputPromptAsJson(buildPromptConfig('checkbox', 'names', selectMessage, nameChoices), createMetadata('agent add', flags));
+                    return;
+                }
+                // Interactive selection from theme
+                const { selected } = await inquirer.prompt([{
+                        type: 'checkbox',
+                        name: 'selected',
+                        message: selectMessage,
+                        choices: nameChoices,
+                        validate: (input) => input.length > 0 || 'Please select at least one name'
+                    }]);
+                agentNames = selected;
+                // Mark selected names as used
+                for (const name of agentNames) {
+                    markThemeNameUsed(workspaceInfo.path, themeId, name);
+                }
+            }
+            // Interactive mode: show names from workspace's active theme
+            else if (agentNames.length === 0) {
+                // Ensure built-in themes are seeded
+                ensureBuiltinThemes(workspaceInfo.path);
+                // Check if workspace has an active theme
+                const activeTheme = getActiveTheme(workspaceInfo.path);
+                if (activeTheme) {
+                    // Workspace has a theme - show names from it directly
+                    themeId = activeTheme.id;
+                    const availableNames = getAvailableThemeNames(workspaceInfo.path, activeTheme.id);
+                    if (availableNames.length === 0) {
+                        if (jsonMode) {
+                            outputErrorAsJson('NO_AVAILABLE_NAMES', `No available names in ${activeTheme.display_name}. All names are in use.`, createMetadata('agent add', flags));
+                            return;
+                        }
+                        this.log(chalk.yellow(`No available names in ${activeTheme.display_name}. All names are in use.`));
+                        this.log(chalk.blue('Use --theme to pick from a different theme, or enter names directly.'));
+                        return;
+                    }
+                    // Build choices once, use for both JSON and interactive modes
+                    const nameChoices = [
+                        ...availableNames.map(name => ({ name, value: name })),
+                        { name: 'Enter custom name(s)...', value: '__custom__' },
+                    ];
+                    const selectMessage = `Select agents from ${activeTheme.display_name}:`;
+                    // In JSON mode, output agent names selection prompt
+                    if (jsonMode) {
+                        outputPromptAsJson(buildPromptConfig('checkbox', 'names', selectMessage, nameChoices), createMetadata('agent add', flags));
+                        return;
+                    }
+                    // Add separator before custom option for interactive mode
+                    const choices = [
+                        ...nameChoices.slice(0, -1),
+                        new inquirer.Separator(),
+                        { name: chalk.blue(nameChoices[nameChoices.length - 1].name), value: nameChoices[nameChoices.length - 1].value }
+                    ];
+                    const { selected } = await inquirer.prompt([{
+                            type: 'checkbox',
+                            name: 'selected',
+                            message: selectMessage,
+                            choices,
+                            pageSize: 20,
+                            validate: (input) => input.length > 0 || 'Please select at least one name'
+                        }]);
+                    // Check if custom was selected
+                    const hasCustom = selected.includes('__custom__');
+                    const themedSelections = selected.filter((s) => s !== '__custom__');
+                    if (hasCustom) {
+                        const { customNames } = await inquirer.prompt([{
+                                type: 'input',
+                                name: 'customNames',
+                                message: 'Enter custom agent names (space-separated):',
+                                validate: (input) => {
+                                    if (!input.trim())
+                                        return 'Please enter at least one name';
+                                    return true;
+                                }
+                            }]);
+                        const rawNames = customNames.trim().split(/\s+/);
+                        const normalizedCustom = rawNames.map((n) => normalizeAgentName(n)).filter((n) => n && isValidAgentName(n));
+                        agentNames.push(...normalizedCustom);
+                    }
+                    if (themedSelections.length > 0) {
+                        agentNames.push(...themedSelections);
+                        // Mark themed names as used
+                        for (const name of themedSelections) {
+                            markThemeNameUsed(workspaceInfo.path, activeTheme.id, name);
+                        }
+                    }
+                }
+                else {
+                    // No active theme - prompt to pick one or enter custom names
+                    const themes = getThemes(workspaceInfo.path);
+                    const themesWithNames = themes.map(t => ({
+                        theme: t,
+                        availableCount: getAvailableThemeNames(workspaceInfo.path, t.id).length
+                    })).filter(t => t.availableCount > 0);
+                    // Build choices once, use for both JSON and interactive modes
+                    const themeChoices = [
+                        ...themesWithNames.map(({ theme, availableCount }) => ({
+                            name: `${theme.display_name} (${availableCount} available)`,
+                            value: theme.id
+                        })),
+                        { name: 'Enter custom name(s)', value: '__custom__' },
+                    ];
+                    const selectMessage = 'No theme set. Select a theme or enter custom names:';
+                    // In JSON mode, output theme selection prompt
+                    if (jsonMode) {
+                        outputPromptAsJson(buildPromptConfig('list', 'theme', selectMessage, themeChoices), createMetadata('agent add', flags));
+                        return;
+                    }
+                    // Add separator and styling for interactive mode
+                    const interactiveChoices = [
+                        ...themeChoices.slice(0, -1).map(c => ({
+                            name: c.name.replace(/\((\d+) available\)/, chalk.dim(`($1 available)`)),
+                            value: c.value
+                        })),
+                        new inquirer.Separator(),
+                        { name: chalk.blue(themeChoices[themeChoices.length - 1].name), value: themeChoices[themeChoices.length - 1].value }
+                    ];
+                    const { selectedTheme } = await inquirer.prompt([{
+                            type: 'list',
+                            name: 'selectedTheme',
+                            message: selectMessage,
+                            choices: interactiveChoices
+                        }]);
+                    if (selectedTheme === '__custom__') {
+                        const { customNames } = await inquirer.prompt([{
+                                type: 'input',
+                                name: 'customNames',
+                                message: 'Enter custom agent names (space-separated):',
+                                validate: (input) => {
+                                    if (!input.trim())
+                                        return 'Please enter at least one name';
+                                    return true;
+                                }
+                            }]);
+                        const rawNames = customNames.trim().split(/\s+/);
+                        const normalizedCustom = rawNames.map((n) => ({
+                            original: n,
+                            normalized: normalizeAgentName(n)
+                        })).filter((x) => x.normalized && isValidAgentName(x.normalized));
+                        const changed = normalizedCustom.filter((x) => x.original !== x.normalized);
+                        if (changed.length > 0) {
+                            this.log(chalk.blue('Normalized names:'));
+                            for (const { original, normalized } of changed) {
+                                this.log(chalk.dim(`   ${original} → ${normalized}`));
+                            }
+                        }
+                        agentNames = normalizedCustom.map((x) => x.normalized);
+                    }
+                    else {
+                        themeId = selectedTheme;
+                        const theme = getTheme(workspaceInfo.path, selectedTheme);
+                        const availableNames = getAvailableThemeNames(workspaceInfo.path, selectedTheme);
+                        const { selected } = await inquirer.prompt([{
+                                type: 'checkbox',
+                                name: 'selected',
+                                message: `Select agents from ${theme?.display_name}:`,
+                                choices: availableNames.map(name => ({ name, value: name })),
+                                pageSize: 20,
+                                validate: (input) => input.length > 0 || 'Please select at least one name'
+                            }]);
+                        agentNames = selected;
+                        for (const name of agentNames) {
+                            markThemeNameUsed(workspaceInfo.path, selectedTheme, name);
+                        }
+                    }
+                }
+                if (agentNames.length === 0) {
+                    this.log(chalk.yellow('No agents specified.'));
+                    return;
+                }
+            }
+            // Validate agent names (skip for theme mode - already validated)
+            if (!flags.theme) {
+                const { valid, invalid } = validateAgentNames(agentNames);
+                if (invalid.length > 0) {
+                    this.log(chalk.red(`Invalid agent names: ${invalid.join(', ')}`));
+                    this.log(chalk.yellow('Agent names must be lowercase alphanumeric with optional hyphens/underscores.'));
+                    if (valid.length === 0) {
+                        return;
+                    }
+                    this.log(chalk.blue(`Proceeding with valid agents: ${valid.join(', ')}`));
+                }
+                agentNames = valid;
+            }
+            // Add agents to workspace
+            const addedAgents = await addAgentsToWorkspace(workspaceInfo, agentNames, {
+                skipDevcontainer: flags['no-container'],
+                themeId,
+            });
+            if (addedAgents.length === 0) {
+                this.log(chalk.yellow('No new agents to add. All specified agents already exist.'));
+                return;
+            }
+            this.log(chalk.green(`\n Successfully added ${addedAgents.length} agent(s): ${addedAgents.join(', ')}`));
+            if (themeId) {
+                const theme = getTheme(workspaceInfo.path, themeId);
+                this.log(chalk.blue(`   From theme: ${theme?.display_name || themeId}`));
+            }
+            if (!flags['no-container']) {
+                this.log(chalk.blue('   Devcontainer config created for sandboxed execution'));
+            }
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+}