profclaw 0.0.1-beta.3 → 2.3.0

package/dist/cli/commands/onboard.js

@@ -11,11 +11,47 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import figlet from 'figlet';
-import { select, search, input, Separator } from '@inquirer/prompts';
+import { select, search, input, confirm, Separator } from '@inquirer/prompts';
 import { existsSync, writeFileSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { execSync } from 'node:child_process';
 import { success, error, info, warn, spinner } from '../utils/output.js';
+import { PROVIDER_CATALOG, PROVIDER_ENV_KEYS } from '../providers.js';
+/** Returns true if an env var name should have its value masked. */
+function isSensitiveKey(key) {
+    return key.includes('KEY') || key.includes('TOKEN') || key.includes('SECRET');
+}
+/** Mask an API key for display — shows first 8 chars and last 4, dots in between. */
+function maskApiKey(key) {
+    if (key.length <= 12)
+        return key.slice(0, 4) + '•'.repeat(key.length - 4);
+    return key.slice(0, 8) + '•'.repeat(8) + key.slice(-4);
+}
+/** Format a generated env file for display with sensitive values masked. */
+function formatEnvPreview(content) {
+    return content.split('\n')
+        .map(line => {
+        if (line.startsWith('#') || line.trim() === '')
+            return chalk.dim(`  ${line}`);
+        const eqIndex = line.indexOf('=');
+        if (eqIndex === -1)
+            return chalk.dim(`  ${line}`);
+        const key = line.slice(0, eqIndex);
+        const value = line.slice(eqIndex + 1);
+        if (isSensitiveKey(key)) {
+            return `  ${chalk.cyan(key)}=${chalk.yellow(maskApiKey(value))}`;
+        }
+        return `  ${chalk.cyan(key)}=${chalk.white(value)}`;
+    })
+        .join('\n');
+}
+/** Render a step header with progress bar. */
+function stepHeader(step, total, title) {
+    const barLen = 20;
+    const filled = Math.round((step / total) * barLen);
+    const bar = chalk.cyan('━'.repeat(filled)) + chalk.dim('━'.repeat(barLen - filled));
+    console.log(`\n  ${bar}  ${chalk.dim(`${step}/${total}`)}  ${chalk.bold.white(title)}\n`);
+}
 const DETECT_TIMEOUT_MS = 5000;
 /** Wrap a detection check with a timeout so a hung service doesn't block onboarding. */
 async function withTimeout(promise, fallback, timeoutMs = DETECT_TIMEOUT_MS) {
@@ -140,13 +176,96 @@ function generateEnvFile(opts) {
     }
     return lines.join('\n');
 }
+const KEY_FORMAT_PREFIXES = {
+    anthropic: 'sk-ant-',
+    openai: 'sk-',
+    groq: 'gsk_',
+};
+async function validateProviderKey(providerKey, apiKey) {
+    // Fast-fail: format check for known prefix patterns
+    const expectedPrefix = KEY_FORMAT_PREFIXES[providerKey];
+    if (expectedPrefix && !apiKey.startsWith(expectedPrefix)) {
+        return {
+            valid: false,
+            error: `Key should start with "${expectedPrefix}"`,
+        };
+    }
+    // Ollama uses a local URL, no key validation needed
+    if (providerKey === 'ollama') {
+        return { valid: true };
+    }
+    // Lightweight API call to verify the key works
+    try {
+        let response;
+        if (providerKey === 'anthropic') {
+            response = await fetch('https://api.anthropic.com/v1/messages', {
+                method: 'POST',
+                signal: AbortSignal.timeout(5000),
+                headers: {
+                    'x-api-key': apiKey,
+                    'anthropic-version': '2023-06-01',
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify({
+                    model: 'claude-3-haiku-20240307',
+                    max_tokens: 1,
+                    messages: [{ role: 'user', content: 'hi' }],
+                }),
+            });
+        }
+        else if (providerKey === 'openai') {
+            response = await fetch('https://api.openai.com/v1/models', {
+                signal: AbortSignal.timeout(5000),
+                headers: { Authorization: `Bearer ${apiKey}` },
+            });
+        }
+        else if (providerKey === 'google') {
+            response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${encodeURIComponent(apiKey)}`, { signal: AbortSignal.timeout(5000) });
+        }
+        else if (providerKey === 'groq') {
+            response = await fetch('https://api.groq.com/openai/v1/models', {
+                signal: AbortSignal.timeout(5000),
+                headers: { Authorization: `Bearer ${apiKey}` },
+            });
+        }
+        else {
+            // Provider not supported for live validation — skip
+            return { valid: true };
+        }
+        if (response.ok) {
+            return { valid: true };
+        }
+        // Parse error message from response body when possible
+        let detail;
+        try {
+            const body = (await response.json());
+            detail = body?.error?.message ?? (typeof body?.message === 'string' ? body.message : undefined);
+        }
+        catch {
+            // ignore parse failure
+        }
+        return {
+            valid: false,
+            error: detail ?? `HTTP ${response.status}`,
+        };
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === 'TimeoutError') {
+            return { valid: false, error: 'Request timed out (5s)' };
+        }
+        return {
+            valid: false,
+            error: err instanceof Error ? err.message : 'Network error',
+        };
+    }
+}
 // Interactive Onboarding
 async function runInteractive() {
     const banner = figlet.textSync('profClaw', { font: 'Standard' });
     console.log(chalk.cyan(banner));
     console.log(chalk.dim('  Onboarding Wizard\n'));
     // Step 1: Detect environment
-    console.log(chalk.bold.white('  Step 1: Environment Detection\n'));
+    stepHeader(1, 6, 'Environment Detection');
     const spin = spinner('Scanning environment...');
     spin.start();
     const env = await detectEnvironment();
@@ -220,8 +339,8 @@ async function runInteractive() {
     const recommended = recommendMode(env);
     console.log('');
     console.log(`  ${chalk.cyan('Recommended mode:')} ${chalk.bold(recommended)}`);
-    // Step 2: Choose mode (arrow keys)
-    console.log(chalk.bold.white('\n  Step 2: Deployment Mode\n'));
+    // Step 2: Choose mode
+    stepHeader(2, 6, 'Deployment Mode');
     let mode;
     try {
         mode = await select({
@@ -252,47 +371,25 @@ async function runInteractive() {
         process.exit(0);
     }
     success(`Mode: ${mode}`);
-    // Step 3: AI Provider (searchable list)
-    console.log(chalk.bold.white('\n  Step 3: AI Provider\n'));
+    // Step 3: AI Provider
+    stepHeader(3, 6, 'AI Provider');
     let anthropicKey;
     let openaiKey;
     let ollamaUrl;
-    const hasExistingProvider = !!process.env.ANTHROPIC_API_KEY || !!process.env.OPENAI_API_KEY;
-    if (hasExistingProvider) {
-        const which = process.env.ANTHROPIC_API_KEY ? 'Anthropic' : 'OpenAI';
-        info(`AI provider already configured from environment (${which}).`);
+    // Check all provider env vars (not just Anthropic/OpenAI)
+    let detectedProviderName = null;
+    for (const p of PROVIDER_CATALOG) {
+        const val = process.env[p.envVar];
+        if (val && val !== '' && !val.startsWith('sk-ant-xxxx') && !val.startsWith('sk-xxxx')) {
+            detectedProviderName = p.name;
+            break;
+        }
+    }
+    if (detectedProviderName) {
+        info(`AI provider already configured from environment (${detectedProviderName}).`);
     }
     else {
-        // Provider catalog
-        const providers = [
-            { key: 'anthropic', name: 'Anthropic', models: 'Claude 4.x, 3.5 Sonnet', envVar: 'ANTHROPIC_API_KEY', category: 'Popular', tag: 'recommended' },
-            { key: 'openai', name: 'OpenAI', models: 'GPT-4o, o1, o3', envVar: 'OPENAI_API_KEY', category: 'Popular', tag: '' },
-            { key: 'google', name: 'Google AI', models: 'Gemini 2.x, Flash', envVar: 'GOOGLE_GENERATIVE_AI_API_KEY', category: 'Popular', tag: '' },
-            { key: 'ollama', name: 'Ollama', models: 'Llama, Mistral, Qwen', envVar: 'OLLAMA_BASE_URL', category: 'Popular', tag: env.hasOllama ? 'detected' : 'free, local' },
-            { key: 'groq', name: 'Groq', models: 'Llama, Mixtral', envVar: 'GROQ_API_KEY', category: 'Fast Inference', tag: 'fast' },
-            { key: 'cerebras', name: 'Cerebras', models: 'Llama 3.3 70B', envVar: 'CEREBRAS_API_KEY', category: 'Fast Inference', tag: 'fast' },
-            { key: 'fireworks', name: 'Fireworks', models: 'Llama, Mixtral', envVar: 'FIREWORKS_API_KEY', category: 'Fast Inference', tag: '' },
-            { key: 'together', name: 'Together', models: 'Open models', envVar: 'TOGETHER_API_KEY', category: 'Fast Inference', tag: '' },
-            { key: 'azure', name: 'Azure OpenAI', models: 'GPT-4o', envVar: 'AZURE_OPENAI_API_KEY', category: 'Enterprise', tag: 'enterprise' },
-            { key: 'bedrock', name: 'AWS Bedrock', models: 'Claude, Titan, Llama', envVar: 'AWS_ACCESS_KEY_ID', category: 'Enterprise', tag: 'enterprise' },
-            { key: 'watsonx', name: 'IBM Watsonx', models: 'Granite, Llama', envVar: 'WATSONX_API_KEY', category: 'Enterprise', tag: 'enterprise' },
-            { key: 'deepseek', name: 'DeepSeek', models: 'V3, R1 (reasoning)', envVar: 'DEEPSEEK_API_KEY', category: 'More Providers', tag: '' },
-            { key: 'mistral', name: 'Mistral', models: 'Large, Codestral', envVar: 'MISTRAL_API_KEY', category: 'More Providers', tag: '' },
-            { key: 'xai', name: 'xAI', models: 'Grok', envVar: 'XAI_API_KEY', category: 'More Providers', tag: '' },
-            { key: 'perplexity', name: 'Perplexity', models: 'Sonar (search)', envVar: 'PERPLEXITY_API_KEY', category: 'More Providers', tag: 'search' },
-            { key: 'cohere', name: 'Cohere', models: 'Command R+', envVar: 'COHERE_API_KEY', category: 'More Providers', tag: '' },
-            { key: 'openrouter', name: 'OpenRouter', models: 'Any model (proxy)', envVar: 'OPENROUTER_API_KEY', category: 'Aggregators', tag: 'multi-model' },
-            { key: 'replicate', name: 'Replicate', models: 'Open-source models', envVar: 'REPLICATE_API_TOKEN', category: 'Aggregators', tag: '' },
-            { key: 'github-models', name: 'GitHub Models', models: 'Azure-backed', envVar: 'GITHUB_TOKEN', category: 'Aggregators', tag: '' },
-            { key: 'huggingface', name: 'HuggingFace', models: 'Inference API', envVar: 'HF_TOKEN', category: 'Aggregators', tag: '' },
-            { key: 'nvidia-nim', name: 'NVIDIA NIM', models: 'Llama, Nemotron', envVar: 'NVIDIA_NIM_API_KEY', category: 'Aggregators', tag: '' },
-            { key: 'zhipu', name: 'Zhipu AI', models: 'GLM-4, GLM-5', envVar: 'ZHIPU_API_KEY', category: 'Asia', tag: '' },
-            { key: 'moonshot', name: 'Moonshot', models: 'Kimi (128K context)', envVar: 'MOONSHOT_API_KEY', category: 'Asia', tag: '' },
-            { key: 'qwen', name: 'Qwen', models: 'Qwen Max, Plus', envVar: 'QWEN_API_KEY', category: 'Asia', tag: '' },
-            { key: 'minimax', name: 'MiniMax', models: 'abab series', envVar: 'MINIMAX_API_KEY', category: 'Asia', tag: '' },
-            { key: 'volcengine', name: 'Volcengine', models: 'Doubao (Bytedance)', envVar: 'VOLCENGINE_API_KEY', category: 'Asia', tag: '' },
-            { key: 'qianfan', name: 'Qianfan', models: 'ERNIE (Baidu)', envVar: 'QIANFAN_API_KEY', category: 'Asia', tag: '' },
-        ];
+        const providers = PROVIDER_CATALOG;
         // Check which providers have keys in env
         const detected = new Set();
         for (const p of providers) {
@@ -306,6 +403,7 @@ async function runInteractive() {
         try {
             chosenProvider = await search({
                 message: 'Select AI provider (type to filter, arrows to navigate)',
+                pageSize: 15,
                 source: (term) => {
                     const results = [];
                     const filter = (term || '').toLowerCase();
@@ -377,108 +475,174 @@ async function runInteractive() {
                 success(`${chosen.name} already configured from ${chosen.envVar}`);
             }
             else {
-                try {
-                    const keyInput = await input({
-                        message: chosen.envVar,
-                        theme: { prefix: '  ' },
-                    });
-                    if (keyInput) {
+                let configured = false;
+                while (!configured) {
+                    let keyInput;
+                    try {
+                        keyInput = await input({
+                            message: chosen.envVar,
+                            theme: { prefix: '  ' },
+                        });
+                    }
+                    catch {
+                        warn('Input cancelled, skipping provider.');
+                        break;
+                    }
+                    if (!keyInput) {
+                        warn('No key provided, skipping.');
+                        break;
+                    }
+                    const verifySpin = spinner('Verifying API key...');
+                    verifySpin.start();
+                    const validation = await validateProviderKey(chosen.key, keyInput);
+                    verifySpin.stop();
+                    if (validation.valid) {
                         if (chosen.key === 'anthropic')
                             anthropicKey = keyInput;
                         else if (chosen.key === 'openai')
                             openaiKey = keyInput;
-                        else {
+                        else
                             process.env[chosen.envVar] = keyInput;
-                        }
                         success(`${chosen.name} configured.`);
+                        configured = true;
                     }
                     else {
-                        warn('No key provided, skipping.');
+                        error(`Invalid key: ${validation.error ?? 'verification failed'}`);
+                        let retry = false;
+                        try {
+                            retry = await confirm({
+                                message: 'Re-enter the key?',
+                                default: true,
+                                theme: { prefix: '  ' },
+                            });
+                        }
+                        catch {
+                            // cancelled
+                        }
+                        if (!retry) {
+                            warn(`Skipping ${chosen.name}.`);
+                            break;
+                        }
                     }
                 }
-                catch {
-                    warn('Input cancelled, skipping provider.');
-                }
             }
         }
         else {
             info('AI provider skipped. Configure later: profclaw provider');
         }
     }
+    // Collect extra env vars that were set during provider selection
+    const extraEnvVars = {};
+    if (!anthropicKey && !openaiKey && !ollamaUrl) {
+        for (const key of PROVIDER_ENV_KEYS) {
+            if (process.env[key])
+                extraEnvVars[key] = process.env[key];
+        }
+    }
     // Step 4: Generate .env
-    console.log(chalk.bold.white('\n  Step 4: Configuration\n'));
+    stepHeader(4, 6, 'Configuration');
+    const envPath = join(process.cwd(), '.env');
     if (!env.existingEnv) {
         const envContent = generateEnvFile({
             mode,
             anthropicKey,
             openaiKey,
             ollamaUrl,
+            extraEnvVars,
         });
-        const envPath = join(process.cwd(), '.env');
+        console.log(chalk.bold.white('\n  Configuration Preview:\n'));
+        console.log(formatEnvPreview(envContent));
+        console.log('');
+        let writeConfirmed = true;
         try {
-            writeFileSync(envPath, envContent, { mode: 0o600 });
-            success('.env file created.');
+            writeConfirmed = await confirm({
+                message: 'Write this configuration to .env?',
+                default: true,
+                theme: { prefix: '  ' },
+            });
         }
-        catch (err) {
-            error(`Failed to write .env: ${err instanceof Error ? err.message : 'unknown'}`);
-            info('Create .env manually with the values above.');
+        catch { /* Ctrl+C — keep default true */ }
+        if (!writeConfirmed) {
+            warn('Skipped .env write. You can create it manually.');
+        }
+        else {
+            try {
+                writeFileSync(envPath, envContent, { mode: 0o600 });
+                success('.env file created.');
+            }
+            catch (err) {
+                error(`Failed to write .env: ${err instanceof Error ? err.message : 'unknown'}`);
+                info('Create .env manually with the values above.');
+            }
         }
     }
     else {
-        info('.env file already exists. Updating PROFCLAW_MODE...');
-        const envPath = join(process.cwd(), '.env');
         let content = readFileSync(envPath, 'utf-8');
+        // Update mode
         if (content.includes('PROFCLAW_MODE=')) {
             content = content.replace(/PROFCLAW_MODE=\w+/, `PROFCLAW_MODE=${mode}`);
         }
         else {
             content += `\nPROFCLAW_MODE=${mode}\n`;
         }
-        writeFileSync(envPath, content);
-        success(`PROFCLAW_MODE=${mode} set in .env`);
+        // Add provider keys to existing .env
+        const keysToWrite = { ...extraEnvVars };
+        if (anthropicKey)
+            keysToWrite['ANTHROPIC_API_KEY'] = anthropicKey;
+        if (openaiKey)
+            keysToWrite['OPENAI_API_KEY'] = openaiKey;
+        if (ollamaUrl)
+            keysToWrite['OLLAMA_BASE_URL'] = ollamaUrl;
+        // Show preview of what will change
+        const allUpdates = { PROFCLAW_MODE: mode, ...keysToWrite };
+        console.log(chalk.bold.white('\n  Changes to existing .env:\n'));
+        for (const [key, value] of Object.entries(allUpdates)) {
+            const masked = isSensitiveKey(key) ? maskApiKey(value) : value;
+            const action = content.includes(`${key}=`) ? chalk.yellow('update') : chalk.green('add');
+            console.log(`  [${action}] ${chalk.cyan(key)}=${chalk.white(masked)}`);
+        }
+        console.log('');
+        let writeConfirmed = true;
+        try {
+            writeConfirmed = await confirm({
+                message: 'Apply these changes to .env?',
+                default: true,
+                theme: { prefix: '  ' },
+            });
+        }
+        catch { /* Ctrl+C — keep default true */ }
+        if (!writeConfirmed) {
+            warn('Skipped .env update. You can edit it manually.');
+        }
+        else {
+            for (const [key, value] of Object.entries(keysToWrite)) {
+                if (content.includes(`${key}=`)) {
+                    content = content.replace(new RegExp(`${key}=.*`), `${key}=${value}`);
+                }
+                else {
+                    content += `${key}=${value}\n`;
+                }
+            }
+            writeFileSync(envPath, content);
+            const keyCount = Object.keys(keysToWrite).length;
+            if (keyCount > 0) {
+                success(`PROFCLAW_MODE=${mode} + ${keyCount} provider key(s) saved to .env`);
+            }
+            else {
+                success(`PROFCLAW_MODE=${mode} set in .env`);
+            }
+        }
     }
-    // Step 5: Run setup wizard
-    console.log(chalk.bold.white('\n  Step 5: Setup\n'));
-    info('Launching setup wizard for admin account and provider configuration...\n');
+    // Steps 5-6: Delegate to setup wizard for admin account + registration
+    // Setup continues the step numbering (5/6, 6/6) and shows summary + server start
     try {
         const { setupCommand } = await import('./setup.js');
         const setupCmd = setupCommand();
-        await setupCmd.parseAsync(['node', 'setup']);
+        await setupCmd.parseAsync(['node', 'setup', '--from-onboard']);
     }
     catch (err) {
         error(`Setup wizard failed: ${err instanceof Error ? err.message : 'Unknown error'}`);
         info('You can run it again later: profclaw setup');
-        return;
-    }
-    // Step 6: Post-setup validation
-    console.log(chalk.bold.white('\n  Step 6: Validation\n'));
-    const postSpin = spinner('Validating installation...');
-    postSpin.start();
-    const checks = [];
-    // Check .env exists
-    const envExists = existsSync(join(process.cwd(), '.env'));
-    checks.push({ label: '.env file', ok: envExists });
-    // Check config exists
-    const configExists = existsSync(join(process.cwd(), 'config', 'settings.yml'));
-    checks.push({ label: 'config/settings.yml', ok: configExists });
-    // Check database was created
-    const dbExists = existsSync(join(process.cwd(), 'data', 'profclaw.db'));
-    checks.push({ label: 'Database', ok: dbExists });
-    postSpin.stop();
-    for (const check of checks) {
-        const icon = check.ok ? chalk.green('  +') : chalk.red('  -');
-        console.log(`${icon} ${check.label}: ${check.ok ? 'OK' : 'missing'}`);
-    }
-    const allPassed = checks.every((c) => c.ok);
-    if (allPassed) {
-        console.log('');
-        success('Onboarding complete! Start the server:');
-        console.log(`\n  ${chalk.cyan.bold('profclaw serve')}\n`);
-    }
-    else {
-        console.log('');
-        warn('Some checks did not pass. You may need to run setup again:');
-        console.log(`\n  ${chalk.cyan('profclaw setup')}\n`);
     }
 }
 // Non-Interactive Onboarding
@@ -538,6 +702,7 @@ export function onboardCommand() {
             else {
                 await runInteractive();
             }
+            process.exit(0);
         }
         catch (err) {
             error(err instanceof Error ? err.message : 'Onboarding failed');

package/dist/cli/commands/plan.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Plan Mode CLI Commands
+ *
+ * View and manage agent plans created during plan-mode sessions.
+ *
+ * Usage:
+ *   profclaw plan list
+ *   profclaw plan show <id>
+ *   profclaw plan approve <id>
+ */
+import { Command } from 'commander';
+export declare function planCommands(): Command;
+//# sourceMappingURL=plan.d.ts.map

package/dist/cli/commands/plan.js

@@ -0,0 +1,184 @@
+/**
+ * Plan Mode CLI Commands
+ *
+ * View and manage agent plans created during plan-mode sessions.
+ *
+ * Usage:
+ *   profclaw plan list
+ *   profclaw plan show <id>
+ *   profclaw plan approve <id>
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { planManager } from '../../agents/plan-mode.js';
+import { createTable, formatRelativeTime, success, error, warn, truncate, } from '../utils/output.js';
+// ─── Status formatting ───────────────────────────────────────────────────────
+const PLAN_STATUS_COLORS = {
+    draft: chalk.yellow,
+    approved: chalk.blue,
+    in_progress: chalk.cyan,
+    completed: chalk.green,
+    rejected: chalk.red,
+};
+const STEP_STATUS_SYMBOLS = {
+    pending: chalk.dim('○'),
+    in_progress: chalk.cyan('◑'),
+    completed: chalk.green('●'),
+    skipped: chalk.gray('–'),
+};
+function formatPlanStatus(status) {
+    const colorFn = PLAN_STATUS_COLORS[status] ?? chalk.white;
+    return colorFn(status.toUpperCase().replace('_', ' '));
+}
+// ─── Command builder ─────────────────────────────────────────────────────────
+export function planCommands() {
+    const plan = new Command('plan').description('Manage agent implementation plans');
+    // ── list ──────────────────────────────────────────────────────────────────
+    plan
+        .command('list')
+        .alias('ls')
+        .description('List all plans')
+        .option('-s, --status <status>', 'Filter by status (draft|approved|in_progress|completed|rejected)')
+        .option('--json', 'Output as JSON')
+        .action((options) => {
+        let plans = planManager.list();
+        if (options.status) {
+            plans = plans.filter((p) => p.status === options.status);
+        }
+        if (options.json) {
+            console.log(JSON.stringify(plans, null, 2));
+            return;
+        }
+        if (plans.length === 0) {
+            console.log(chalk.dim('No plans found.'));
+            return;
+        }
+        const table = createTable(['ID', 'Title', 'Status', 'Steps', 'Created']);
+        for (const p of plans) {
+            const doneSteps = p.steps.filter((s) => s.status === 'completed' || s.status === 'skipped').length;
+            table.push([
+                p.id.slice(0, 8),
+                truncate(p.title, 40),
+                formatPlanStatus(p.status),
+                `${doneSteps}/${p.steps.length}`,
+                formatRelativeTime(new Date(p.createdAt)),
+            ]);
+        }
+        console.log(table.toString());
+        console.log(chalk.dim(`\n${plans.length} plan(s) total`));
+    });
+    // ── show ──────────────────────────────────────────────────────────────────
+    plan
+        .command('show <id>')
+        .alias('get')
+        .description('Show plan details and step list')
+        .option('--json', 'Output as JSON')
+        .action((id, options) => {
+        // Support partial ID prefix matching
+        const allPlans = planManager.list();
+        const found = allPlans.find((p) => p.id === id || p.id.startsWith(id));
+        if (!found) {
+            error(`Plan not found: ${id}`);
+            process.exit(1);
+        }
+        if (options.json) {
+            console.log(JSON.stringify(found, null, 2));
+            return;
+        }
+        console.log('');
+        console.log(chalk.bold(`Plan: ${found.id}`));
+        console.log(`Title:   ${found.title}`);
+        console.log(`Status:  ${formatPlanStatus(found.status)}`);
+        console.log(`Created: ${formatRelativeTime(new Date(found.createdAt))}`);
+        if (found.approvedAt) {
+            console.log(`Approved: ${formatRelativeTime(new Date(found.approvedAt))}`);
+        }
+        if (found.completedAt) {
+            console.log(`Completed: ${formatRelativeTime(new Date(found.completedAt))}`);
+        }
+        if (found.rejectionReason) {
+            console.log(`Rejection reason: ${chalk.red(found.rejectionReason)}`);
+        }
+        if (found.taskId) {
+            console.log(`Task ID: ${found.taskId}`);
+        }
+        console.log('');
+        console.log(chalk.bold('Steps:'));
+        for (const step of found.steps) {
+            const symbol = STEP_STATUS_SYMBOLS[step.status];
+            const effort = step.estimatedEffort ? chalk.dim(` [${step.estimatedEffort}]`) : '';
+            console.log(`  ${symbol} ${step.index}. ${step.description}${effort}`);
+            if (step.files && step.files.length > 0) {
+                for (const f of step.files) {
+                    console.log(`       ${chalk.dim(f)}`);
+                }
+            }
+        }
+        console.log('');
+    });
+    // ── approve ───────────────────────────────────────────────────────────────
+    plan
+        .command('approve <id>')
+        .description('Approve a pending plan so the agent can begin implementation')
+        .option('--json', 'Output as JSON')
+        .action((id, options) => {
+        const allPlans = planManager.list();
+        const found = allPlans.find((p) => p.id === id || p.id.startsWith(id));
+        if (!found) {
+            error(`Plan not found: ${id}`);
+            process.exit(1);
+        }
+        if (found.status !== 'draft') {
+            warn(`Plan ${found.id.slice(0, 8)} is already ${found.status}, cannot approve.`);
+            process.exit(1);
+        }
+        try {
+            const approved = planManager.approve(found.id);
+            if (options.json) {
+                console.log(JSON.stringify(approved, null, 2));
+                return;
+            }
+            success(`Plan approved: ${approved.id.slice(0, 8)} — "${approved.title}"`);
+            console.log(chalk.dim('The agent will now begin implementation.'));
+        }
+        catch (err) {
+            error(err instanceof Error ? err.message : 'Failed to approve plan');
+            process.exit(1);
+        }
+    });
+    // ── reject ────────────────────────────────────────────────────────────────
+    plan
+        .command('reject <id>')
+        .description('Reject a pending plan')
+        .option('-r, --reason <reason>', 'Reason for rejection')
+        .option('--json', 'Output as JSON')
+        .action((id, options) => {
+        const allPlans = planManager.list();
+        const found = allPlans.find((p) => p.id === id || p.id.startsWith(id));
+        if (!found) {
+            error(`Plan not found: ${id}`);
+            process.exit(1);
+        }
+        if (found.status !== 'draft') {
+            warn(`Plan ${found.id.slice(0, 8)} is already ${found.status}, cannot reject.`);
+            process.exit(1);
+        }
+        try {
+            const rejected = planManager.reject(found.id, options.reason);
+            if (options.json) {
+                console.log(JSON.stringify(rejected, null, 2));
+                return;
+            }
+            console.log(chalk.red('✗') + ` Plan rejected: ${rejected.id.slice(0, 8)}`);
+            if (options.reason) {
+                console.log(chalk.dim(`Reason: ${options.reason}`));
+            }
+        }
+        catch (err) {
+            error(err instanceof Error ? err.message : 'Failed to reject plan');
+            process.exit(1);
+        }
+    });
+    return plan;
+}
+//# sourceMappingURL=plan.js.map