@proletariat/cli 0.1.4 → 0.3.0

package/dist/commands/agent/list.js

@@ -0,0 +1,126 @@
+import { Command } from '@oclif/core';
+import chalk from 'chalk';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { getWorkspaceInfo, getAllAgentsStatus, getAgentTmuxSessions } from '../../lib/agents/commands.js';
+export default class List extends Command {
+    static description = 'List all agents and their current status';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {};
+    async run() {
+        try {
+            // Get workspace information
+            const workspaceInfo = getWorkspaceInfo();
+            // Filter to active agents only
+            const activeAgents = workspaceInfo.agents.filter(a => a.status === 'active');
+            if (activeAgents.length === 0) {
+                this.log(chalk.yellow('No active agents found.'));
+                this.log(chalk.dim('Use "prlt agent staff add" or "prlt work spawn" to create agents.'));
+                return;
+            }
+            // Get status for all active agents
+            const agentsStatus = getAllAgentsStatus(workspaceInfo);
+            // Separate by type
+            const staffAgents = activeAgents.filter(a => a.type === 'persistent');
+            const tempAgents = activeAgents.filter(a => a.type === 'ephemeral');
+            // Staff agents section
+            if (staffAgents.length > 0) {
+                this.log(chalk.bold.cyan('\n Staff Agents:\n'));
+                const staffStatus = agentsStatus.filter(a => staffAgents.some(s => s.name === a.name));
+                for (const agentStatus of staffStatus) {
+                    const statusIcon = agentStatus.exists ? '🟢' : '🔴';
+                    const status = agentStatus.exists ? chalk.green('Active') : chalk.red('Missing');
+                    this.log(`${statusIcon} ${chalk.bold(agentStatus.name)} ${chalk.dim('[staff]')} - ${status}`);
+                    if (agentStatus.exists) {
+                        if (agentStatus.branch) {
+                            this.log(chalk.cyan(`   Branch: ${agentStatus.branch}`));
+                        }
+                        if (agentStatus.repositories.length > 0) {
+                            const dirtyRepos = agentStatus.repositories.filter(r => r.status === 'dirty').length;
+                            const reposWithCommits = agentStatus.repositories.filter(r => r.commitsAhead > 0);
+                            let repoStatusText = `${agentStatus.repositories.length} repo(s)`;
+                            if (dirtyRepos > 0) {
+                                repoStatusText += `, ${dirtyRepos} dirty`;
+                            }
+                            if (reposWithCommits.length > 0) {
+                                const commitDetails = reposWithCommits.map(r => `${r.name}(+${r.commitsAhead})`).join(', ');
+                                repoStatusText += `, commits ahead: ${commitDetails}`;
+                            }
+                            this.log(chalk.white(`   Repositories: ${repoStatusText}`));
+                        }
+                        if (agentStatus.assignedTickets.length > 0) {
+                            this.log(chalk.blue(`   Current tickets: ${agentStatus.assignedTickets.join(', ')}`));
+                        }
+                        else {
+                            this.log(chalk.white('   No active tickets'));
+                        }
+                        if (agentStatus.completedTickets.length > 0) {
+                            this.log(chalk.white(`   Completed: ${agentStatus.completedTickets.length} ticket(s)`));
+                        }
+                    }
+                    else {
+                        const agentDir = path.join(workspaceInfo.agentsPath, agentStatus.name);
+                        const dirExists = fs.existsSync(agentDir);
+                        if (dirExists) {
+                            this.log(chalk.red(`   Invalid or broken worktrees`));
+                        }
+                        else {
+                            this.log(chalk.red(`   Agent directory not found`));
+                        }
+                        this.log(chalk.white('   Run "prlt agent staff add" to recreate'));
+                    }
+                    this.log('');
+                }
+            }
+            // Temp agents section
+            if (tempAgents.length > 0) {
+                this.log(chalk.bold.yellow('\n Temporary Agents:\n'));
+                const tempStatus = agentsStatus.filter(a => tempAgents.some(s => s.name === a.name));
+                for (const agentStatus of tempStatus) {
+                    const sessions = getAgentTmuxSessions(agentStatus.name);
+                    const hasRunningWork = sessions.length > 0;
+                    const statusIcon = hasRunningWork ? '🟡' : (agentStatus.exists ? '🟢' : '🔴');
+                    const runningLabel = hasRunningWork ? chalk.yellow(' (running)') : '';
+                    const status = agentStatus.exists ? chalk.green('Active') : chalk.red('Missing');
+                    this.log(`${statusIcon} ${chalk.bold(agentStatus.name)} ${chalk.dim('[temp]')} - ${status}${runningLabel}`);
+                    if (agentStatus.exists) {
+                        if (agentStatus.branch) {
+                            this.log(chalk.cyan(`   Branch: ${agentStatus.branch}`));
+                        }
+                        if (agentStatus.assignedTickets.length > 0) {
+                            this.log(chalk.blue(`   Current tickets: ${agentStatus.assignedTickets.join(', ')}`));
+                        }
+                    }
+                    else {
+                        this.log(chalk.red(`   Agent directory not found`));
+                    }
+                    this.log('');
+                }
+            }
+            // Summary
+            const activeStaffCount = agentsStatus.filter(a => staffAgents.some(s => s.name === a.name) && a.exists).length;
+            const activeTempCount = agentsStatus.filter(a => tempAgents.some(s => s.name === a.name) && a.exists).length;
+            const runningTempCount = tempAgents.filter(a => {
+                const sessions = getAgentTmuxSessions(a.name);
+                return sessions.length > 0;
+            }).length;
+            const totalAssignedTickets = agentsStatus.reduce((sum, a) => sum + a.assignedTickets.length, 0);
+            this.log(chalk.bold(`Summary:`));
+            this.log(`   Staff agents: ${staffAgents.length} (${activeStaffCount} active)`);
+            this.log(`   Temp agents: ${tempAgents.length} (${activeTempCount} active${runningTempCount > 0 ? `, ${runningTempCount} running` : ''})`);
+            if (workspaceInfo.hasPMO) {
+                this.log(`   Tickets assigned: ${totalAssignedTickets}`);
+            }
+            // Show cleaned agents count if any
+            const cleanedAgents = workspaceInfo.agents.filter(a => a.status === 'cleaned');
+            if (cleanedAgents.length > 0) {
+                this.log(chalk.dim(`   Cleaned (historical): ${cleanedAgents.length}`));
+            }
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+}

package/dist/commands/agent/login.d.ts

@@ -0,0 +1,16 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class Login extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/agent/login.js

@@ -0,0 +1,146 @@
+import { Args, Flags } from '@oclif/core';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { execSync } from 'node:child_process';
+import inquirer from 'inquirer';
+import { colors } from '../../lib/colors.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { isDockerRunning } from '../../lib/execution/runners.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class Login extends PMOCommand {
+    static description = 'Authenticate Claude Code inside an agent container (one-time setup)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> damodei',
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Agent name to authenticate',
+            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(Login);
+        // 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 login', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Check Docker is running
+        if (!isDockerRunning()) {
+            return handleError('DOCKER_NOT_RUNNING', 'Docker is not running. Please start Docker Desktop and try again.');
+        }
+        // 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 login', 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) {
+            // In JSON mode, output agent selection prompt
+            if (jsonMode) {
+                const agentChoices = workspaceInfo.agents.map((agent) => ({ name: agent.name, value: agent.name }));
+                outputPromptAsJson(buildPromptConfig('list', 'name', 'Select agent to authenticate:', agentChoices), createMetadata('agent login', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select agent to authenticate:',
+                    choices: workspaceInfo.agents.map(agent => ({
+                        name: agent.name,
+                        value: agent.name
+                    }))
+                }
+            ]);
+            agentName = selected;
+        }
+        // Validate agent exists
+        const agent = workspaceInfo.agents.find(a => a.name === agentName);
+        if (!agent) {
+            this.error(`Agent "${agentName}" not found. Available agents: ${workspaceInfo.agents.map(a => a.name).join(', ')}`);
+        }
+        const agentDir = path.join(workspaceInfo.agentsPath, agentName);
+        // Check if devcontainer exists
+        const devcontainerPath = path.join(agentDir, '.devcontainer');
+        try {
+            execSync(`test -d "${devcontainerPath}"`, { stdio: 'ignore' });
+        }
+        catch {
+            this.error(`Agent "${agentName}" does not have a devcontainer configuration. Run "prlt agent add ${agentName}" to initialize.`);
+        }
+        // Get container ID
+        this.log(colors.primary(`🔐 Authenticating agent: ${agentName}`));
+        this.log('');
+        let containerId;
+        try {
+            containerId = execSync(`docker ps --filter "label=devcontainer.local_folder=${agentDir}" --format "{{.ID}}"`, { encoding: 'utf-8' }).trim();
+        }
+        catch {
+            this.error('Failed to find running container. Make sure the agent container is running.');
+        }
+        if (!containerId) {
+            this.log(colors.warning('Container is not running. Starting it now...'));
+            this.log('');
+            try {
+                execSync(`devcontainer up --workspace-folder "${agentDir}"`, {
+                    stdio: 'inherit',
+                    cwd: agentDir
+                });
+                // Get container ID again
+                containerId = execSync(`docker ps --filter "label=devcontainer.local_folder=${agentDir}" --format "{{.ID}}"`, { encoding: 'utf-8' }).trim();
+            }
+            catch {
+                this.error('Failed to start container.');
+            }
+        }
+        // Create a helper script to launch interactive session
+        this.log(colors.success(`✓ Container running: ${containerId}`));
+        this.log('');
+        // Generate script that opens interactive Claude and prompts for /login
+        const scriptPath = `/tmp/prlt-agent-login-${containerId}.sh`;
+        const scriptContent = `#!/bin/bash
+echo "======================================"
+echo "Claude Code Authentication"
+echo "======================================"
+echo ""
+echo "Type: /login"
+echo "Then follow the browser prompts to authenticate with your Claude subscription."
+echo ""
+echo "Your credentials will be saved and persist across container rebuilds."
+echo ""
+docker exec -it ${containerId} claude
+`;
+        fs.writeFileSync(scriptPath, scriptContent, { mode: 0o755 });
+        this.log(colors.text('Opening interactive Claude session...'));
+        this.log('');
+        // Execute the script directly with a new shell
+        execSync(`open -a Terminal ${scriptPath}`, { stdio: 'inherit' });
+        this.log(colors.success('✓ Opened new terminal window'));
+        this.log(colors.textSecondary('Complete the /login flow in the new terminal window.'));
+        this.log(colors.textSecondary('Your credentials will be saved automatically.'));
+    }
+}

package/dist/commands/agent/rebuild.d.ts

@@ -0,0 +1,18 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class AgentRebuild extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'no-cache': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+    private getAvailableAgents;
+}

package/dist/commands/agent/rebuild.js

@@ -0,0 +1,133 @@
+import { Args, Flags } from '@oclif/core';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { colors } from '../../lib/colors.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { isDockerRunning } from '../../lib/execution/runners.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+const execAsync = promisify(exec);
+export default class AgentRebuild extends PMOCommand {
+    static description = 'Rebuild a specific agent devcontainer image';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> altman',
+        '<%= config.bin %> <%= command.id %> altman --no-cache',
+        '<%= config.bin %> <%= command.id %>  # Interactive selection',
+        '<%= config.bin %> <%= command.id %> --json  # JSON mode for AI agents',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Agent name to rebuild',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+        'no-cache': Flags.boolean({
+            description: 'Build without using cache',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(AgentRebuild);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Check Docker is running
+        if (!isDockerRunning()) {
+            if (jsonMode) {
+                outputErrorAsJson('DOCKER_NOT_RUNNING', 'Docker is not running. Please start Docker Desktop and try again.', createMetadata('agent rebuild', flags));
+                this.exit(1);
+            }
+            this.error('Docker is not running. Please start Docker Desktop and try again.');
+        }
+        let agentName = args.name;
+        // If no agent name provided, prompt for selection
+        if (!agentName) {
+            const agents = this.getAvailableAgents();
+            if (agents.length === 0) {
+                if (jsonMode) {
+                    outputErrorAsJson('NO_AGENTS', 'No agents found.', createMetadata('agent rebuild', flags));
+                    return;
+                }
+                this.log(colors.warning('No agents found.'));
+                return;
+            }
+            const selected = await this.selectFromList({
+                message: 'Select agent to rebuild:',
+                items: agents,
+                getName: (a) => a.name,
+                getValue: (a) => a.name,
+                getCommand: (a) => `prlt agent rebuild ${a.name} --json`,
+                jsonMode: jsonMode ? { flags, commandName: 'agent rebuild' } : null,
+            });
+            if (!selected) {
+                return;
+            }
+            agentName = selected;
+        }
+        // Get workspace info
+        const workspaceInfo = getWorkspaceInfo();
+        if (!workspaceInfo) {
+            this.error('Not in a proletariat workspace. Run `prlt init` first.');
+        }
+        this.log(colors.primary(`🔨 Rebuilding agent: ${agentName}\n`));
+        const agentsPath = path.join(workspaceInfo.path, 'agents', 'staff');
+        const agentDir = path.join(agentsPath, agentName);
+        try {
+            this.log(colors.textSecondary('  Building devcontainer...'));
+            const buildCommand = [
+                'devcontainer',
+                'build',
+                '--workspace-folder',
+                agentDir,
+            ];
+            if (flags['no-cache']) {
+                buildCommand.push('--no-cache');
+            }
+            const { stderr } = await execAsync(buildCommand.join(' '));
+            if (stderr && !stderr.includes('WARNING')) {
+                this.log(colors.textMuted(`  ${stderr.trim()}`));
+            }
+            this.log('');
+            this.log(colors.success(`✓ Agent ${agentName} rebuild complete`));
+            this.log(colors.textMuted('Use `prlt agent restart` to apply changes to running container'));
+        }
+        catch (error) {
+            this.error(`Failed to rebuild agent ${agentName}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    getAvailableAgents() {
+        const workspaceInfo = getWorkspaceInfo();
+        if (!workspaceInfo) {
+            return [];
+        }
+        const agents = [];
+        const agentsPath = path.join(workspaceInfo.path, 'agents');
+        // Check staff agents
+        const staffPath = path.join(agentsPath, 'staff');
+        if (fs.existsSync(staffPath)) {
+            const staffAgents = fs.readdirSync(staffPath, { withFileTypes: true })
+                .filter(d => d.isDirectory() && !d.name.startsWith('.'))
+                .map(d => ({ name: d.name, type: 'staff' }));
+            agents.push(...staffAgents);
+        }
+        // Check temp agents
+        const tempPath = path.join(agentsPath, 'temp');
+        if (fs.existsSync(tempPath)) {
+            const tempAgents = fs.readdirSync(tempPath, { withFileTypes: true })
+                .filter(d => d.isDirectory() && !d.name.startsWith('.'))
+                .map(d => ({ name: d.name, type: 'temp' }));
+            agents.push(...tempAgents);
+        }
+        return agents;
+    }
+}

package/dist/commands/agent/restart.d.ts

@@ -0,0 +1,17 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class AgentRestart extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+    private getAvailableAgents;
+}

package/dist/commands/agent/restart.js

@@ -0,0 +1,116 @@
+import { Args, Flags } from '@oclif/core';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { colors } from '../../lib/colors.js';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { isDockerRunning } from '../../lib/execution/runners.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+const execAsync = promisify(exec);
+export default class AgentRestart extends PMOCommand {
+    static description = 'Restart a specific agent devcontainer';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> altman',
+        '<%= config.bin %> <%= command.id %>  # Interactive selection',
+        '<%= config.bin %> <%= command.id %> --json  # JSON mode for AI agents',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Agent name to restart',
+            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(AgentRestart);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Check Docker is running
+        if (!isDockerRunning()) {
+            if (jsonMode) {
+                outputErrorAsJson('DOCKER_NOT_RUNNING', 'Docker is not running. Please start Docker Desktop and try again.', createMetadata('agent restart', flags));
+                this.exit(1);
+            }
+            this.error('Docker is not running. Please start Docker Desktop and try again.');
+        }
+        let agentName = args.name;
+        // If no agent name provided, prompt for selection
+        if (!agentName) {
+            const agents = this.getAvailableAgents();
+            if (agents.length === 0) {
+                if (jsonMode) {
+                    outputErrorAsJson('NO_AGENTS', 'No agents found.', createMetadata('agent restart', flags));
+                    return;
+                }
+                this.log(colors.warning('No agents found.'));
+                return;
+            }
+            const selected = await this.selectFromList({
+                message: 'Select agent to restart:',
+                items: agents,
+                getName: (a) => a.name,
+                getValue: (a) => a.name,
+                getCommand: (a) => `prlt agent restart ${a.name} --json`,
+                jsonMode: jsonMode ? { flags, commandName: 'agent restart' } : null,
+            });
+            if (!selected) {
+                return;
+            }
+            agentName = selected;
+        }
+        this.log(colors.primary(`🔄 Restarting agent: ${agentName}\n`));
+        // Find container by agent name
+        const { stdout: containers } = await execAsync(`docker ps -a --format "{{.Names}}" | grep -i "${agentName}" || true`);
+        const containerNames = containers.trim().split('\n').filter(Boolean);
+        if (containerNames.length === 0) {
+            this.log(colors.warning(`No container found for agent: ${agentName}`));
+            this.log(colors.textMuted('The container will be created on next `prlt work start`'));
+            return;
+        }
+        for (const containerName of containerNames) {
+            this.log(colors.textSecondary(`  Stopping container: ${containerName}...`));
+            await execAsync(`docker stop ${containerName}`);
+            this.log(colors.textSecondary(`  Removing container: ${containerName}...`));
+            await execAsync(`docker rm ${containerName}`);
+        }
+        this.log('');
+        this.log(colors.success(`✓ Agent ${agentName} container restarted`));
+        this.log(colors.textMuted('Container will rebuild with updated configuration on next `prlt work start`'));
+    }
+    getAvailableAgents() {
+        const workspaceInfo = getWorkspaceInfo();
+        if (!workspaceInfo) {
+            return [];
+        }
+        const agents = [];
+        const agentsPath = path.join(workspaceInfo.path, 'agents');
+        // Check staff agents
+        const staffPath = path.join(agentsPath, 'staff');
+        if (fs.existsSync(staffPath)) {
+            const staffAgents = fs.readdirSync(staffPath, { withFileTypes: true })
+                .filter(d => d.isDirectory() && !d.name.startsWith('.'))
+                .map(d => ({ name: d.name, type: 'staff' }));
+            agents.push(...staffAgents);
+        }
+        // Check temp agents
+        const tempPath = path.join(agentsPath, 'temp');
+        if (fs.existsSync(tempPath)) {
+            const tempAgents = fs.readdirSync(tempPath, { withFileTypes: true })
+                .filter(d => d.isDirectory() && !d.name.startsWith('.'))
+                .map(d => ({ name: d.name, type: 'temp' }));
+            agents.push(...tempAgents);
+        }
+        return agents;
+    }
+}

package/dist/commands/agent/shell.d.ts

@@ -0,0 +1,23 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class Shell extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+    private openDevcontainerShell;
+    private openHostShell;
+    /**
+     * Run a script in a new terminal window using the same method as work start.
+     * Uses osascript with proper iTerm/Terminal handling.
+     */
+    private runInTerminal;
+}