@proletariat/cli 0.2.0 → 0.3.0

package/dist/commands/work/watch.d.ts

@@ -0,0 +1,31 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class WorkWatch extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        column: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        strategy: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        agent: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        interval: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        once: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        mode: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'skip-permissions': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'create-pr': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    private isRunning;
+    private knownTickets;
+    private columnName;
+    private projectId;
+    private environment;
+    private displayMode;
+    private executionConfig;
+    private skipPermissions;
+    private createPR;
+    protected pmoLogger(): void;
+    execute(): Promise<void>;
+    private pollForNewTickets;
+    private printSummary;
+}

package/dist/commands/work/watch.js

@@ -0,0 +1,359 @@
+import { Flags } from '@oclif/core';
+import * as path from 'node:path';
+import Database from 'better-sqlite3';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { ExecutionStorage } from '../../lib/execution/storage.js';
+import { hasDevcontainerConfig } from '../../lib/execution/devcontainer.js';
+import { spawnForColumn, getAvailableAgents, isDockerRunning, } from '../../lib/execution/spawner.js';
+import { promptExecutionSettings } from '../../lib/execution/config.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class WorkWatch extends PMOCommand {
+    static description = 'Watch a column and auto-spawn agents for new tickets';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --column Ready',
+        '<%= config.bin %> <%= command.id %> --column Ready --strategy round-robin',
+        '<%= config.bin %> <%= command.id %> --column Ready --interval 10',
+        '<%= config.bin %> <%= command.id %> --column Ready --once',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+        column: Flags.string({
+            char: 'c',
+            description: 'Column to watch for new tickets (prompts if not provided)',
+        }),
+        strategy: Flags.string({
+            char: 's',
+            description: 'Agent selection strategy',
+            options: ['round-robin', 'least-busy', 'random'],
+            default: 'round-robin',
+        }),
+        agent: Flags.string({
+            char: 'a',
+            description: 'Use specific agent for all tickets',
+        }),
+        limit: Flags.integer({
+            char: 'l',
+            description: 'Maximum concurrent executions',
+        }),
+        interval: Flags.integer({
+            char: 'i',
+            description: 'Polling interval in seconds',
+            default: 5,
+        }),
+        once: Flags.boolean({
+            description: 'Check once and exit (no continuous watching)',
+            default: false,
+        }),
+        mode: Flags.string({
+            char: 'm',
+            description: 'Display mode for agent output',
+            options: ['terminal', 'background'],
+        }),
+        'skip-permissions': Flags.boolean({
+            description: 'Skip permission prompts (danger mode)',
+            default: false,
+        }),
+        'create-pr': Flags.boolean({
+            description: 'Create PR when work is ready',
+            default: false,
+        }),
+    };
+    isRunning = true;
+    knownTickets = new Set();
+    columnName = '';
+    projectId = '';
+    environment = 'host';
+    displayMode = 'terminal';
+    executionConfig;
+    skipPermissions = false;
+    createPR = false;
+    pmoLogger() {
+        // Silent logging during watch
+    }
+    async execute() {
+        const { flags } = await this.parse(WorkWatch);
+        // 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('work watch', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get workspace info
+        let workspaceInfo;
+        try {
+            workspaceInfo = getWorkspaceInfo();
+        }
+        catch {
+            return handleError('NOT_IN_WORKSPACE', 'Not in a workspace. Run "prlt init" first.');
+        }
+        if (workspaceInfo.agents.length === 0) {
+            return handleError('NO_AGENTS', 'No agents found in workspace. Add agents first with "prlt agent add".');
+        }
+        // Get project
+        this.projectId = await this.requireProject();
+        // Open database for execution storage
+        const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+        const db = new Database(dbPath);
+        const executionStorage = new ExecutionStorage(db);
+        // Handle graceful shutdown
+        const cleanup = async () => {
+            this.isRunning = false;
+            this.log('');
+            this.log(styles.muted('Stopping watch...'));
+            db.close();
+            process.exit(0);
+        };
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+        try {
+            // Get board columns for selection
+            const board = await this.storage.getBoard(this.projectId);
+            const columns = board.columns.map(col => col.name);
+            if (columns.length === 0) {
+                db.close();
+                this.error('No columns found in board. Initialize board first.');
+            }
+            // Prompt for column if not provided
+            this.columnName = flags.column || '';
+            if (!this.columnName) {
+                // In JSON mode, output column selection prompt
+                if (jsonMode) {
+                    const columnChoices = columns.map(col => {
+                        const ticketCount = board.columns.find(c => c.name === col)?.tickets?.length || 0;
+                        return {
+                            name: `${col} (${ticketCount} tickets)`,
+                            value: col,
+                        };
+                    });
+                    outputPromptAsJson(buildPromptConfig('list', 'column', 'Select column to watch for new tickets:', columnChoices), createMetadata('work watch', flags));
+                    db.close();
+                    return;
+                }
+                const { selectedColumn } = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'selectedColumn',
+                        message: 'Select column to watch for new tickets:',
+                        choices: columns.map(col => {
+                            // Get ticket count for each column
+                            const ticketCount = board.columns.find(c => c.name === col)?.tickets?.length || 0;
+                            return {
+                                name: `${col} (${ticketCount} tickets)`,
+                                value: col,
+                            };
+                        }),
+                    },
+                ]);
+                this.columnName = selectedColumn;
+            }
+            // Check if any agent has devcontainer
+            const hasDevcontainer = workspaceInfo.agents.some(agent => {
+                const agentDir = path.join(workspaceInfo.agentsPath, agent.name);
+                return hasDevcontainerConfig(agentDir);
+            });
+            // Docker check
+            const dockerRunning = isDockerRunning();
+            if (hasDevcontainer && !dockerRunning) {
+                this.warn('Docker is not running. Agents will run on host instead of devcontainer.\n' +
+                    'Start Docker Desktop for sandboxed execution.');
+            }
+            // Prompt for environment and display mode if not provided
+            this.environment = 'host';
+            this.displayMode = 'terminal';
+            if (!flags.mode) {
+                if (hasDevcontainer && dockerRunning) {
+                    // Prompt for environment choice
+                    const { selectedEnvironment } = await inquirer.prompt([
+                        {
+                            type: 'list',
+                            name: 'selectedEnvironment',
+                            message: 'Where should agents run?',
+                            choices: [
+                                { name: '🐳 devcontainer (sandboxed, recommended)', value: 'devcontainer' },
+                                { name: '💻 host (runs directly on your machine)', value: 'host' },
+                            ],
+                            default: 'devcontainer',
+                        },
+                    ]);
+                    this.environment = selectedEnvironment;
+                }
+                // Prompt for display mode
+                const { selectedDisplay } = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'selectedDisplay',
+                        message: 'How should agent output be displayed?',
+                        choices: [
+                            { name: '🖥️  New tab      - Opens in new terminal tab (recommended)', value: 'terminal' },
+                            { name: '📦 Background  - Runs detached, reattach with: prlt session attach', value: 'background' },
+                        ],
+                        default: 'terminal',
+                    },
+                ]);
+                this.displayMode = selectedDisplay;
+            }
+            else {
+                this.displayMode = flags.mode;
+                this.environment = hasDevcontainer && dockerRunning ? 'devcontainer' : 'host';
+            }
+            // Prompt for execution settings (terminal, output mode, permissions, PR creation)
+            const promptResult = await promptExecutionSettings(db, {
+                displayMode: this.displayMode,
+                environment: this.environment,
+                skipPermissions: flags['skip-permissions'] ? true : undefined,
+                createPR: flags['create-pr'] ? true : undefined,
+                log: (msg) => this.log(styles.header(msg)),
+            });
+            this.executionConfig = promptResult.executionConfig;
+            this.skipPermissions = promptResult.skipPermissions;
+            this.createPR = promptResult.createPR;
+            this.log('');
+            this.log(styles.header(`👁️  Watching column "${this.columnName}" for new tickets`));
+            this.log('');
+            this.log(styles.muted(`   Strategy: ${flags.strategy}`));
+            this.log(styles.muted(`   Environment: ${this.environment}`));
+            this.log(styles.muted(`   Display: ${this.displayMode}`));
+            if (this.displayMode === 'terminal') {
+                this.log(styles.muted(`   Terminal: ${this.executionConfig.terminal.app}`));
+            }
+            this.log(styles.muted(`   Output: ${this.executionConfig.outputMode === 'interactive' ? 'streaming' : 'print'}`));
+            if (this.skipPermissions) {
+                this.log(styles.warning(`   Permissions: ⚠️  danger`));
+            }
+            else {
+                this.log(styles.success(`   Permissions: 🔒 safe`));
+            }
+            if (this.createPR) {
+                this.log(styles.muted(`   Create PR: yes`));
+            }
+            if (flags.agent) {
+                this.log(styles.muted(`   Agent: ${flags.agent}`));
+            }
+            if (flags.limit) {
+                this.log(styles.muted(`   Max concurrent: ${flags.limit}`));
+            }
+            this.log(styles.muted(`   Interval: ${flags.interval}s`));
+            this.log('');
+            // Initial scan - record current tickets as "known"
+            const initialTickets = await this.storage.listTickets(this.projectId, { column: this.columnName });
+            for (const ticket of initialTickets) {
+                this.knownTickets.add(ticket.id);
+            }
+            this.log(styles.muted(`   Found ${initialTickets.length} existing tickets in column`));
+            // If --once, just do a single spawn cycle
+            if (flags.once) {
+                this.log('');
+                const result = await spawnForColumn(this.projectId, this.columnName, this.storage, executionStorage, workspaceInfo, db, this.pmoPath, {
+                    strategy: flags.strategy,
+                    specificAgent: flags.agent,
+                    limit: flags.limit,
+                    skipPermissions: this.skipPermissions,
+                    createPR: this.createPR,
+                    environment: this.environment,
+                    displayMode: this.displayMode,
+                    executionConfig: this.executionConfig,
+                    log: (msg) => this.log(styles.muted(`   ${msg}`)),
+                });
+                this.printSummary(result);
+                db.close();
+                return;
+            }
+            // Continuous watching
+            this.log('');
+            this.log(styles.muted('Press Ctrl+C to stop watching'));
+            this.log('');
+            while (this.isRunning) {
+                await this.pollForNewTickets(flags, executionStorage, workspaceInfo, db);
+                // Wait for interval
+                await new Promise(resolve => setTimeout(resolve, flags.interval * 1000));
+            }
+            db.close();
+        }
+        catch (error) {
+            db.close();
+            throw error;
+        }
+    }
+    async pollForNewTickets(flags, executionStorage, workspaceInfo, db) {
+        // Get current tickets in column
+        const currentTickets = await this.storage.listTickets(this.projectId, { column: this.columnName });
+        // Find new tickets (in current but not in known)
+        const newTickets = currentTickets.filter(t => !this.knownTickets.has(t.id));
+        if (newTickets.length === 0) {
+            // Update status line
+            const availableAgents = getAvailableAgents(workspaceInfo, executionStorage);
+            const runningExecutions = executionStorage.listExecutions({ status: 'running' });
+            const timestamp = new Date().toLocaleTimeString();
+            // Clear line and show status
+            process.stdout.write(`\r${styles.muted(`[${timestamp}] Watching: ${currentTickets.length} tickets | ${availableAgents.length} agents available | ${runningExecutions.length} running   `)}`);
+            return;
+        }
+        // New tickets detected!
+        this.log('');
+        this.log(styles.success(`✨ New tickets detected: ${newTickets.length}`));
+        // Add to known set before spawning
+        for (const ticket of newTickets) {
+            this.knownTickets.add(ticket.id);
+        }
+        // Spawn agents for new tickets
+        const result = await spawnForColumn(this.projectId, this.columnName, this.storage, executionStorage, workspaceInfo, db, this.pmoPath, {
+            strategy: flags.strategy,
+            specificAgent: flags.agent,
+            limit: flags.limit,
+            skipPermissions: this.skipPermissions,
+            createPR: this.createPR,
+            environment: this.environment,
+            displayMode: this.displayMode,
+            executionConfig: this.executionConfig,
+            log: (msg) => this.log(styles.muted(`   ${msg}`)),
+        });
+        // Print activity
+        const timestamp = new Date().toLocaleTimeString();
+        for (const spawn of result.spawned) {
+            this.log(styles.success(`   [${timestamp}] ${spawn.ticketId} → ${spawn.agentName} (spawned)`));
+        }
+        for (const skip of result.skipped) {
+            this.log(styles.warning(`   [${timestamp}] ${skip.ticketId}: ${skip.reason}`));
+        }
+        for (const fail of result.failed) {
+            this.log(styles.error(`   [${timestamp}] ${fail.ticketId}: ${fail.error}`));
+        }
+        this.log('');
+    }
+    printSummary(result) {
+        this.log('');
+        this.log(styles.header('Summary'));
+        this.log('');
+        if (result.spawned.length > 0) {
+            this.log(styles.success(`   ✓ Spawned: ${result.spawned.length}`));
+            for (const spawn of result.spawned) {
+                this.log(styles.muted(`     ${spawn.ticketId} → ${spawn.agentName}${spawn.executionId ? ` (${spawn.executionId})` : ''}`));
+            }
+        }
+        if (result.skipped.length > 0) {
+            this.log(styles.warning(`   ⏭ Skipped: ${result.skipped.length}`));
+            for (const skip of result.skipped) {
+                this.log(styles.muted(`     ${skip.ticketId}: ${skip.reason}`));
+            }
+        }
+        if (result.failed.length > 0) {
+            this.log(styles.error(`   ✗ Failed: ${result.failed.length}`));
+            for (const fail of result.failed) {
+                this.log(styles.muted(`     ${fail.ticketId}: ${fail.error}`));
+            }
+        }
+        this.log('');
+    }
+}

package/dist/commands/workflow/create.d.ts

@@ -0,0 +1,18 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class WorkflowCreate extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        statuses: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        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/workflow/create.js

@@ -0,0 +1,119 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildFormPromptConfig, } from '../../lib/prompt-json.js';
+export default class WorkflowCreate extends PMOCommand {
+    static description = 'Create a new custom workflow';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> "My Workflow"',
+        '<%= config.bin %> <%= command.id %> "Sprint Board" --description "Agile sprint workflow"',
+        '<%= config.bin %> <%= command.id %> "Simple" --statuses "Todo,In Progress,Done"',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Workflow name',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        description: Flags.string({
+            char: 'd',
+            description: 'Workflow description',
+        }),
+        statuses: Flags.string({
+            char: 's',
+            description: 'Comma-separated list of status names (uses default categories)',
+        }),
+        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(WorkflowCreate);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Get workflow name
+        let name = args.name;
+        if (!name) {
+            const fields = [
+                { type: 'input', name: 'name', message: 'Workflow name:' },
+                { type: 'input', name: 'description', message: 'Description (optional):', default: flags.description },
+            ];
+            if (jsonMode) {
+                outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('workflow create', flags));
+                return;
+            }
+            const answers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'name',
+                    message: 'Workflow name:',
+                    validate: (input) => input.length > 0 || 'Name is required',
+                },
+                {
+                    type: 'input',
+                    name: 'description',
+                    message: 'Description (optional):',
+                },
+            ]);
+            name = answers.name;
+            if (answers.description) {
+                flags.description = answers.description;
+            }
+        }
+        // Create the workflow
+        const workflow = await this.storage.createWorkflow({
+            name: name,
+            description: flags.description,
+        });
+        // If statuses were provided, add them
+        if (flags.statuses) {
+            const statusNames = flags.statuses.split(',').map(s => s.trim()).filter(s => s);
+            const defaultCategories = ['backlog', 'unstarted', 'started', 'started', 'completed'];
+            for (let i = 0; i < statusNames.length; i++) {
+                const statusName = statusNames[i];
+                // Assign categories based on position: first = backlog, second = unstarted, middle = started, last = completed
+                let category;
+                if (i === 0) {
+                    category = 'backlog';
+                }
+                else if (i === 1) {
+                    category = 'unstarted';
+                }
+                else if (i === statusNames.length - 1) {
+                    category = 'completed';
+                }
+                else {
+                    category = 'started';
+                }
+                await this.storage.createStatus(workflow.id, {
+                    name: statusName,
+                    category: category,
+                    position: i,
+                    isDefault: i === 1, // Second status (unstarted) is default
+                });
+            }
+        }
+        // Get the statuses for display
+        const statuses = await this.storage.listStatuses(workflow.id);
+        this.log(styles.success(`\nCreated workflow "${styles.emphasis(workflow.name)}"`));
+        this.log(styles.muted(`  ID: ${workflow.id}`));
+        if (workflow.description) {
+            this.log(styles.muted(`  Description: ${workflow.description}`));
+        }
+        if (statuses.length > 0) {
+            this.log(styles.muted(`  Statuses: ${statuses.map(s => s.name).join(', ')}`));
+        }
+        else {
+            this.log(styles.muted('  No statuses yet. Add some with: prlt status create'));
+        }
+        this.log('');
+        this.log(styles.muted(`View workflow: prlt workflow view ${workflow.id}`));
+    }
+}

package/dist/commands/workflow/delete.d.ts

@@ -0,0 +1,17 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class WorkflowDelete extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        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/workflow/delete.js

@@ -0,0 +1,119 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class WorkflowDelete extends PMOCommand {
+    static description = 'Delete a custom workflow';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-workflow',
+        '<%= config.bin %> <%= command.id %> my-workflow --force  # Skip confirmation',
+        '<%= config.bin %> <%= command.id %>  # Interactive selection',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Workflow ID to delete - prompts with dropdown if not provided',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation prompt',
+            default: false,
+        }),
+        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(WorkflowDelete);
+        // 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('workflow delete', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get workflow ID - prompt if not provided
+        let workflowId = args.id;
+        if (!workflowId) {
+            // Only show custom workflows (built-in cannot be deleted)
+            const workflows = await this.storage.listWorkflows({ isBuiltin: false });
+            if (workflows.length === 0) {
+                return handleError('NO_CUSTOM_WORKFLOWS', 'No custom workflows found to delete.');
+            }
+            // In JSON mode, output workflow selection prompt
+            if (jsonMode) {
+                const workflowChoices = workflows.map(w => ({
+                    name: w.name,
+                    value: w.id,
+                }));
+                outputPromptAsJson(buildPromptConfig('list', 'id', 'Select workflow to delete:', workflowChoices), createMetadata('workflow delete', flags));
+                return;
+            }
+            const { selectedId } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedId',
+                    message: 'Select workflow to delete:',
+                    choices: workflows.map(w => ({
+                        name: w.name,
+                        value: w.id,
+                    })),
+                }]);
+            workflowId = selectedId;
+        }
+        // Get workflow details
+        const workflow = await this.storage.getWorkflow(workflowId);
+        if (!workflow) {
+            return handleError('WORKFLOW_NOT_FOUND', `Workflow not found: ${workflowId}`);
+        }
+        // Cannot delete built-in workflows
+        if (workflow.isBuiltin) {
+            return handleError('CANNOT_DELETE_BUILTIN', `Cannot delete built-in workflow: ${workflow.name}`);
+        }
+        // Check if workflow is in use by any projects
+        const projects = await this.storage.listProjects();
+        const usingProjects = projects.filter(p => p.workflowId === workflowId);
+        if (usingProjects.length > 0) {
+            const projectNames = usingProjects.map(p => p.name).join(', ');
+            return handleError('WORKFLOW_IN_USE', `Cannot delete workflow "${workflow.name}" - it is used by ${usingProjects.length} project(s): ${projectNames}`);
+        }
+        // Confirm deletion unless --force
+        if (!flags.force) {
+            const statuses = await this.storage.listStatuses(workflowId);
+            // In JSON mode, output confirmation prompt
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('confirm', 'confirm', `Delete workflow "${workflow.name}" with ${statuses.length} statuses?`), createMetadata('workflow delete', flags));
+                return;
+            }
+            this.log(styles.warning(`\nWorkflow "${workflow.name}" has ${statuses.length} status(es).`));
+            this.log(styles.warning('This action cannot be undone.'));
+            this.log('');
+            const { confirm } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'confirm',
+                    message: `Delete workflow "${workflow.name}"?`,
+                    choices: [
+                        { name: 'Yes', value: true },
+                        { name: 'No', value: false },
+                    ],
+                }]);
+            if (!confirm) {
+                this.log(styles.muted('Cancelled'));
+                return;
+            }
+        }
+        // Delete the workflow
+        await this.storage.deleteWorkflow(workflowId);
+        this.log(styles.success(`\nDeleted workflow "${styles.emphasis(workflow.name)}"`));
+    }
+}