popeye-cli 1.0.1 → 1.2.0

package/dist/cli/interactive.js

@@ -3,11 +3,152 @@
  * Claude Code-style interface for Popeye CLI
  */
 import * as readline from 'node:readline';
-import { getAuthStatusForDisplay, authenticateClaude, authenticateOpenAI } from '../auth/index.js';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { getAuthStatusForDisplay, authenticateClaude, authenticateOpenAI, authenticateGemini, authenticateGrok, isClaudeCLIInstalled, checkClaudeCLIAuth, checkGeminiAuth, checkGrokAuth, } from '../auth/index.js';
 import { runWorkflow, resumeWorkflow, getWorkflowStatus, getWorkflowSummary, } from '../workflow/index.js';
+import { analyzeProjectProgress, verifyProjectCompletion, } from '../state/index.js';
 import { generateProject } from '../generators/index.js';
-import { loadConfig } from '../config/index.js';
+import { discoverProjects, formatProjectForDisplay, } from '../state/registry.js';
+import { loadConfig, saveConfig } from '../config/index.js';
 import { printSuccess, printError, printWarning, printInfo, printKeyValue, startSpinner, succeedSpinner, failSpinner, stopSpinner, theme, } from './output.js';
+/**
+ * Read popeye.md from project directory
+ * Returns null if file doesn't exist
+ */
+async function readPopeyeConfig(projectDir) {
+    const configPath = path.join(projectDir, 'popeye.md');
+    try {
+        const content = await fs.readFile(configPath, 'utf-8');
+        // Parse YAML frontmatter
+        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        if (!frontmatterMatch) {
+            return null;
+        }
+        const frontmatter = frontmatterMatch[1];
+        const config = {};
+        // Parse each line of YAML
+        for (const line of frontmatter.split('\n')) {
+            const match = line.match(/^(\w+):\s*(.+)$/);
+            if (match) {
+                const [, key, value] = match;
+                const cleanValue = value.trim();
+                switch (key) {
+                    case 'language':
+                        if (['python', 'typescript', 'fullstack'].includes(cleanValue)) {
+                            config.language = cleanValue;
+                        }
+                        break;
+                    case 'reviewer':
+                        if (['openai', 'gemini', 'grok'].includes(cleanValue)) {
+                            config.reviewer = cleanValue;
+                        }
+                        break;
+                    case 'arbitrator':
+                        if (['openai', 'gemini', 'grok', 'off'].includes(cleanValue)) {
+                            if (cleanValue === 'off') {
+                                config.enableArbitration = false;
+                            }
+                            else {
+                                config.arbitrator = cleanValue;
+                                config.enableArbitration = true;
+                            }
+                        }
+                        break;
+                    case 'created':
+                        config.created = cleanValue;
+                        break;
+                    case 'lastRun':
+                        config.lastRun = cleanValue;
+                        break;
+                    case 'projectName':
+                        config.projectName = cleanValue;
+                        break;
+                }
+            }
+        }
+        // Extract notes section if present
+        const notesMatch = content.match(/## Notes\n([\s\S]*?)(?=\n## |$)/);
+        if (notesMatch) {
+            config.notes = notesMatch[1].trim();
+        }
+        // Return config only if we have the essential fields
+        if (config.language && config.reviewer) {
+            return {
+                language: config.language,
+                reviewer: config.reviewer,
+                arbitrator: config.arbitrator || 'gemini',
+                enableArbitration: config.enableArbitration ?? true,
+                created: config.created || new Date().toISOString(),
+                lastRun: config.lastRun || new Date().toISOString(),
+                projectName: config.projectName,
+                description: config.description,
+                notes: config.notes,
+            };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write popeye.md to project directory
+ */
+async function writePopeyeConfig(projectDir, config) {
+    const configPath = path.join(projectDir, 'popeye.md');
+    const content = `---
+# Popeye Project Configuration
+language: ${config.language}
+reviewer: ${config.reviewer}
+arbitrator: ${config.enableArbitration ? config.arbitrator : 'off'}
+created: ${config.created}
+lastRun: ${new Date().toISOString()}
+${config.projectName ? `projectName: ${config.projectName}` : ''}
+---
+
+# ${config.projectName || 'Popeye Project'}
+
+${config.description ? `## Description\n${config.description}\n` : ''}
+## Notes
+${config.notes || 'Add any guidance or notes for Claude here...'}
+
+## Configuration
+- **Language**: ${config.language}
+- **Reviewer**: ${config.reviewer}
+- **Arbitrator**: ${config.enableArbitration ? config.arbitrator : 'disabled'}
+
+## Session History
+- ${config.created.split('T')[0]}: Project created
+- ${new Date().toISOString().split('T')[0]}: Last session
+`;
+    await fs.writeFile(configPath, content, 'utf-8');
+}
+/**
+ * Update lastRun in popeye.md without changing other content
+ */
+async function updatePopeyeLastRun(projectDir) {
+    const configPath = path.join(projectDir, 'popeye.md');
+    try {
+        let content = await fs.readFile(configPath, 'utf-8');
+        // Update lastRun in frontmatter
+        content = content.replace(/lastRun:\s*.+/, `lastRun: ${new Date().toISOString()}`);
+        await fs.writeFile(configPath, content, 'utf-8');
+    }
+    catch {
+        // File doesn't exist, ignore
+    }
+}
+/**
+ * Apply popeye.md config to session state
+ */
+function applyPopeyeConfig(state, config) {
+    state.language = config.language;
+    state.reviewer = config.reviewer;
+    state.arbitrator = config.arbitrator;
+    state.enableArbitration = config.enableArbitration;
+}
+// Note: startSpinner, succeedSpinner, failSpinner, stopSpinner are used in handleIdea
 /**
  * Box drawing characters for Claude Code-style UI
  */
@@ -33,7 +174,7 @@ function getTerminalWidth() {
 function drawHeader() {
     const width = getTerminalWidth();
     const title = ' Popeye CLI ';
-    const subtitle = ' AI-Powered Code Generation ';
+    const subtitle = ' Autonomous Code Generation with AI Consensus ';
     // Top border
     console.log(theme.dim(box.topLeft + box.horizontal.repeat(width - 2) + box.topRight));
     // Title line
@@ -54,33 +195,57 @@ function drawHeader() {
     console.log(theme.dim(box.bottomLeft + box.horizontal.repeat(width - 2) + box.bottomRight));
 }
 /**
- * Draw the input box frame
+ * Draw hints line and top of input box
  */
-function drawInputFrame(state) {
-    const width = getTerminalWidth();
-    // Status items
-    const langStatus = `${state.language}`;
-    const modelStatus = `${state.model}`;
-    const authStatus = state.claudeAuth && state.openaiAuth ? '●' : '○';
-    const authColor = state.claudeAuth && state.openaiAuth ? theme.success : theme.warning;
-    // Build status line
-    const statusItems = [
-        theme.dim('lang:') + theme.primary(langStatus),
-        theme.dim('model:') + theme.secondary(modelStatus),
-        authColor(authStatus) + theme.dim(' auth'),
+function drawInputBoxTop(state) {
+    const width = Math.min(getTerminalWidth(), 100);
+    // Hints line (above the box)
+    const hints = [
+        theme.dim('/lang ') + theme.primary('py') + theme.dim('|') + theme.primary('ts') + theme.dim('|') + theme.primary('fs'),
+        theme.dim('/config'),
+        theme.dim('/help'),
+        theme.dim('/exit'),
+    ];
+    console.log('  ' + hints.join('   '));
+    // Status items for the top line
+    const langStatus = state.language === 'fullstack' ? 'fs' : state.language;
+    const reviewerStatus = state.reviewer === 'openai' ? 'O' : state.reviewer === 'grok' ? 'X' : 'G';
+    const arbitratorStatus = state.enableArbitration
+        ? (state.arbitrator === 'openai' ? 'O' : state.arbitrator === 'grok' ? 'X' : 'G')
+        : '-';
+    // Check auth based on which providers are configured
+    const reviewerAuthed = state.reviewer === 'openai' ? state.openaiAuth
+        : state.reviewer === 'grok' ? state.grokAuth : state.geminiAuth;
+    const arbitratorAuthed = !state.enableArbitration ? true
+        : state.arbitrator === 'openai' ? state.openaiAuth
+            : state.arbitrator === 'grok' ? state.grokAuth : state.geminiAuth;
+    const allAuth = state.claudeAuth && reviewerAuthed && arbitratorAuthed;
+    const authIcon = allAuth ? '●' : '○';
+    const authColor = allAuth ? theme.success : theme.warning;
+    // Build status text
+    const statusParts = [
+        theme.primary(langStatus),
+        theme.dim('R:') + theme.secondary(reviewerStatus),
+        theme.dim('A:') + theme.secondary(arbitratorStatus),
+        authColor(authIcon),
     ];
-    const statusText = statusItems.join(theme.dim(' │ '));
+    const statusText = statusParts.join(theme.dim(' │ '));
     // Calculate visible length (without ANSI codes)
     // eslint-disable-next-line no-control-regex
     const stripAnsi = (str) => str.replace(/\x1b\[[0-9;]*m/g, '');
     const statusLen = stripAnsi(statusText).length;
-    // Top line with status
-    const topLine = box.topLeft +
-        box.horizontal.repeat(2) +
-        ' ' + stripAnsi(statusText) + ' ' +
-        box.horizontal.repeat(Math.max(0, width - statusLen - 6)) +
-        box.topRight;
-    console.log(theme.dim(topLine.slice(0, 1)) + statusText + theme.dim(topLine.slice(statusLen + 4)));
+    // Top line: ╭─ status ─────────────────────────────────────────╮
+    const paddingLen = Math.max(0, width - statusLen - 6);
+    console.log(theme.dim(box.topLeft + box.horizontal + ' ') +
+        statusText +
+        theme.dim(' ' + box.horizontal.repeat(paddingLen) + box.topRight));
+}
+/**
+ * Draw bottom of input box after user presses enter
+ */
+function drawInputBoxBottom() {
+    const width = Math.min(getTerminalWidth(), 100);
+    console.log(theme.dim(box.bottomLeft + box.horizontal.repeat(width - 2) + box.bottomRight));
 }
 /**
  * Clear screen and redraw UI
@@ -91,10 +256,102 @@ function redrawUI(_state) {
     console.log();
 }
 /**
- * Prompt for input with styled prompt
+ * Prompt for input with styled prompt (inside box)
  */
 function getPrompt() {
-    return theme.dim(box.vertical) + ' ' + theme.primary('❯') + ' ';
+    return theme.dim(box.vertical + ' ') + theme.primary('popeye') + theme.dim(' > ');
+}
+/**
+ * Prompt user to select an option
+ * Uses terminal: false to prevent echo issues when nested with main readline
+ */
+async function promptSelection(question, options, defaultValue) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: false, // Prevent terminal mode to avoid echo issues
+        });
+        console.log();
+        console.log(theme.primary(`  ${question}`));
+        options.forEach((opt, i) => {
+            const isDefault = opt.value === defaultValue;
+            console.log(`    ${theme.dim(`${i + 1}.`)} ${opt.label}${isDefault ? theme.dim(' (default)') : ''}`);
+        });
+        console.log();
+        // Print prompt manually since terminal: false disables it
+        process.stdout.write(`  Enter choice [1-${options.length}] or press Enter for default: `);
+        rl.once('line', (answer) => {
+            rl.close();
+            const trimmed = answer.trim();
+            if (!trimmed) {
+                resolve(defaultValue);
+                return;
+            }
+            const num = parseInt(trimmed, 10);
+            if (num >= 1 && num <= options.length) {
+                resolve(options[num - 1].value);
+            }
+            else {
+                resolve(defaultValue);
+            }
+        });
+    });
+}
+/**
+ * Prompt yes/no question
+ * Uses terminal: false to prevent echo issues when nested with main readline
+ */
+async function promptYesNo(question, defaultYes = true) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: false, // Prevent terminal mode to avoid echo issues
+        });
+        const hint = defaultYes ? '[Y/n]' : '[y/N]';
+        process.stdout.write(`  ${question} ${theme.dim(hint)} `);
+        rl.once('line', (answer) => {
+            rl.close();
+            const trimmed = answer.trim().toLowerCase();
+            if (!trimmed) {
+                resolve(defaultYes);
+            }
+            else {
+                resolve(trimmed === 'y' || trimmed === 'yes');
+            }
+        });
+    });
+}
+/**
+ * Check if reviewer/arbitrator has been configured (saved to config)
+ */
+async function isConsensusConfigured() {
+    const config = await loadConfig();
+    // Consider configured if enable_arbitration is true or if arbitrator is explicitly set to a provider
+    // (Default is arbitrator='off' and enable_arbitration=false, so any change indicates user configured it)
+    return config.consensus.enable_arbitration || config.consensus.arbitrator !== 'off';
+}
+/**
+ * Save reviewer/arbitrator settings to config file
+ */
+async function saveConsensusConfig(state) {
+    try {
+        // Load existing config and merge with new consensus settings
+        const existingConfig = await loadConfig();
+        const updatedConsensus = {
+            ...existingConfig.consensus,
+            reviewer: state.reviewer,
+            arbitrator: state.enableArbitration ? state.arbitrator : 'off',
+            enable_arbitration: state.enableArbitration,
+        };
+        await saveConfig({
+            consensus: updatedConsensus,
+        }, true); // Save to global config
+    }
+    catch (err) {
+        printWarning(`Could not save config: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    }
 }
 /**
  * Check and perform authentication
@@ -103,77 +360,255 @@ async function ensureAuthentication(state) {
     const status = await getAuthStatusForDisplay();
     state.claudeAuth = status.claude.authenticated;
     state.openaiAuth = status.openai.authenticated;
-    if (state.claudeAuth && state.openaiAuth) {
-        return true;
-    }
+    state.geminiAuth = status.gemini?.authenticated || false;
+    const grokStatus = await checkGrokAuth();
+    state.grokAuth = grokStatus.authenticated;
     console.log();
-    printWarning('Authentication required to continue');
+    printInfo('Checking authentication...');
     console.log();
     // Authenticate Claude if needed
     if (!state.claudeAuth) {
-        console.log(theme.dim(box.vertical) + ' ' + theme.primary('Claude CLI') + theme.dim(' - Browser authentication'));
+        console.log(theme.dim(box.vertical) + ' ' + theme.primary('Claude Code CLI') + theme.dim(' - Required for code generation'));
         console.log(theme.dim(box.vertical));
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        const proceed = await new Promise((resolve) => {
-            rl.question(theme.dim(box.vertical) + '   Press Enter to open browser (or "skip" to skip): ', (answer) => {
-                rl.close();
-                resolve(answer.toLowerCase() !== 'skip');
-            });
-        });
-        if (proceed) {
-            startSpinner('Opening browser for Claude authentication...');
+        try {
+            const success = await authenticateClaude();
+            if (success) {
+                printSuccess('Claude Code CLI ready');
+                state.claudeAuth = true;
+            }
+            else {
+                printWarning('Claude Code CLI not authenticated - run "claude login" to authenticate');
+            }
+        }
+        catch (err) {
+            printError(err instanceof Error ? err.message : 'Authentication failed');
+        }
+        console.log();
+    }
+    else {
+        printSuccess('Claude Code CLI ready');
+    }
+    // Authenticate OpenAI if needed
+    if (!state.openaiAuth) {
+        console.log(theme.dim(box.vertical) + ' ' + theme.primary('OpenAI API') + theme.dim(' - Required for consensus review'));
+        console.log(theme.dim(box.vertical));
+        try {
+            const success = await authenticateOpenAI();
+            if (success) {
+                printSuccess('OpenAI API ready');
+                state.openaiAuth = true;
+            }
+            else {
+                printWarning('OpenAI API not authenticated');
+            }
+        }
+        catch (err) {
+            printError(err instanceof Error ? err.message : 'Authentication failed');
+        }
+        console.log();
+    }
+    else {
+        printSuccess('OpenAI API ready');
+    }
+    // Check if reviewer/arbitrator is already configured
+    const alreadyConfigured = await isConsensusConfigured();
+    // Only ask about reviewer/arbitrator if not already configured
+    if (state.claudeAuth && state.openaiAuth && !alreadyConfigured) {
+        console.log();
+        console.log(theme.primary.bold('  AI Configuration'));
+        console.log(theme.dim('  Claude generates code. Choose who reviews and arbitrates:'));
+        // Ask who should review plans
+        state.reviewer = await promptSelection('Who should review Claude\'s plans?', [
+            { label: theme.secondary('OpenAI') + theme.dim(' - GPT-4o reviews plans'), value: 'openai' },
+            { label: theme.secondary('Gemini') + theme.dim(' - Gemini 2.0 reviews plans'), value: 'gemini' },
+            { label: theme.secondary('Grok') + theme.dim(' - xAI Grok reviews plans'), value: 'grok' },
+        ], 'openai');
+        // Ask about arbitration
+        console.log();
+        state.enableArbitration = await promptYesNo(theme.primary('Enable arbitration when consensus is stuck?'), true);
+        if (state.enableArbitration) {
+            // Auto-select a different provider as arbitrator
+            const defaultArbitrator = state.reviewer === 'openai' ? 'gemini'
+                : state.reviewer === 'gemini' ? 'openai' : 'gemini';
+            state.arbitrator = await promptSelection('Who should arbitrate when stuck?', [
+                { label: theme.secondary('Gemini') + theme.dim(' - Google Gemini breaks deadlocks'), value: 'gemini' },
+                { label: theme.secondary('OpenAI') + theme.dim(' - OpenAI breaks deadlocks'), value: 'openai' },
+                { label: theme.secondary('Grok') + theme.dim(' - xAI Grok breaks deadlocks'), value: 'grok' },
+            ], defaultArbitrator);
+            // Authenticate Gemini if needed for reviewer or arbitrator
+            const needsGemini = state.reviewer === 'gemini' || state.arbitrator === 'gemini';
+            if (needsGemini && !state.geminiAuth) {
+                console.log();
+                console.log(theme.dim(box.vertical) + ' ' + theme.primary('Gemini API') + theme.dim(' - Required for ' + (state.reviewer === 'gemini' ? 'review' : 'arbitration')));
+                console.log(theme.dim(box.vertical));
+                try {
+                    const success = await authenticateGemini();
+                    if (success) {
+                        printSuccess('Gemini API ready');
+                        state.geminiAuth = true;
+                    }
+                    else {
+                        printWarning('Gemini API not authenticated - arbitration disabled');
+                        state.enableArbitration = false;
+                    }
+                }
+                catch (err) {
+                    printError(err instanceof Error ? err.message : 'Authentication failed');
+                    state.enableArbitration = false;
+                }
+            }
+            // Authenticate Grok if needed for reviewer or arbitrator
+            const needsGrok = state.reviewer === 'grok' || state.arbitrator === 'grok';
+            if (needsGrok && !state.grokAuth) {
+                console.log();
+                console.log(theme.dim(box.vertical) + ' ' + theme.primary('Grok API') + theme.dim(' - Required for ' + (state.reviewer === 'grok' ? 'review' : 'arbitration')));
+                console.log(theme.dim(box.vertical));
+                try {
+                    const success = await authenticateGrok();
+                    if (success) {
+                        printSuccess('Grok API ready');
+                        state.grokAuth = true;
+                    }
+                    else {
+                        printWarning('Grok API not authenticated');
+                        if (state.reviewer === 'grok') {
+                            printWarning('Falling back to OpenAI as reviewer');
+                            state.reviewer = 'openai';
+                        }
+                        if (state.arbitrator === 'grok') {
+                            state.enableArbitration = false;
+                        }
+                    }
+                }
+                catch (err) {
+                    printError(err instanceof Error ? err.message : 'Authentication failed');
+                    if (state.reviewer === 'grok') {
+                        state.reviewer = 'openai';
+                    }
+                    if (state.arbitrator === 'grok') {
+                        state.enableArbitration = false;
+                    }
+                }
+            }
+        }
+        // Also check if reviewer is gemini and we need to auth
+        if (state.reviewer === 'gemini' && !state.geminiAuth) {
+            console.log();
+            console.log(theme.dim(box.vertical) + ' ' + theme.primary('Gemini API') + theme.dim(' - Required for review'));
+            console.log(theme.dim(box.vertical));
             try {
-                const success = await authenticateClaude();
+                const success = await authenticateGemini();
                 if (success) {
-                    succeedSpinner('Claude authenticated');
-                    state.claudeAuth = true;
+                    printSuccess('Gemini API ready');
+                    state.geminiAuth = true;
                 }
                 else {
-                    failSpinner('Claude authentication failed');
+                    printWarning('Gemini API not authenticated - falling back to OpenAI');
+                    state.reviewer = 'openai';
                 }
             }
             catch (err) {
-                failSpinner('Claude authentication failed');
                 printError(err instanceof Error ? err.message : 'Authentication failed');
+                state.reviewer = 'openai';
             }
         }
-        console.log();
-    }
-    // Authenticate OpenAI if needed
-    if (!state.openaiAuth) {
-        console.log(theme.dim(box.vertical) + ' ' + theme.primary('OpenAI API') + theme.dim(' - API key required'));
-        console.log(theme.dim(box.vertical));
-        const rl2 = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        const proceed2 = await new Promise((resolve) => {
-            rl2.question(theme.dim(box.vertical) + '   Press Enter to open key entry page (or "skip" to skip): ', (answer) => {
-                rl2.close();
-                resolve(answer.toLowerCase() !== 'skip');
-            });
-        });
-        if (proceed2) {
-            startSpinner('Opening browser for OpenAI API key entry...');
+        // Also check if reviewer is grok and we need to auth
+        if (state.reviewer === 'grok' && !state.grokAuth) {
+            console.log();
+            console.log(theme.dim(box.vertical) + ' ' + theme.primary('Grok API') + theme.dim(' - Required for review'));
+            console.log(theme.dim(box.vertical));
             try {
-                const success = await authenticateOpenAI();
+                const success = await authenticateGrok();
                 if (success) {
-                    succeedSpinner('OpenAI authenticated');
-                    state.openaiAuth = true;
+                    printSuccess('Grok API ready');
+                    state.grokAuth = true;
                 }
                 else {
-                    failSpinner('OpenAI authentication failed');
+                    printWarning('Grok API not authenticated - falling back to OpenAI');
+                    state.reviewer = 'openai';
                 }
             }
             catch (err) {
-                failSpinner('OpenAI authentication failed');
                 printError(err instanceof Error ? err.message : 'Authentication failed');
+                state.reviewer = 'openai';
             }
         }
+        // Save the configuration to persist between sessions
+        await saveConsensusConfig(state);
+        // Show summary
+        console.log();
+        console.log(theme.secondary('  Configuration saved. Use /config to change later.'));
+        const reviewerName = state.reviewer === 'openai' ? 'OpenAI (GPT-4o)' : state.reviewer === 'grok' ? 'Grok' : 'Gemini';
+        const arbitratorName = state.arbitrator === 'openai' ? 'OpenAI' : state.arbitrator === 'grok' ? 'Grok' : 'Gemini';
+        console.log(`    ${theme.dim('Reviewer:')}    ${theme.primary(reviewerName)}`);
+        console.log(`    ${theme.dim('Arbitrator:')}  ${state.enableArbitration ? theme.primary(arbitratorName) : theme.dim('Disabled')}`);
+        console.log();
+    }
+    else if (state.claudeAuth && state.openaiAuth && alreadyConfigured) {
+        // Show loaded configuration
+        console.log();
+        console.log(theme.secondary('  Using saved configuration (use /config to change):'));
+        const savedReviewerName = state.reviewer === 'openai' ? 'OpenAI (GPT-4o)' : state.reviewer === 'grok' ? 'Grok' : 'Gemini';
+        const savedArbitratorName = state.arbitrator === 'openai' ? 'OpenAI' : state.arbitrator === 'grok' ? 'Grok' : 'Gemini';
+        console.log(`    ${theme.dim('Reviewer:')}    ${theme.primary(savedReviewerName)}`);
+        console.log(`    ${theme.dim('Arbitrator:')}  ${state.enableArbitration ? theme.primary(savedArbitratorName) : theme.dim('Disabled')}`);
         console.log();
+        // Authenticate Gemini if needed based on saved config
+        const needsGemini = state.reviewer === 'gemini' || (state.enableArbitration && state.arbitrator === 'gemini');
+        if (needsGemini && !state.geminiAuth) {
+            console.log(theme.dim(box.vertical) + ' ' + theme.primary('Gemini API') + theme.dim(' - Required for ' + (state.reviewer === 'gemini' ? 'review' : 'arbitration')));
+            console.log(theme.dim(box.vertical));
+            try {
+                const success = await authenticateGemini();
+                if (success) {
+                    printSuccess('Gemini API ready');
+                    state.geminiAuth = true;
+                }
+                else {
+                    printWarning('Gemini API not authenticated');
+                    if (state.reviewer === 'gemini') {
+                        printWarning('Falling back to OpenAI as reviewer');
+                        state.reviewer = 'openai';
+                    }
+                    if (state.enableArbitration && state.arbitrator === 'gemini') {
+                        printWarning('Disabling arbitration');
+                        state.enableArbitration = false;
+                    }
+                }
+            }
+            catch (err) {
+                printError(err instanceof Error ? err.message : 'Gemini authentication failed');
+            }
+            console.log();
+        }
+        // Authenticate Grok if needed based on saved config
+        const needsGrok = state.reviewer === 'grok' || (state.enableArbitration && state.arbitrator === 'grok');
+        if (needsGrok && !state.grokAuth) {
+            console.log(theme.dim(box.vertical) + ' ' + theme.primary('Grok API') + theme.dim(' - Required for ' + (state.reviewer === 'grok' ? 'review' : 'arbitration')));
+            console.log(theme.dim(box.vertical));
+            try {
+                const success = await authenticateGrok();
+                if (success) {
+                    printSuccess('Grok API ready');
+                    state.grokAuth = true;
+                }
+                else {
+                    printWarning('Grok API not authenticated');
+                    if (state.reviewer === 'grok') {
+                        printWarning('Falling back to OpenAI as reviewer');
+                        state.reviewer = 'openai';
+                    }
+                    if (state.enableArbitration && state.arbitrator === 'grok') {
+                        printWarning('Disabling arbitration');
+                        state.enableArbitration = false;
+                    }
+                }
+            }
+            catch (err) {
+                printError(err instanceof Error ? err.message : 'Grok authentication failed');
+            }
+            console.log();
+        }
     }
     return state.claudeAuth && state.openaiAuth;
 }
@@ -186,11 +621,14 @@ function showHelp() {
     console.log();
     const commands = [
         ['/help', 'Show this help message'],
+        ['/info', 'Show system info (Claude CLI status, etc.)'],
         ['/status', 'Show current project status'],
         ['/auth', 'Re-authenticate services'],
-        ['/config', 'Show configuration'],
-        ['/language <lang>', 'Set language (python/typescript)'],
-        ['/model <model>', 'Set OpenAI model'],
+        ['/config', 'Show/change configuration'],
+        ['/config reviewer', 'Set reviewer (openai/gemini/grok)'],
+        ['/config arbitrator', 'Set arbitrator (openai/gemini/grok/off)'],
+        ['/lang <lang>', 'Set language (python/typescript/fullstack)'],
+        ['/new <idea>', 'Force start a new project (skips existing check)'],
         ['/resume', 'Resume interrupted project'],
         ['/clear', 'Clear screen'],
         ['/exit', 'Exit Popeye'],
@@ -199,7 +637,64 @@ function showHelp() {
         console.log(`  ${theme.primary(cmd.padEnd(20))} ${theme.dim(desc)}`);
     }
     console.log();
-    console.log(theme.secondary('  Or just type your project idea to get started!'));
+    console.log(theme.secondary('  Type your project idea to get started!'));
+    console.log(theme.secondary('  Example: "A REST API for managing todo items"'));
+    console.log();
+}
+/**
+ * Handle /info command - show system info
+ */
+async function handleInfo() {
+    console.log();
+    console.log(theme.primary.bold('  System Info:'));
+    console.log();
+    // Check Claude CLI
+    const claudeInstalled = await isClaudeCLIInstalled();
+    const claudeStatus = await checkClaudeCLIAuth();
+    console.log(theme.secondary('  Claude Code:'));
+    console.log(`    ${theme.dim('Installed:')}      ${claudeInstalled ? theme.success('Yes') : theme.error('No')}`);
+    if (claudeInstalled) {
+        console.log(`    ${theme.dim('Authenticated:')}  ${claudeStatus.authenticated ? theme.success('Yes') : theme.warning('No')}`);
+        console.log(`    ${theme.dim('Model:')}          ${theme.primary('Uses your Claude Code settings')}`);
+        console.log(`    ${theme.dim('MCPs:')}           ${theme.primary('Uses your configured MCP servers')}`);
+        if (!claudeStatus.authenticated) {
+            console.log();
+            console.log(`    ${theme.warning('Run:')} ${theme.primary('claude login')} ${theme.warning('to authenticate')}`);
+        }
+    }
+    else {
+        console.log();
+        console.log(`    ${theme.warning('Install:')} ${theme.primary('npm install -g @anthropic-ai/claude-code')}`);
+    }
+    console.log();
+    console.log(theme.secondary('  OpenAI:'));
+    const authStatus = await getAuthStatusForDisplay();
+    console.log(`    ${theme.dim('Authenticated:')}  ${authStatus.openai.authenticated ? theme.success('Yes') : theme.warning('No')}`);
+    if (authStatus.openai.authenticated && authStatus.openai.keyLastFour) {
+        console.log(`    ${theme.dim('API Key:')}        ${theme.dim(authStatus.openai.keyLastFour)}`);
+    }
+    console.log();
+    console.log(theme.secondary('  Gemini:'));
+    const geminiStatus = await checkGeminiAuth();
+    console.log(`    ${theme.dim('Authenticated:')}  ${geminiStatus.authenticated ? theme.success('Yes') : theme.dim('No')}`);
+    if (geminiStatus.authenticated && geminiStatus.keyLastFour) {
+        console.log(`    ${theme.dim('API Key:')}        ${theme.dim(geminiStatus.keyLastFour)}`);
+    }
+    console.log();
+    console.log(theme.secondary('  Grok:'));
+    const grokStatus = await checkGrokAuth();
+    console.log(`    ${theme.dim('Authenticated:')}  ${grokStatus.authenticated ? theme.success('Yes') : theme.dim('No')}`);
+    if (grokStatus.authenticated && grokStatus.keyLastFour) {
+        console.log(`    ${theme.dim('API Key:')}        ${theme.dim(grokStatus.keyLastFour)}`);
+    }
+    console.log();
+    console.log(theme.secondary('  Environment:'));
+    console.log(`    ${theme.dim('Node.js:')}        ${process.version}`);
+    console.log(`    ${theme.dim('Platform:')}       ${process.platform}`);
+    console.log(`    ${theme.dim('Working Dir:')}    ${process.cwd()}`);
+    console.log();
+    console.log(theme.dim('  Tip: Claude Code model and MCP settings are configured in your'));
+    console.log(theme.dim('  Claude Code CLI. Run "claude config" to see/change them.'));
     console.log();
 }
 /**
@@ -209,14 +704,26 @@ async function handleInput(input, state) {
     const trimmed = input.trim();
     if (!trimmed)
         return true;
+    // Check for common words that should be commands (without /)
+    const lowerTrimmed = trimmed.toLowerCase();
+    if (['help', 'exit', 'quit', 'info', 'status', 'config'].includes(lowerTrimmed)) {
+        printWarning(`Did you mean /${lowerTrimmed}? Use / prefix for commands.`);
+        return true;
+    }
     // Handle commands
     if (trimmed.startsWith('/')) {
         const [cmd, ...args] = trimmed.split(/\s+/);
         const command = cmd.toLowerCase();
         switch (command) {
             case '/help':
+            case '/h':
+            case '/?':
                 showHelp();
                 break;
+            case '/info':
+            case '/check':
+                await handleInfo();
+                break;
             case '/exit':
             case '/quit':
             case '/q':
@@ -224,6 +731,7 @@ async function handleInput(input, state) {
                 printInfo('Goodbye!');
                 return false;
             case '/clear':
+            case '/cls':
                 redrawUI(state);
                 break;
             case '/status':
@@ -233,16 +741,29 @@ async function handleInput(input, state) {
                 await ensureAuthentication(state);
                 break;
             case '/config':
-                await handleConfig(state);
+                await handleConfig(state, args);
                 break;
             case '/language':
+            case '/lang':
+            case '/l':
                 handleLanguage(args, state);
                 break;
             case '/model':
+            case '/m':
                 handleModel(args, state);
                 break;
             case '/resume':
-                await handleResume(state);
+                await handleResume(state, args);
+                break;
+            case '/new':
+                // Force start a new project even if existing projects found
+                if (args.length === 0) {
+                    printError('Usage: /new <project idea>');
+                    printInfo('Example: /new todo app with user authentication');
+                }
+                else {
+                    await handleNewProject(args.join(' '), state);
+                }
                 break;
             default:
                 printError(`Unknown command: ${cmd}`);
@@ -250,6 +771,12 @@ async function handleInput(input, state) {
         }
         return true;
     }
+    // Warn if input is too short (likely accidental)
+    if (trimmed.length < 10) {
+        printWarning(`Input "${trimmed}" is very short. Did you mean to type a command?`);
+        printInfo('Type /help for commands, or enter a longer project description.');
+        return true;
+    }
     // Handle as project idea
     await handleIdea(trimmed, state);
     return true;
@@ -275,19 +802,129 @@ async function handleStatus(state) {
 /**
  * Handle /config command
  */
-async function handleConfig(state) {
+async function handleConfig(state, args = []) {
     const config = await loadConfig();
+    // Handle config subcommands
+    if (args.length > 0) {
+        const subcommand = args[0].toLowerCase();
+        switch (subcommand) {
+            case 'reviewer':
+                if (args.length > 1) {
+                    const newReviewer = args[1].toLowerCase();
+                    if (newReviewer === 'openai' || newReviewer === 'gemini' || newReviewer === 'grok') {
+                        if (newReviewer === 'gemini' && !state.geminiAuth) {
+                            printWarning('Gemini API not authenticated. Run /auth first.');
+                            return;
+                        }
+                        if (newReviewer === 'grok' && !state.grokAuth) {
+                            printWarning('Grok API not authenticated. Run /auth first.');
+                            return;
+                        }
+                        state.reviewer = newReviewer;
+                        // Save to config
+                        await saveConsensusConfig(state);
+                        printSuccess(`Reviewer set to ${newReviewer}`);
+                    }
+                    else {
+                        printError('Invalid reviewer. Use: openai, gemini, or grok');
+                    }
+                }
+                else {
+                    printKeyValue('Reviewer', state.reviewer);
+                    printInfo('Use: /config reviewer <openai|gemini|grok>');
+                }
+                return;
+            case 'arbitrator':
+                if (args.length > 1) {
+                    const newArbitrator = args[1].toLowerCase();
+                    if (newArbitrator === 'openai' || newArbitrator === 'gemini' || newArbitrator === 'grok') {
+                        if (newArbitrator === 'gemini' && !state.geminiAuth) {
+                            printWarning('Gemini API not authenticated. Run /auth first.');
+                            return;
+                        }
+                        if (newArbitrator === 'grok' && !state.grokAuth) {
+                            printWarning('Grok API not authenticated. Run /auth first.');
+                            return;
+                        }
+                        state.arbitrator = newArbitrator;
+                        state.enableArbitration = true;
+                        // Save to config
+                        await saveConsensusConfig(state);
+                        printSuccess(`Arbitrator set to ${newArbitrator}`);
+                    }
+                    else if (newArbitrator === 'off' || newArbitrator === 'none') {
+                        state.enableArbitration = false;
+                        // Save to config
+                        await saveConsensusConfig(state);
+                        printSuccess('Arbitration disabled');
+                    }
+                    else {
+                        printError('Invalid arbitrator. Use: openai, gemini, grok, or off');
+                    }
+                }
+                else {
+                    printKeyValue('Arbitrator', state.enableArbitration ? state.arbitrator : 'disabled');
+                    printInfo('Use: /config arbitrator <openai|gemini|grok|off>');
+                }
+                return;
+            case 'language':
+            case 'lang':
+                if (args.length > 1) {
+                    // Map shortcuts to full language names
+                    const langAliases = {
+                        'py': 'python',
+                        'python': 'python',
+                        'ts': 'typescript',
+                        'typescript': 'typescript',
+                        'fs': 'fullstack',
+                        'fullstack': 'fullstack',
+                    };
+                    const input = args[1].toLowerCase();
+                    const lang = langAliases[input];
+                    if (lang) {
+                        state.language = lang;
+                        printSuccess(`Language set to ${lang}`);
+                    }
+                    else {
+                        printError('Invalid language. Use: py, ts, fs (or python, typescript, fullstack)');
+                    }
+                }
+                else {
+                    printKeyValue('Language', state.language);
+                }
+                return;
+            default:
+                printError(`Unknown config option: ${subcommand}`);
+                printInfo('Options: reviewer, arbitrator, language');
+                return;
+        }
+    }
+    // Show full config
     console.log();
     console.log(theme.primary.bold('  Session:'));
-    console.log(`    ${theme.dim('Directory:')} ${state.projectDir || 'Not set'}`);
-    console.log(`    ${theme.dim('Language:')}  ${theme.primary(state.language)}`);
-    console.log(`    ${theme.dim('Model:')}     ${theme.secondary(state.model)}`);
-    console.log(`    ${theme.dim('Claude:')}    ${state.claudeAuth ? theme.success('●') : theme.error('○')}`);
-    console.log(`    ${theme.dim('OpenAI:')}    ${state.openaiAuth ? theme.success('●') : theme.error('○')}`);
+    console.log(`    ${theme.dim('Directory:')}  ${state.projectDir || 'Not set'}`);
+    console.log(`    ${theme.dim('Language:')}   ${theme.primary(state.language)}`);
+    console.log();
+    console.log(theme.primary.bold('  Authentication:'));
+    console.log(`    ${theme.dim('Claude:')}     ${state.claudeAuth ? theme.success('● Ready') : theme.error('○ Not authenticated')}`);
+    console.log(`    ${theme.dim('OpenAI:')}     ${state.openaiAuth ? theme.success('● Ready') : theme.error('○ Not authenticated')}`);
+    console.log(`    ${theme.dim('Gemini:')}     ${state.geminiAuth ? theme.success('● Ready') : theme.dim('○ Not configured')}`);
+    console.log(`    ${theme.dim('Grok:')}       ${state.grokAuth ? theme.success('● Ready') : theme.dim('○ Not configured')}`);
+    console.log();
+    console.log(theme.primary.bold('  AI Configuration:'));
+    const configReviewerName = state.reviewer === 'openai' ? 'OpenAI (GPT-4o)' : state.reviewer === 'grok' ? 'Grok' : 'Gemini';
+    const configArbitratorName = state.arbitrator === 'openai' ? 'OpenAI' : state.arbitrator === 'grok' ? 'Grok' : 'Gemini';
+    console.log(`    ${theme.dim('Reviewer:')}   ${theme.primary(configReviewerName)}`);
+    console.log(`    ${theme.dim('Arbitrator:')} ${state.enableArbitration ? theme.primary(configArbitratorName) : theme.dim('Disabled')}`);
     console.log();
     console.log(theme.primary.bold('  Consensus:'));
-    console.log(`    ${theme.dim('Threshold:')} ${config.consensus.threshold}%`);
-    console.log(`    ${theme.dim('Max Iterations:')} ${config.consensus.max_disagreements}`);
+    console.log(`    ${theme.dim('Threshold:')}  ${config.consensus.threshold}%`);
+    console.log(`    ${theme.dim('Max Iters:')}  ${config.consensus.max_disagreements}`);
+    console.log();
+    console.log(theme.secondary('  Change settings:'));
+    console.log(theme.dim('    /config reviewer <openai|gemini|grok>'));
+    console.log(theme.dim('    /config arbitrator <openai|gemini|grok|off>'));
+    console.log(theme.dim('    /config language <python|typescript|fullstack>'));
     console.log();
 }
 /**
@@ -297,12 +934,22 @@ function handleLanguage(args, state) {
     if (args.length === 0) {
         console.log();
         printKeyValue('Current language', state.language);
-        printInfo('Use /language <python|typescript> to change');
+        printInfo('Use /language <py|ts|fs> or <python|typescript|fullstack> to change');
         return;
     }
-    const lang = args[0].toLowerCase();
-    if (!['python', 'typescript'].includes(lang)) {
-        printError('Invalid language. Use: python or typescript');
+    // Map shortcuts to full language names
+    const langAliases = {
+        'py': 'python',
+        'python': 'python',
+        'ts': 'typescript',
+        'typescript': 'typescript',
+        'fs': 'fullstack',
+        'fullstack': 'fullstack',
+    };
+    const input = args[0].toLowerCase();
+    const lang = langAliases[input];
+    if (!lang) {
+        printError('Invalid language. Use: py, ts, fs (or python, typescript, fullstack)');
         return;
     }
     state.language = lang;
@@ -329,43 +976,655 @@ function handleModel(args, state) {
     console.log();
     printSuccess(`Model set to ${model}`);
 }
+/**
+ * Prompt for additional context
+ * Uses terminal: false to prevent echo issues when nested with main readline
+ */
+async function promptForContext(prompt) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: false, // Prevent terminal mode to avoid echo issues
+        });
+        console.log();
+        console.log(theme.primary(`  ${prompt}`));
+        console.log(theme.dim('  (Press Enter to skip, or type your guidance)'));
+        console.log();
+        process.stdout.write('  > ');
+        rl.once('line', (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+/**
+ * Discover project context from docs/ and codebase
+ */
+async function discoverProjectContext(projectDir) {
+    const result = {
+        found: false,
+        hasCode: false,
+        codeFiles: [],
+    };
+    const docsDir = path.join(projectDir, 'docs');
+    // Try to read plan files
+    const planFiles = ['PLAN.md', 'PLAN-DRAFT.md'];
+    for (const planFile of planFiles) {
+        try {
+            const planPath = path.join(docsDir, planFile);
+            const content = await fs.readFile(planPath, 'utf-8');
+            result.plan = content;
+            result.planFile = planFile;
+            result.found = true;
+            // Try to extract project name from plan
+            const nameMatch = content.match(/^#\s*(?:Development Plan|Project):\s*(.+)$/mi) ||
+                content.match(/^#\s*(.+)$/m);
+            if (nameMatch) {
+                result.name = nameMatch[1].replace(/Development Plan/i, '').trim();
+            }
+            // Try to extract idea/overview from plan
+            const overviewMatch = content.match(/(?:Overview|Summary|Description)[:\s]*\n+([\s\S]*?)(?=\n#|\n\*\*|$)/i);
+            if (overviewMatch) {
+                result.idea = overviewMatch[1].trim().slice(0, 500);
+            }
+            break;
+        }
+        catch {
+            // File doesn't exist, continue
+        }
+    }
+    // Try to read README
+    try {
+        const readmePath = path.join(projectDir, 'README.md');
+        const content = await fs.readFile(readmePath, 'utf-8');
+        result.readme = content;
+        result.found = true;
+        // Extract project name from README if not already found
+        if (!result.name) {
+            const nameMatch = content.match(/^#\s*(.+)$/m);
+            if (nameMatch) {
+                result.name = nameMatch[1].trim();
+            }
+        }
+        // Extract idea from README if not found in plan
+        if (!result.idea) {
+            const lines = content.split('\n').slice(1, 10).join('\n').trim();
+            if (lines.length > 20) {
+                result.idea = lines.slice(0, 500);
+            }
+        }
+    }
+    catch {
+        // README doesn't exist
+    }
+    // Scan for code files to detect language
+    try {
+        const files = await fs.readdir(projectDir, { recursive: true });
+        const codeExtensions = {
+            python: ['.py'],
+            typescript: ['.ts', '.tsx', '.js', '.jsx'],
+        };
+        let pyCount = 0;
+        let tsCount = 0;
+        for (const file of files) {
+            const fileName = String(file);
+            if (fileName.includes('node_modules') || fileName.includes('.git') || fileName.includes('__pycache__')) {
+                continue;
+            }
+            if (codeExtensions.python.some(ext => fileName.endsWith(ext))) {
+                pyCount++;
+                result.codeFiles.push(fileName);
+            }
+            if (codeExtensions.typescript.some(ext => fileName.endsWith(ext))) {
+                tsCount++;
+                result.codeFiles.push(fileName);
+            }
+        }
+        result.hasCode = result.codeFiles.length > 0;
+        // Determine language from code files
+        if (pyCount > tsCount) {
+            result.language = 'python';
+        }
+        else if (tsCount > 0) {
+            result.language = 'typescript';
+        }
+    }
+    catch {
+        // Can't read directory
+    }
+    return result;
+}
 /**
  * Handle /resume command
  */
-async function handleResume(state) {
+async function handleResume(state, args) {
+    if (!state.claudeAuth || !state.openaiAuth) {
+        printError('Authentication required. Run /auth first.');
+        return;
+    }
+    // Discover all projects (registered + scanned in current directory)
+    console.log();
+    printInfo('Scanning for projects...');
+    const { all: allProjects } = await discoverProjects(state.projectDir || process.cwd());
+    // If projects found, let user select one
+    if (allProjects.length > 0) {
+        console.log();
+        console.log(theme.primary.bold('  Found Projects:'));
+        console.log();
+        // Show project list with numbers
+        const displayProjects = allProjects.slice(0, 10); // Limit to 10
+        for (let i = 0; i < displayProjects.length; i++) {
+            const project = displayProjects[i];
+            const info = formatProjectForDisplay(project);
+            const statusColor = project.status === 'complete' ? theme.success :
+                project.status === 'failed' ? theme.error :
+                    project.status === 'in-progress' ? theme.warning : theme.dim;
+            console.log(`    ${theme.primary(`${i + 1}.`)} ${theme.secondary(info.name)}`);
+            console.log(`       ${statusColor(info.status)} ${theme.dim('|')} ${info.age}`);
+            console.log(`       ${theme.dim(info.path)}`);
+            if (project.idea) {
+                console.log(`       ${theme.dim(project.idea.slice(0, 60))}${project.idea.length > 60 ? '...' : ''}`);
+            }
+            console.log();
+        }
+        if (allProjects.length > 10) {
+            console.log(theme.dim(`    ... and ${allProjects.length - 10} more projects`));
+            console.log();
+        }
+        // Let user select
+        const selection = await promptSelection('Select a project to resume:', [
+            ...displayProjects.map((p, i) => ({
+                value: String(i),
+                label: `${p.name} (${formatProjectForDisplay(p).age})`,
+            })),
+            { value: 'scan', label: 'Scan for more projects...' },
+            { value: 'cancel', label: 'Cancel' },
+        ], '0');
+        if (selection === 'cancel') {
+            printInfo('Cancelled');
+            return;
+        }
+        if (selection === 'scan') {
+            // Scan deeper in current directory
+            printInfo('Scanning subdirectories...');
+            const { all: deepScan } = await discoverProjects(state.projectDir || process.cwd());
+            if (deepScan.length === allProjects.length) {
+                printWarning('No additional projects found');
+            }
+            else {
+                printSuccess(`Found ${deepScan.length - allProjects.length} additional projects`);
+            }
+            // Recursively call handleResume to show updated list
+            await handleResume(state, args);
+            return;
+        }
+        const selectedIndex = parseInt(selection, 10);
+        const selectedProject = displayProjects[selectedIndex];
+        if (!selectedProject) {
+            printError('Invalid selection');
+            return;
+        }
+        // Set the project directory and continue
+        state.projectDir = selectedProject.path;
+        console.log();
+        printInfo(`Selected: ${selectedProject.name}`);
+    }
+    // Now check for formal project state at the selected/current directory
     if (!state.projectDir) {
         printError('No project directory set');
         return;
     }
-    if (!state.claudeAuth || !state.openaiAuth) {
-        printError('Authentication required. Run /auth first.');
-        return;
+    // Check for popeye.md and load project-specific configuration
+    const popeyeConfig = await readPopeyeConfig(state.projectDir);
+    if (popeyeConfig) {
+        applyPopeyeConfig(state, popeyeConfig);
+        await updatePopeyeLastRun(state.projectDir);
+        printInfo(`Loaded config from popeye.md (${popeyeConfig.language}, reviewer: ${popeyeConfig.reviewer})`);
     }
     const status = await getWorkflowStatus(state.projectDir);
-    if (!status.exists) {
-        printError('No project found to resume');
+    if (status.exists && status.state) {
+        // Formal project state exists - analyze actual progress before resuming
+        // Update session state to reflect project's language (preserves language on resume)
+        state.language = status.state.language;
+        // Get detailed progress analysis
+        const progressAnalysis = await analyzeProjectProgress(state.projectDir);
+        const verification = await verifyProjectCompletion(state.projectDir);
+        console.log();
+        console.log(theme.primary.bold('  Project Status:'));
+        console.log(`    ${theme.dim('Name:')}      ${status.state.name}`);
+        console.log(`    ${theme.dim('Language:')}  ${theme.primary(status.state.language)}`);
+        console.log(`    ${theme.dim('Phase:')}     ${theme.primary(status.state.phase)}`);
+        console.log(`    ${theme.dim('Status:')}    ${status.state.status}`);
+        // Show detailed progress comparison
+        console.log();
+        console.log(theme.primary.bold('  Progress Analysis:'));
+        console.log(`    ${theme.dim('Milestones:')} ${progressAnalysis.completedMilestones}/${progressAnalysis.totalMilestones} complete`);
+        console.log(`    ${theme.dim('Tasks:')}      ${progressAnalysis.completedTasks}/${progressAnalysis.totalTasks} complete (${progressAnalysis.percentComplete}%)`);
+        if (progressAnalysis.inProgressTasks > 0) {
+            console.log(`    ${theme.dim('In Progress:')} ${theme.warning(String(progressAnalysis.inProgressTasks))} task(s)`);
+        }
+        if (progressAnalysis.failedTasks > 0) {
+            console.log(`    ${theme.dim('Failed:')}     ${theme.error(String(progressAnalysis.failedTasks))} task(s)`);
+        }
+        if (progressAnalysis.pendingTasks > 0) {
+            console.log(`    ${theme.dim('Pending:')}    ${progressAnalysis.pendingTasks} task(s)`);
+        }
+        // Show plan file comparison
+        if (progressAnalysis.planTaskCount > 0) {
+            console.log();
+            console.log(theme.primary.bold('  Plan Comparison (from docs/PLAN.md):'));
+            console.log(`    ${theme.dim('Plan Tasks:')}   ${progressAnalysis.planTaskCount} tasks found in plan`);
+            console.log(`    ${theme.dim('State Tasks:')}  ${progressAnalysis.totalTasks} tasks in state`);
+            // Show plan mismatch warning (critical - plan has more tasks than state)
+            if (progressAnalysis.planMismatch) {
+                console.log();
+                console.log(theme.error.bold('  CRITICAL: Plan Mismatch Detected!'));
+                console.log(theme.error(`    The plan file has ${progressAnalysis.planTaskCount} tasks but state only has ${progressAnalysis.totalTasks}.`));
+                console.log(theme.error(`    This means the plan was not fully parsed into tasks.`));
+                console.log(theme.error(`    True progress: ${progressAnalysis.completedTasks}/${progressAnalysis.planTaskCount} tasks (${progressAnalysis.percentComplete}%)`));
+                // Show some missing tasks
+                if (progressAnalysis.missingFromState.length > 0) {
+                    console.log();
+                    console.log(theme.warning('  Tasks in plan but missing from state:'));
+                    for (const task of progressAnalysis.missingFromState.slice(0, 8)) {
+                        console.log(`    ${theme.dim('-')} ${task.slice(0, 70)}${task.length > 70 ? '...' : ''}`);
+                    }
+                    if (progressAnalysis.missingFromState.length > 8) {
+                        console.log(`    ${theme.dim(`... and ${progressAnalysis.missingFromState.length - 8} more tasks`)}`);
+                    }
+                }
+                console.log();
+                console.log(theme.secondary('    The plan needs to be re-parsed to capture all tasks.'));
+                console.log(theme.secondary('    Consider running the workflow again or manually adding tasks.'));
+            }
+        }
+        else if (progressAnalysis.planParseError) {
+            console.log();
+            console.log(theme.dim(`  Plan file: ${progressAnalysis.planParseError}`));
+        }
+        // Check for status mismatch (status says complete but state tasks are incomplete)
+        if (progressAnalysis.statusMismatch && !progressAnalysis.planMismatch) {
+            console.log();
+            console.log(theme.warning.bold('  WARNING: Status Mismatch Detected!'));
+            console.log(theme.warning(`    Project status says '${status.state.status}' but work is incomplete.`));
+            console.log(theme.warning(`    ${progressAnalysis.progressSummary}`));
+            console.log(theme.secondary('    Will reset status and continue execution.'));
+        }
+        // Show next items to work on
+        if (progressAnalysis.nextMilestone || progressAnalysis.nextTask) {
+            console.log();
+            console.log(theme.secondary('  Next Up:'));
+            if (progressAnalysis.nextMilestone) {
+                console.log(`    ${theme.dim('Milestone:')} ${progressAnalysis.nextMilestone.name}`);
+            }
+            if (progressAnalysis.nextTask) {
+                console.log(`    ${theme.dim('Task:')}      ${progressAnalysis.nextTask.name}`);
+            }
+        }
+        // Show incomplete milestones
+        if (progressAnalysis.incompleteMilestones.length > 0 && !verification.isComplete) {
+            console.log();
+            console.log(theme.secondary('  Remaining Milestones:'));
+            for (const m of progressAnalysis.incompleteMilestones.slice(0, 5)) {
+                console.log(`    ${theme.dim('-')} ${m.name} (${m.tasksRemaining} tasks remaining)`);
+            }
+            if (progressAnalysis.incompleteMilestones.length > 5) {
+                console.log(`    ${theme.dim(`... and ${progressAnalysis.incompleteMilestones.length - 5} more`)}`);
+            }
+        }
+        if (status.state.consensusHistory && status.state.consensusHistory.length > 0) {
+            const lastConsensus = status.state.consensusHistory[status.state.consensusHistory.length - 1];
+            console.log();
+            console.log(theme.secondary('  Consensus History:'));
+            console.log(`    ${theme.dim('Last Score:')} ${lastConsensus.result.score}%`);
+            console.log(`    ${theme.dim('Iterations:')} ${status.state.consensusHistory.length}`);
+            // Show last concerns
+            if (lastConsensus.result.concerns && lastConsensus.result.concerns.length > 0) {
+                console.log();
+                console.log(theme.secondary('  Last Concerns:'));
+                for (const concern of lastConsensus.result.concerns.slice(0, 3)) {
+                    console.log(`    ${theme.dim('-')} ${concern.slice(0, 80)}${concern.length > 80 ? '...' : ''}`);
+                }
+            }
+        }
+        if (status.state.error) {
+            console.log();
+            console.log(theme.error(`  Error: ${status.state.error}`));
+        }
+        // If project says complete but isn't, inform user we'll continue
+        if (verification.isComplete) {
+            console.log();
+            printSuccess('Project is fully complete!');
+            printInfo(`All ${progressAnalysis.totalTasks} tasks across ${progressAnalysis.totalMilestones} milestones are done.`);
+            return;
+        }
+        // Check if user provided context as argument
+        let additionalContext = args.join(' ').trim();
+        // If no context provided, ask if they want to add guidance
+        if (!additionalContext) {
+            console.log();
+            const wantsContext = await promptYesNo(theme.primary('Would you like to add guidance before resuming?'), false);
+            if (wantsContext) {
+                additionalContext = await promptForContext('What guidance would you like to give? (e.g., "Focus on simplicity", "Use SQLite instead of PostgreSQL")');
+            }
+        }
+        console.log();
+        printInfo('Resuming workflow...');
+        if (additionalContext) {
+            console.log(`    ${theme.dim('With guidance:')} ${additionalContext.slice(0, 60)}${additionalContext.length > 60 ? '...' : ''}`);
+        }
+        console.log();
+        const result = await resumeWorkflow(state.projectDir, {
+            consensusConfig: {
+                reviewer: state.reviewer,
+                arbitrator: state.arbitrator,
+                enableArbitration: state.enableArbitration,
+            },
+            additionalContext,
+            onProgress: (phase, message) => {
+                console.log(`  ${theme.dim(`[${phase}]`)} ${message}`);
+            },
+        });
+        console.log();
+        if (result.success) {
+            // Update README with project description on completion
+            await updateReadmeOnCompletion(state.projectDir, status.state.name, status.state.idea, status.state.language);
+            printSuccess('Workflow completed!');
+            console.log(`    ${theme.dim('Location:')} ${state.projectDir}`);
+        }
+        else {
+            printError(result.error || 'Workflow failed');
+            printInfo('You can run /resume again with additional guidance');
+        }
         return;
     }
+    // No formal project state - try to discover context from docs/
+    printInfo('No project state found in selected directory. Scanning for project context...');
+    console.log();
+    const discovered = await discoverProjectContext(state.projectDir);
+    if (!discovered.found) {
+        console.log(theme.secondary('  No project context found in this directory.'));
+        console.log();
+        console.log(theme.dim('  To start a new project, simply type your idea:'));
+        console.log(theme.dim('    Example: "Build a REST API for task management"'));
+        console.log();
+        console.log(theme.dim('  Or navigate to a directory with existing plans:'));
+        console.log(theme.dim('    - docs/PLAN.md or docs/PLAN-DRAFT.md'));
+        console.log(theme.dim('    - README.md'));
+        return;
+    }
+    // Show what we discovered
+    console.log(theme.primary.bold('  Discovered Project Context:'));
+    console.log();
+    if (discovered.name) {
+        console.log(`    ${theme.dim('Name:')}     ${discovered.name}`);
+    }
+    if (discovered.language) {
+        console.log(`    ${theme.dim('Language:')} ${theme.primary(discovered.language)}`);
+    }
+    if (discovered.planFile) {
+        console.log(`    ${theme.dim('Plan:')}     docs/${discovered.planFile}`);
+    }
+    if (discovered.hasCode) {
+        console.log(`    ${theme.dim('Code:')}     ${discovered.codeFiles.length} source files found`);
+    }
+    if (discovered.idea) {
+        console.log();
+        console.log(theme.secondary('  Project Overview:'));
+        const ideaLines = discovered.idea.split('\n').slice(0, 4);
+        for (const line of ideaLines) {
+            console.log(`    ${theme.dim(line.slice(0, 80))}`);
+        }
+        if (discovered.idea.split('\n').length > 4) {
+            console.log(theme.dim('    ...'));
+        }
+    }
+    if (discovered.plan) {
+        // Show plan summary
+        console.log();
+        console.log(theme.secondary('  Plan Summary:'));
+        const planLines = discovered.plan.split('\n').filter(l => l.trim().startsWith('#') || l.trim().startsWith('-')).slice(0, 8);
+        for (const line of planLines) {
+            console.log(`    ${theme.dim(line.slice(0, 80))}`);
+        }
+    }
+    console.log();
+    // Ask user what they want to do
+    const action = await promptSelection('What would you like to do?', [
+        { value: 'continue', label: 'Continue with this plan - use existing and continue development' },
+        { value: 'refine', label: 'Refine the plan - review and improve with consensus' },
+        { value: 'new', label: 'Start fresh - provide a new idea' },
+        { value: 'cancel', label: 'Cancel' },
+    ], 'continue');
+    if (action === 'cancel') {
+        printInfo('Cancelled');
+        return;
+    }
+    if (action === 'new') {
+        console.log();
+        printInfo('Type your project idea to start a new workflow');
+        return;
+    }
+    // Get additional context/guidance
+    let additionalContext = args.join(' ').trim();
+    if (!additionalContext && action === 'refine') {
+        additionalContext = await promptForContext('What changes or improvements would you like? (e.g., "Add authentication", "Simplify the architecture")');
+    }
+    else if (!additionalContext) {
+        console.log();
+        const wantsContext = await promptYesNo(theme.primary('Would you like to add any guidance?'), false);
+        if (wantsContext) {
+            additionalContext = await promptForContext('What guidance would you like to give?');
+        }
+    }
+    // Create project spec from discovered context
+    const projectName = discovered.name ||
+        path.basename(state.projectDir)
+            .toLowerCase()
+            .replace(/[^a-z0-9]/g, '-')
+            .substring(0, 30) ||
+        'my-project';
+    const spec = {
+        idea: discovered.idea || discovered.plan?.slice(0, 500) || `Continue developing ${projectName}`,
+        name: projectName,
+        language: discovered.language || state.language,
+        openaiModel: state.model,
+        outputDir: state.projectDir,
+    };
     console.log();
-    printInfo('Resuming workflow...');
+    printInfo(`Starting workflow for "${projectName}"...`);
+    if (additionalContext) {
+        console.log(`    ${theme.dim('With guidance:')} ${additionalContext.slice(0, 60)}${additionalContext.length > 60 ? '...' : ''}`);
+    }
     console.log();
-    const result = await resumeWorkflow(state.projectDir, {
+    // Run the workflow
+    const result = await runWorkflow(spec, {
+        projectDir: state.projectDir,
+        consensusConfig: {
+            reviewer: state.reviewer,
+            arbitrator: state.arbitrator,
+            enableArbitration: state.enableArbitration,
+        },
         onProgress: (phase, message) => {
             console.log(`  ${theme.dim(`[${phase}]`)} ${message}`);
         },
     });
     console.log();
     if (result.success) {
+        // Update README with project description on completion
+        if (state.projectDir) {
+            await updateReadmeOnCompletion(state.projectDir, spec.name || 'my-project', spec.idea, spec.language);
+        }
         printSuccess('Workflow completed!');
+        console.log(`    ${theme.dim('Location:')} ${state.projectDir}`);
     }
     else {
         printError(result.error || 'Workflow failed');
+        printInfo('You can run /resume again with additional guidance');
+    }
+}
+/**
+ * Generate a meaningful project name from an idea
+ * Extracts key nouns and creates a kebab-case name
+ */
+function generateProjectName(idea) {
+    // 1. First, try to find explicit project name patterns
+    const explicitPatterns = [
+        /(?:called|named|for|planning|project)\s+["']?([A-Z][a-zA-Z0-9]+)["']?/i,
+        /["']([A-Z][a-zA-Z0-9]+)["']/, // Quoted names
+        /\b([A-Z][a-z]+(?:[A-Z][a-z]+)+)\b/, // CamelCase names like "TodoMaster"
+    ];
+    for (const pattern of explicitPatterns) {
+        const match = idea.match(pattern);
+        if (match && match[1] && match[1].length >= 3 && match[1].length <= 30) {
+            // Convert to kebab-case
+            return match[1]
+                .replace(/([a-z])([A-Z])/g, '$1-$2')
+                .toLowerCase()
+                .replace(/[^a-z0-9-]/g, '-')
+                .replace(/-+/g, '-')
+                .replace(/^-|-$/g, '');
+        }
+    }
+    // 2. Look for standalone capitalized words (potential project names)
+    // Exclude common capitalized words at sentence start
+    const capitalizedWords = idea.match(/\b([A-Z][a-z]{2,})\b/g) || [];
+    const excludeCapitalized = new Set([
+        'Build', 'Create', 'Make', 'Develop', 'Write', 'Implement', 'Design',
+        'Read', 'Start', 'Help', 'Please', 'Want', 'Need', 'Use', 'Add',
+        'The', 'This', 'That', 'What', 'When', 'Where', 'How', 'Why',
+    ]);
+    const projectNameCandidates = capitalizedWords.filter(w => !excludeCapitalized.has(w) && w.length >= 3);
+    if (projectNameCandidates.length > 0) {
+        // Use the first non-excluded capitalized word
+        return projectNameCandidates[0].toLowerCase();
+    }
+    // 3. Fall back to extracting meaningful words
+    const stopWords = new Set([
+        'a', 'an', 'the', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
+        'of', 'with', 'by', 'from', 'as', 'is', 'was', 'are', 'were', 'been',
+        'be', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+        'should', 'may', 'might', 'must', 'shall', 'can', 'need', 'dare', 'ought',
+        'used', 'create', 'build', 'make', 'develop', 'write', 'implement',
+        'want', 'like', 'please', 'help', 'me', 'i', 'my', 'we', 'our', 'you',
+        'your', 'that', 'which', 'who', 'what', 'where', 'when', 'why', 'how',
+        'this', 'these', 'those', 'it', 'its', 'simple', 'basic', 'new',
+        // Action verbs that shouldn't be project names
+        'read', 'start', 'planning', 'reading', 'starting', 'begin', 'beginning',
+        'all', 'files', 'file', 'directory', 'folder', 'also',
+    ]);
+    // Extract meaningful words
+    const words = idea
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, ' ')
+        .split(/\s+/)
+        .filter(word => word.length > 2 && !stopWords.has(word));
+    // Take first 2-3 meaningful words
+    const nameWords = words.slice(0, 3);
+    if (nameWords.length === 0) {
+        // Fallback: use first words from original idea
+        const fallback = idea
+            .toLowerCase()
+            .replace(/[^a-z0-9\s]/g, '')
+            .split(/\s+/)
+            .filter(w => w.length > 0)
+            .slice(0, 2);
+        return fallback.join('-') || 'my-project';
+    }
+    return nameWords.join('-').substring(0, 40);
+}
+/**
+ * Update README.md with project description and usage instructions
+ */
+async function updateReadmeOnCompletion(projectDir, projectName, idea, language) {
+    const readmePath = path.join(projectDir, 'README.md');
+    try {
+        // Read existing README
+        let content = await fs.readFile(readmePath, 'utf-8');
+        // Check if it still has the placeholder description
+        if (content.includes('Generated by Popeye CLI')) {
+            // Generate a better description based on the idea
+            const description = `${idea}\n\nThis project was automatically generated and implemented using [Popeye CLI](https://github.com/popeye-cli).`;
+            // Replace the placeholder
+            content = content.replace(/Generated by Popeye CLI/g, description);
+            // Add a "Getting Started" section if it doesn't exist
+            if (!content.includes('## Getting Started')) {
+                const gettingStarted = language === 'python'
+                    ? `
+## Getting Started
+
+1. Create and activate a virtual environment:
+   \`\`\`bash
+   python -m venv venv
+   source venv/bin/activate  # On Windows: venv\\Scripts\\activate
+   \`\`\`
+
+2. Install dependencies:
+   \`\`\`bash
+   pip install -e ".[dev]"
+   \`\`\`
+
+3. Run the application:
+   \`\`\`bash
+   python -m src.${projectName.replace(/-/g, '_')}.main
+   \`\`\`
+`
+                    : `
+## Getting Started
+
+1. Install dependencies:
+   \`\`\`bash
+   npm install
+   \`\`\`
+
+2. Build the project:
+   \`\`\`bash
+   npm run build
+   \`\`\`
+
+3. Run the application:
+   \`\`\`bash
+   npm start
+   \`\`\`
+`;
+                // Insert before "## Development" or at the end
+                if (content.includes('## Development')) {
+                    content = content.replace('## Development', gettingStarted + '\n## Development');
+                }
+                else {
+                    content += gettingStarted;
+                }
+            }
+            await fs.writeFile(readmePath, content, 'utf-8');
+        }
+    }
+    catch {
+        // Silently ignore if README doesn't exist or can't be updated
     }
 }
 /**
  * Handle project idea input
  */
 async function handleIdea(idea, state) {
+    const cwd = state.projectDir || process.cwd();
+    // Check for existing Popeye projects in the current directory
+    const { all: existingProjects } = await discoverProjects(cwd);
+    const localProjects = existingProjects.filter(p => p.path.startsWith(cwd));
+    if (localProjects.length > 0) {
+        console.log();
+        printWarning('Existing Popeye projects found in this directory:');
+        console.log();
+        for (const project of localProjects.slice(0, 5)) {
+            const display = formatProjectForDisplay(project);
+            console.log(`    ${theme.primary(display.name)} ${theme.dim(`(${display.age})`)}`);
+            console.log(`    ${theme.dim(display.status)} - ${theme.dim(project.path)}`);
+            console.log();
+        }
+        printInfo('Consider running /resume to continue an existing project.');
+        printInfo('To start a new project anyway, run: /new ' + idea);
+        return;
+    }
     if (!state.claudeAuth || !state.openaiAuth) {
         console.log();
         printError('Authentication required');
@@ -377,44 +1636,60 @@ async function handleIdea(idea, state) {
             return;
         }
     }
+    // Generate a meaningful project name
+    const projectName = generateProjectName(idea);
+    const projectDir = path.join(cwd, projectName);
     console.log();
     console.log(theme.primary.bold('  Creating Project'));
     console.log(`    ${theme.dim('Idea:')} ${idea}`);
+    console.log(`    ${theme.dim('Name:')} ${theme.primary(projectName)}`);
     console.log(`    ${theme.dim('Language:')} ${theme.primary(state.language)}`);
     console.log(`    ${theme.dim('Model:')} ${theme.secondary(state.model)}`);
     console.log();
-    // Generate project name from idea
-    const projectName = idea
-        .toLowerCase()
-        .replace(/[^a-z0-9\s]/g, '')
-        .split(/\s+/)
-        .slice(0, 3)
-        .join('-')
-        .substring(0, 30) || 'my-project';
-    const path = await import('node:path');
-    const projectDir = path.join(state.projectDir || process.cwd(), projectName);
     const spec = {
         idea,
         name: projectName,
         language: state.language,
         openaiModel: state.model,
-        outputDir: state.projectDir || process.cwd(),
+        outputDir: cwd,
     };
     // Generate scaffold
     startSpinner('Creating project structure...');
-    const scaffoldResult = await generateProject(spec, state.projectDir || process.cwd());
+    const scaffoldResult = await generateProject(spec, cwd);
     if (!scaffoldResult.success) {
         failSpinner('Scaffolding failed');
         printError(scaffoldResult.error || 'Failed to create project');
         return;
     }
     succeedSpinner(`Created ${scaffoldResult.filesCreated.length} files`);
-    // Run workflow
+    // Create popeye.md with project configuration
+    await writePopeyeConfig(projectDir, {
+        language: state.language,
+        reviewer: state.reviewer,
+        arbitrator: state.arbitrator,
+        enableArbitration: state.enableArbitration,
+        created: new Date().toISOString(),
+        lastRun: new Date().toISOString(),
+        projectName,
+        description: idea,
+    });
+    printInfo('Created popeye.md with project configuration');
+    // Run workflow with reviewer/arbitrator settings
     console.log();
     printInfo('Starting AI workflow...');
+    console.log(`    ${theme.dim('Reviewer:')} ${theme.primary(state.reviewer)}`);
+    if (state.enableArbitration) {
+        console.log(`    ${theme.dim('Arbitrator:')} ${theme.primary(state.arbitrator)}`);
+    }
     console.log();
     const workflowResult = await runWorkflow(spec, {
         projectDir,
+        consensusConfig: {
+            reviewer: state.reviewer,
+            arbitrator: state.arbitrator,
+            enableArbitration: state.enableArbitration,
+            geminiModel: state.geminiModel,
+        },
         onProgress: (phase, message) => {
             console.log(`  ${theme.dim(`[${phase}]`)} ${message}`);
         },
@@ -422,6 +1697,95 @@ async function handleIdea(idea, state) {
     stopSpinner();
     console.log();
     if (workflowResult.success) {
+        // Update README with project description
+        await updateReadmeOnCompletion(projectDir, projectName, idea, state.language);
+        printSuccess('Project created successfully!');
+        console.log(`    ${theme.dim('Location:')} ${projectDir}`);
+        state.projectDir = projectDir;
+    }
+    else {
+        printError(workflowResult.error || 'Workflow failed');
+    }
+}
+/**
+ * Handle /new command - force create a new project (skips existing project check)
+ */
+async function handleNewProject(idea, state) {
+    if (!state.claudeAuth || !state.openaiAuth) {
+        console.log();
+        printError('Authentication required');
+        printInfo('Running authentication flow...');
+        console.log();
+        const authenticated = await ensureAuthentication(state);
+        if (!authenticated) {
+            printWarning('Skipping project creation - authentication incomplete');
+            return;
+        }
+    }
+    const cwd = state.projectDir || process.cwd();
+    // Generate a meaningful project name
+    const projectName = generateProjectName(idea);
+    const projectDir = path.join(cwd, projectName);
+    console.log();
+    console.log(theme.primary.bold('  Creating New Project'));
+    console.log(`    ${theme.dim('Idea:')} ${idea}`);
+    console.log(`    ${theme.dim('Name:')} ${theme.primary(projectName)}`);
+    console.log(`    ${theme.dim('Language:')} ${theme.primary(state.language)}`);
+    console.log(`    ${theme.dim('Model:')} ${theme.secondary(state.model)}`);
+    console.log();
+    const spec = {
+        idea,
+        name: projectName,
+        language: state.language,
+        openaiModel: state.model,
+        outputDir: cwd,
+    };
+    // Generate scaffold
+    startSpinner('Creating project structure...');
+    const scaffoldResult = await generateProject(spec, cwd);
+    if (!scaffoldResult.success) {
+        failSpinner('Scaffolding failed');
+        printError(scaffoldResult.error || 'Failed to create project');
+        return;
+    }
+    succeedSpinner(`Created ${scaffoldResult.filesCreated.length} files`);
+    // Create popeye.md with project configuration
+    await writePopeyeConfig(projectDir, {
+        language: state.language,
+        reviewer: state.reviewer,
+        arbitrator: state.arbitrator,
+        enableArbitration: state.enableArbitration,
+        created: new Date().toISOString(),
+        lastRun: new Date().toISOString(),
+        projectName,
+        description: idea,
+    });
+    printInfo('Created popeye.md with project configuration');
+    // Run workflow with reviewer/arbitrator settings
+    console.log();
+    printInfo('Starting AI workflow...');
+    console.log(`    ${theme.dim('Reviewer:')} ${theme.primary(state.reviewer)}`);
+    if (state.enableArbitration) {
+        console.log(`    ${theme.dim('Arbitrator:')} ${theme.primary(state.arbitrator)}`);
+    }
+    console.log();
+    const workflowResult = await runWorkflow(spec, {
+        projectDir,
+        consensusConfig: {
+            reviewer: state.reviewer,
+            arbitrator: state.arbitrator,
+            enableArbitration: state.enableArbitration,
+            geminiModel: state.geminiModel,
+        },
+        onProgress: (phase, message) => {
+            console.log(`  ${theme.dim(`[${phase}]`)} ${message}`);
+        },
+    });
+    stopSpinner();
+    console.log();
+    if (workflowResult.success) {
+        // Update README with project description
+        await updateReadmeOnCompletion(projectDir, projectName, idea, state.language);
         printSuccess('Project created successfully!');
         console.log(`    ${theme.dim('Location:')} ${projectDir}`);
         state.projectDir = projectDir;
@@ -435,18 +1799,34 @@ async function handleIdea(idea, state) {
  */
 export async function startInteractiveMode() {
     console.clear();
-    // Initialize state
+    // Initialize state from saved config
     const config = await loadConfig();
     const state = {
         projectDir: process.cwd(),
         language: config.project.default_language,
         model: config.apis.openai.model,
+        geminiModel: 'gemini-2.0-flash',
         claudeAuth: false,
         openaiAuth: false,
+        geminiAuth: false,
+        grokAuth: false,
+        // Load saved reviewer/arbitrator settings from config
+        reviewer: config.consensus.reviewer,
+        arbitrator: config.consensus.arbitrator === 'off' ? 'openai' : config.consensus.arbitrator,
+        enableArbitration: config.consensus.enable_arbitration,
     };
     // Draw header
     drawHeader();
     console.log();
+    // Show how Popeye works
+    console.log(theme.secondary('  How Popeye works:'));
+    console.log(theme.dim('  ├─ ') + theme.primary('Claude Code CLI') + theme.dim(' - Generates code (uses your model & MCP settings)'));
+    console.log(theme.dim('  ├─ ') + theme.secondary('Reviewer (configurable)') + theme.dim(' - Reviews plans until consensus'));
+    console.log(theme.dim('  └─ ') + theme.secondary('Arbitrator (optional)') + theme.dim(' - Breaks deadlocks when stuck'));
+    console.log();
+    console.log(theme.dim('  You can choose OpenAI, Gemini, or Grok as reviewer/arbitrator during setup.'));
+    console.log(theme.dim('  Plans are saved to docs/ folder in markdown format.'));
+    console.log();
     // Check and perform authentication
     const isAuthenticated = await ensureAuthentication(state);
     if (!isAuthenticated) {
@@ -466,10 +1846,10 @@ export async function startInteractiveMode() {
     });
     // Input loop
     const promptUser = () => {
-        drawInputFrame(state);
+        drawInputBoxTop(state);
         rl.question(getPrompt(), async (input) => {
-            // Clear the input frame line
-            process.stdout.write('\x1b[1A\x1b[2K'); // Move up and clear
+            // Draw bottom of input box after user presses enter
+            drawInputBoxBottom();
             const shouldContinue = await handleInput(input, state);
             if (shouldContinue) {
                 console.log();