vibecodingmachine-cli 1.0.0

package/src/utils/interactive.js

@@ -0,0 +1,3616 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const boxen = require('boxen');
+const path = require('path');
+const os = require('os');
+const fs = require('fs-extra');
+const readline = require('readline');
+const repo = require('../commands/repo');
+const auto = require('../commands/auto');
+const status = require('../commands/status');
+const { getRepoPath, readConfig, writeConfig } = require('./config');
+const { getProviderPreferences, saveProviderPreferences, getProviderDefinitions } = require('../utils/provider-registry');
+const { checkAutoModeStatus } = require('./auto-mode');
+const {
+  checkVibeCodingMachineExists,
+  getHostname,
+  getRequirementsFilename,
+  requirementsExists,
+  isComputerNameEnabled
+} = require('@vibecodingmachine/core');
+
+/**
+ * Format IDE name for display
+ * @param {string} ide - Internal IDE identifier
+ * @returns {string} Display name for IDE
+ */
+function formatIDEName(ide) {
+  const ideNames = {
+    'claude-code': 'Claude Code CLI',
+    'aider': 'Aider CLI',
+    'continue': 'Continue CLI',
+    'cline': 'Cline CLI',
+    'cursor': 'Cursor',
+    'vscode': 'VS Code',
+    'windsurf': 'Windsurf'
+  };
+  return ideNames[ide] || ide;
+}
+
+/**
+ * Get current AI provider name for IDEs that require it (like Cline and Continue)
+ * @param {string} ide - Internal IDE identifier
+ * @returns {string|null} Provider name or null if not applicable/configured
+ */
+/**
+ * Get unified agent name (IDE or LLM-based)
+ * @param {string} agentType - Agent type (e.g., 'cursor', 'ollama', 'anthropic')
+ * @returns {string} - Display name like "Cursor IDE Agent" or "Ollama (qwen2.5-coder:32b)"
+ */
+function getAgentDisplayName(agentType) {
+  // IDE-based agents
+  if (agentType === 'cursor') return 'Cursor IDE Agent';
+  if (agentType === 'windsurf') return 'Windsurf IDE Agent';
+  if (agentType === 'antigravity') return 'Google Antigravity IDE Agent';
+  if (agentType === 'vscode') return 'VS Code IDE Agent';
+
+  // Claude Code CLI
+  if (agentType === 'claude-code') return 'Claude Code CLI';
+
+  // Direct LLM agents
+  if (agentType === 'ollama' || agentType === 'anthropic' || agentType === 'groq' || agentType === 'bedrock') {
+    try {
+      const fs = require('fs');
+      const path = require('path');
+      const os = require('os');
+      const configPath = path.join(os.homedir(), '.config', 'allnightai', 'config.json');
+      if (fs.existsSync(configPath)) {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        const model = config.auto?.llmModel || config.auto?.aiderModel || config.auto?.groqModel;
+
+        if (agentType === 'ollama' && model && !model.includes('groq/')) {
+          return `Ollama (${model})`;
+        } else if (agentType === 'anthropic') {
+          return 'Anthropic (Claude Sonnet 4)';
+        } else if (agentType === 'groq') {
+          // Extract model name from groq/model format
+          const groqModel = model && model.includes('groq/') ? model.split('/')[1] : 'llama-3.3-70b-versatile';
+          return `Groq (${groqModel})`;
+        } else if (agentType === 'bedrock') {
+          return 'AWS Bedrock (Claude)';
+        }
+      }
+    } catch (error) {
+      // Fallback to generic names
+    }
+
+    // Fallback names
+    if (agentType === 'ollama') return 'Ollama (Local)';
+    if (agentType === 'anthropic') return 'Anthropic (Claude)';
+    if (agentType === 'groq') return 'Groq (llama-3.3-70b-versatile)';
+    if (agentType === 'bedrock') return 'AWS Bedrock';
+  }
+
+  // Legacy support for old IDE names
+  return formatIDEName(agentType);
+}
+
+function getCurrentAIProvider(ide) {
+  // Aider, Cline, and Continue require AI provider configuration
+  if (ide !== 'aider' && ide !== 'cline' && ide !== 'continue') {
+    return null;
+  }
+
+  // Aider uses Ollama by default (or Bedrock if configured)
+  if (ide === 'aider') {
+    try {
+      const { getAutoConfig } = require('./config');
+      // Note: getAutoConfig is async, but this function is sync
+      // We'll use a sync read for now, or make this function async
+      const fs = require('fs');
+      const path = require('path');
+      const os = require('os');
+      const configPath = path.join(os.homedir(), '.config', 'allnightai', 'config.json');
+      if (fs.existsSync(configPath)) {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        const aiderModel = config.auto?.aiderModel;
+        if (aiderModel) {
+          return `Ollama (${aiderModel})`;
+        }
+      }
+      return 'Ollama';
+    } catch (error) {
+      return 'Ollama';
+    }
+  }
+
+  // Handle Continue CLI - read from Continue config
+  if (ide === 'continue') {
+    try {
+      const fs = require('fs');
+      const path = require('path');
+      const os = require('os');
+      const yaml = require('js-yaml');
+      const configPath = path.join(os.homedir(), '.continue', 'config.yaml');
+
+      if (!fs.existsSync(configPath)) {
+        return 'Not configured';
+      }
+
+      const config = yaml.load(fs.readFileSync(configPath, 'utf8'));
+      const models = config.models || [];
+
+      if (models.length === 0) {
+        return 'Not configured';
+      }
+
+      const firstModel = models[0];
+      if (firstModel.provider === 'ollama') {
+        return `Ollama (${firstModel.model || 'model configured'})`;
+      }
+
+      return firstModel.provider || 'Configured';
+    } catch (error) {
+      return 'Not configured';
+    }
+  }
+
+  try {
+    const { ClineCLIManager } = require('@vibecodingmachine/core');
+    const clineManager = new ClineCLIManager();
+
+    if (!clineManager.isConfigured()) {
+      return 'Not configured';
+    }
+
+    const fs = require('fs');
+    const path = require('path');
+    const os = require('os');
+    const configPath = path.join(os.homedir(), '.cline_cli', 'cline_cli_settings.json');
+
+    if (!fs.existsSync(configPath)) {
+      return 'Not configured';
+    }
+
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    const apiProvider = config.globalState?.apiProvider;
+    const openAiBaseUrl = config.globalState?.openAiBaseUrl;
+
+    if (!apiProvider) {
+      return 'Not configured';
+    }
+
+    // Map provider identifiers to display names
+    if (apiProvider === 'anthropic') {
+      return 'Anthropic Claude';
+    } else if (apiProvider === 'openrouter') {
+      return 'OpenRouter';
+    } else if (apiProvider === 'openai-native') {
+      if (openAiBaseUrl === 'http://localhost:11434/v1') {
+        return 'Ollama';
+      } else if (openAiBaseUrl?.includes('generativelanguage.googleapis.com')) {
+        return 'Google Gemini';
+      }
+      return 'OpenAI Native';
+    }
+
+    return apiProvider;
+  } catch (error) {
+    return 'Unknown';
+  }
+}
+
+function formatPath(fullPath) {
+  const homeDir = os.homedir();
+  if (fullPath.startsWith(homeDir)) {
+    return fullPath.replace(homeDir, '~');
+  }
+  return fullPath;
+}
+
+async function countRequirements() {
+  try {
+    const { getRequirementsPath, getVibeCodingMachineDir } = require('@vibecodingmachine/core');
+    const repoPath = await getRepoPath();
+    const reqPath = await getRequirementsPath(repoPath);
+
+    if (!reqPath || !await fs.pathExists(reqPath)) {
+      return null;
+    }
+
+    const content = await fs.readFile(reqPath, 'utf8');
+
+    // Count requirements in each section
+    let todoCount = 0;
+    let toVerifyCount = 0;
+    let verifiedCount = 0;
+
+    // Split by sections
+    const lines = content.split('\n');
+    let currentSection = '';
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+
+      // Check for requirement headers first (###), then section headers (##)
+      // This prevents ### from being treated as section headers
+      if (trimmed.startsWith('###')) {
+        // Count requirements (### headers in new format)
+        // IMPORTANT: Only count if we're in a recognized section
+        if (currentSection) {
+          const requirementText = trimmed.replace(/^###\s*/, '').trim();
+          if (requirementText) { // Only count if requirement text is not empty
+            if (currentSection === 'todo') {
+              todoCount++;
+            } else if (currentSection === 'toverify') {
+              toVerifyCount++;
+            }
+          }
+        }
+      } else if (trimmed.startsWith('##') && !trimmed.startsWith('###')) {
+        // Detect section headers (must start with ## but not ###)
+        if (trimmed.includes('⏳ Requirements not yet completed') ||
+          trimmed.includes('Requirements not yet completed')) {
+          currentSection = 'todo';
+        } else if (trimmed.includes('🔍 TO VERIFY BY HUMAN') ||
+          trimmed.includes('TO VERIFY BY HUMAN') ||
+          trimmed.includes('🔍 TO VERIFY') ||
+          trimmed.includes('TO VERIFY') ||
+          trimmed.includes('✅ Verified by AI') ||
+          trimmed.includes('Verified by AI')) {
+          currentSection = 'toverify';
+        } else {
+          // Any other section header clears the current section
+          currentSection = '';
+        }
+      }
+    }
+
+    // Count verified requirements from CHANGELOG.md (at repository root)
+    const allnightDir = await getVibeCodingMachineDir();
+    if (allnightDir) {
+      // CHANGELOG.md is at the repository root
+      // If .vibecodingmachine is inside repo: go up one level
+      // If .vibecodingmachine is sibling (../.vibecodingmachine-reponame): go up one level then into repo
+      let changelogPath;
+      const allnightStatus = await require('@vibecodingmachine/core').checkVibeCodingMachineExists();
+
+      if (allnightStatus.insideExists) {
+        // .vibecodingmachine is inside repo, so go up one level
+        changelogPath = path.join(path.dirname(allnightDir), 'CHANGELOG.md');
+      } else if (allnightStatus.siblingExists) {
+        // .vibecodingmachine is sibling, use current working directory
+        changelogPath = path.join(process.cwd(), 'CHANGELOG.md');
+      }
+
+      if (changelogPath && await fs.pathExists(changelogPath)) {
+        const changelogContent = await fs.readFile(changelogPath, 'utf8');
+        // Count entries that look like completed requirements
+        // Each entry typically starts with "- " followed by date/description
+        const changelogLines = changelogContent.split('\n');
+        for (const line of changelogLines) {
+          const trimmed = line.trim();
+          // Count lines that start with "- " and have substantial content (not just empty bullets)
+          if (trimmed.startsWith('- ') && trimmed.length > 10) {
+            verifiedCount++;
+          }
+        }
+      }
+    }
+
+    return { todoCount, toVerifyCount, verifiedCount };
+  } catch (error) {
+    return null;
+  }
+}
+
+async function getCurrentProgress() {
+  try {
+    const { getRequirementsPath } = require('@vibecodingmachine/core');
+    const reqPath = await getRequirementsPath();
+
+    if (!reqPath || !await fs.pathExists(reqPath)) {
+      return null;
+    }
+
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+
+    let requirement = null;
+    let inTodoSection = false;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      // Find TODO section
+      if (line.includes('## ⏳ Requirements not yet completed') || line.includes('## Requirements not yet completed')) {
+        inTodoSection = true;
+        continue;
+      }
+
+      // Exit TODO section when we hit another section
+      if (inTodoSection && line.trim().startsWith('##')) {
+        break;
+      }
+
+      // Find first TODO requirement
+      if (inTodoSection) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('- ') || trimmed.startsWith('* ')) {
+          requirement = trimmed.substring(2); // Remove "- " or "* " prefix
+          break;
+        }
+      }
+    }
+
+    return requirement ? { status: 'PREPARE', requirement } : null;
+  } catch (error) {
+    return null;
+  }
+}
+
+async function showWelcomeScreen() {
+  const repoPath = process.cwd(); // Always use current working directory
+  const autoStatus = await checkAutoModeStatus();
+  const allnightStatus = await checkVibeCodingMachineExists();
+  const hostname = getHostname();
+  const requirementsFilename = await getRequirementsFilename();
+  const useHostname = await isComputerNameEnabled();
+
+  // Get current IDE from config
+  const { getAutoConfig } = require('./config');
+  const autoConfig = await getAutoConfig();
+  const currentIDE = autoConfig.ide || autoStatus.ide || 'claude-code';
+
+  // Check for requirements file
+  const hasRequirements = await requirementsExists();
+  let requirementsLocation = '';
+
+  if (allnightStatus.insideExists) {
+    requirementsLocation = '.vibecodingmachine';
+  } else if (allnightStatus.siblingExists) {
+    requirementsLocation = path.basename(allnightStatus.siblingDir);
+  }
+
+  // Count requirements if file exists
+  const counts = hasRequirements ? await countRequirements() : null;
+
+  // Clear the screen
+  console.clear();
+
+  // Get version formatted like the UI: "v2025.10.30 4:15 PM MDT"
+  const pkg = require('../../package.json');
+  const buildDate = new Date(); // Using current date since we don't track install date in CLI
+  const year = buildDate.getFullYear();
+  const month = String(buildDate.getMonth() + 1).padStart(2, '0');
+  const day = String(buildDate.getDate()).padStart(2, '0');
+  const dateStr = `${year}.${month}.${day}`;
+  const timeStr = buildDate.toLocaleTimeString('en-US', {
+    hour: 'numeric',
+    minute: '2-digit',
+    hour12: true,
+    timeZoneName: 'short'
+  });
+  const version = `v${dateStr} ${timeStr}`;
+
+  // Display welcome banner with version
+  console.log('\n' + boxen(
+    chalk.bold.cyan('Vibe Coding Machine') + '\n' +
+    chalk.gray(version) + '\n' +
+    chalk.gray('Big Dreams + AI + VibeCodingMachine.com = Your money making apps'),
+    {
+      padding: 1,
+      margin: 0,
+      borderStyle: 'round',
+      borderColor: 'cyan'
+    }
+  ));
+
+  // Display repository and system info
+  console.log();
+  console.log(chalk.gray('Repo:                    '), formatPath(repoPath));
+  console.log(chalk.gray('Computer Name:           '), chalk.cyan(hostname));
+
+  // Display auto mode progress if running
+  if (autoStatus.running) {
+    console.log(chalk.gray('Chats:                   '), chalk.cyan(autoStatus.chatCount || 0));
+
+    // Get current status and requirement from REQUIREMENTS file
+    const progress = await getCurrentProgress();
+    if (progress) {
+      console.log();
+      // Display progress in a purple/magenta box similar to UI
+      const stageIcons = {
+        'PREPARE': '🔍',
+        'ACT': '⚡',
+        'CLEAN UP': '🧹',
+        'VERIFY': '✅',
+        'DONE': '🎉'
+      };
+      const icon = stageIcons[progress.status] || '⏳';
+      const statusColor = progress.status === 'DONE' ? chalk.green : chalk.magenta;
+
+      console.log(boxen(
+        statusColor.bold(`${icon} ${progress.status}`) + '\n' +
+        chalk.gray(progress.requirement ? progress.requirement.substring(0, 60) + (progress.requirement.length > 60 ? '...' : '') : 'No requirement'),
+        {
+          padding: { left: 1, right: 1, top: 0, bottom: 0 },
+          margin: 0,
+          borderStyle: 'round',
+          borderColor: 'magenta'
+        }
+      ));
+    }
+
+    // Display recent audit log entries
+    const { readAuditLog, getDateStr } = require('@vibecodingmachine/core');
+    const todayStr = getDateStr();
+    const entries = readAuditLog(todayStr);
+    if (entries && entries.length > 0) {
+      console.log();
+      console.log(chalk.gray.bold('Recent Activity:'));
+      // Show last 5 entries
+      const recentEntries = entries.slice(-5);
+      recentEntries.forEach(entry => {
+        const time = new Date(entry.timestamp).toLocaleTimeString('en-US', {
+          hour: 'numeric',
+          minute: '2-digit',
+          second: '2-digit',
+          hour12: true
+        });
+        const icon = entry.type === 'auto-mode-start' ? '▶️' :
+          entry.type === 'auto-mode-stop' ? '⏹️' :
+            entry.type === 'ide-message' ? '💬' : '•';
+        console.log(chalk.gray(`  ${time} ${icon}`), entry.message || '');
+      });
+    }
+  }
+
+  console.log();
+}
+
+// Helper to convert index to letter (0->a, 1->b, etc.)
+function indexToLetter(index) {
+  return String.fromCharCode(97 + index); // 97 is 'a'
+}
+
+// Tree-style requirements navigator
+async function showRequirementsTree() {
+  console.log(chalk.bold.cyan('\n📋 Requirements Navigator\n'));
+  console.log(chalk.gray('Use ↑/↓ to navigate, →/Enter/Space to expand, ←/ESC to collapse/go back\n'));
+
+  const tree = {
+    expanded: { root: true },
+    selected: 0,
+    items: []
+  };
+
+  // Build tree structure
+  const buildTree = () => {
+    tree.items = [];
+
+    // Root: Requirements
+    tree.items.push({ level: 0, type: 'root', label: '📋 Requirements', key: 'root' });
+
+    if (tree.expanded.root) {
+      tree.items.push({ level: 1, type: 'add', label: '➕ Add new requirement', key: 'add-one' });
+      tree.items.push({ level: 1, type: 'add', label: '➕ Add multiple requirements', key: 'add-many' });
+
+      // Calculate counts and percentages
+      const verifiedReqs = tree.verifiedReqs || [];
+      const verifyReqs = tree.verifyReqs || [];
+      const clarificationReqs = tree.clarificationReqs || [];
+      const todoReqs = tree.todoReqs || [];
+      const recycledReqs = tree.recycledReqs || [];
+      const total = verifiedReqs.length + verifyReqs.length + clarificationReqs.length + todoReqs.length + recycledReqs.length;
+
+      const verifiedPercent = total > 0 ? Math.round((verifiedReqs.length / total) * 100) : 0;
+      const verifyPercent = total > 0 ? Math.round((verifyReqs.length / total) * 100) : 0;
+      const clarificationPercent = total > 0 ? Math.round((clarificationReqs.length / total) * 100) : 0;
+      const todoPercent = total > 0 ? Math.round((todoReqs.length / total) * 100) : 0;
+      const recycledPercent = total > 0 ? Math.round((recycledReqs.length / total) * 100) : 0;
+
+      // VERIFIED section (first)
+      tree.items.push({ level: 1, type: 'section', label: `🎉 VERIFIED (${verifiedReqs.length} - ${verifiedPercent}%)`, key: 'verified' });
+
+      if (tree.expanded.verified) {
+        verifiedReqs.forEach((req, idx) => {
+          tree.items.push({ level: 2, type: 'verified', label: req, key: `verified-${idx}` });
+        });
+      }
+
+      // TO VERIFY section (second)
+      tree.items.push({ level: 1, type: 'section', label: `✅ TO VERIFY (${verifyReqs.length} - ${verifyPercent}%)`, key: 'verify', section: '✅ Verified by AI screenshot' });
+
+      if (tree.expanded.verify) {
+        verifyReqs.forEach((req, idx) => {
+          tree.items.push({ level: 2, type: 'requirement', label: req.title, key: `verify-${idx}`, req, sectionKey: 'verify' });
+        });
+      }
+
+      // NEEDING CLARIFICATION section (third)
+      tree.items.push({ level: 1, type: 'section', label: `❓ NEEDING CLARIFICATION (${clarificationReqs.length} - ${clarificationPercent}%)`, key: 'clarification', section: '❓ Requirements needing manual feedback' });
+
+      if (tree.expanded.clarification) {
+        clarificationReqs.forEach((req, idx) => {
+          tree.items.push({ level: 2, type: 'clarification', label: req.title, key: `clarification-${idx}`, req, sectionKey: 'clarification' });
+        });
+      }
+
+      // TODO section (fourth)
+      tree.items.push({ level: 1, type: 'section', label: `⏳ TODO (${todoReqs.length} - ${todoPercent}%)`, key: 'todo', section: '⏳ Requirements not yet completed' });
+
+      if (tree.expanded.todo) {
+        todoReqs.forEach((req, idx) => {
+          tree.items.push({ level: 2, type: 'requirement', label: req.title, key: `todo-${idx}`, req, sectionKey: 'todo' });
+        });
+      }
+
+      // RECYCLED section (last)
+      tree.items.push({ level: 1, type: 'section', label: `♻️ RECYCLED (${recycledReqs.length} - ${recycledPercent}%)`, key: 'recycled', section: '♻️ Recycled' });
+
+      if (tree.expanded.recycled) {
+        recycledReqs.forEach((req, idx) => {
+          tree.items.push({ level: 2, type: 'recycled', label: req.title, key: `recycled-${idx}`, req, sectionKey: 'recycled' });
+        });
+      }
+    }
+  };
+
+  // Load requirements for a section
+  const loadSection = async (sectionKey, sectionTitle) => {
+    const { getRequirementsPath } = require('@vibecodingmachine/core');
+    const reqPath = await getRequirementsPath();
+
+    if (!reqPath || !await fs.pathExists(reqPath)) {
+      return [];
+    }
+
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+
+    let inSection = false;
+    const requirements = [];
+
+    // For TO VERIFY section, check multiple possible section titles
+    const sectionTitles = sectionKey === 'verify'
+      ? ['🔍 TO VERIFY BY HUMAN', 'TO VERIFY BY HUMAN', '🔍 TO VERIFY', 'TO VERIFY', '✅ Verified by AI screenshot', 'Verified by AI screenshot']
+      : [sectionTitle];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      // Check if this line matches any of the section titles
+      if (sectionTitles.some(title => line.includes(title))) {
+        inSection = true;
+        continue;
+      }
+
+      if (inSection && line.startsWith('## ') && !line.startsWith('###') && !sectionTitles.some(title => line.includes(title))) {
+        break;
+      }
+
+      // Read requirements in new format (### header)
+      if (inSection && line.trim().startsWith('###')) {
+        const title = line.trim().replace(/^###\s*/, '');
+        const details = [];
+        let package = null;
+
+        // Read package and description
+        for (let j = i + 1; j < lines.length; j++) {
+          const nextLine = lines[j].trim();
+          // Stop if we hit another requirement or section
+          if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
+            break;
+          }
+          // Check for PACKAGE line
+          if (nextLine.startsWith('PACKAGE:')) {
+            package = nextLine.replace(/^PACKAGE:\s*/, '').trim();
+          } else if (nextLine && !nextLine.startsWith('PACKAGE:')) {
+            // Description line
+            details.push(nextLine);
+          }
+        }
+
+        requirements.push({ title, details, package, lineIndex: i });
+      }
+    }
+
+    return requirements;
+  };
+
+  // Load VERIFIED requirements from CHANGELOG
+  const loadVerified = async () => {
+    const { getVibeCodingMachineDir, checkVibeCodingMachineExists } = require('@vibecodingmachine/core');
+    const allnightStatus = await checkVibeCodingMachineExists();
+    let changelogPath;
+
+    if (allnightStatus.insideExists) {
+      const allnightDir = await getVibeCodingMachineDir();
+      changelogPath = path.join(path.dirname(allnightDir), 'CHANGELOG.md');
+    } else if (allnightStatus.siblingExists) {
+      changelogPath = path.join(process.cwd(), 'CHANGELOG.md');
+    }
+
+    if (!changelogPath || !await fs.pathExists(changelogPath)) {
+      return [];
+    }
+
+    const content = await fs.readFile(changelogPath, 'utf8');
+    const lines = content.split('\n');
+    const requirements = [];
+    let inVerifiedSection = false;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+
+      // Check for Verified Requirements section
+      if (trimmed.includes('## Verified Requirements')) {
+        inVerifiedSection = true;
+        continue;
+      }
+
+      // Exit section if we hit another ## header
+      if (inVerifiedSection && trimmed.startsWith('##') && !trimmed.includes('Verified Requirements')) {
+        break;
+      }
+
+      // Only collect items from within the Verified Requirements section
+      if (inVerifiedSection && trimmed.startsWith('- ') && trimmed.length > 10) {
+        requirements.push(trimmed.substring(2));
+      }
+    }
+
+    return requirements;
+  };
+
+  // Load clarification requirements with questions
+  const loadClarification = async () => {
+    const { getRequirementsPath } = require('@vibecodingmachine/core');
+    const reqPath = await getRequirementsPath();
+
+    if (!reqPath || !await fs.pathExists(reqPath)) {
+      return [];
+    }
+
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+
+    let inSection = false;
+    const requirements = [];
+    let currentReq = null;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      if (line.includes('❓ Requirements needing manual feedback')) {
+        inSection = true;
+        continue;
+      }
+
+      if (inSection && line.startsWith('##') && !line.includes('❓ Requirements needing manual feedback')) {
+        if (currentReq) requirements.push(currentReq);
+        break;
+      }
+
+      if (inSection && line.trim().startsWith('- ')) {
+        if (currentReq) requirements.push(currentReq);
+
+        const title = line.trim().substring(2);
+        currentReq = { title, questions: [], findings: null, lineIndex: i };
+      } else if (inSection && currentReq && line.trim()) {
+        // Check for AI findings section
+        if (line.trim().startsWith('**AI found in codebase:**')) {
+          continue; // Skip the header, capture next line as findings
+        } else if (!currentReq.findings && !line.trim().startsWith('**Clarifying questions:**') && !line.trim().match(/^\d+\./)) {
+          // This is the findings content (comes after "AI found in codebase:")
+          currentReq.findings = line.trim();
+        } else if (line.trim().startsWith('**Clarifying questions:**')) {
+          continue; // Skip the questions header
+        } else if (line.trim().match(/^\d+\./)) {
+          // This is a question
+          currentReq.questions.push({ question: line.trim(), response: null });
+        } else if (currentReq.questions.length > 0) {
+          // This might be a response to the last question
+          const lastQuestion = currentReq.questions[currentReq.questions.length - 1];
+          if (!lastQuestion.response) {
+            lastQuestion.response = line.trim();
+          }
+        }
+      }
+    }
+
+    if (currentReq) requirements.push(currentReq);
+    return requirements;
+  };
+
+  // Load all sections upfront to show counts immediately
+  tree.todoReqs = await loadSection('todo', '⏳ Requirements not yet completed');
+  tree.verifyReqs = await loadSection('verify', '✅ Verified by AI screenshot');
+  tree.clarificationReqs = await loadClarification();
+  tree.verifiedReqs = await loadVerified();
+  tree.recycledReqs = await loadSection('recycled', '♻️ Recycled');
+
+  let inTree = true;
+  buildTree();
+
+  while (inTree) {
+    console.clear();
+    console.log(chalk.bold.cyan('\n📋 Requirements Navigator\n'));
+    console.log(chalk.gray('Use ↑/↓ to navigate, ') + chalk.white('→/Enter') + chalk.gray(' to expand/view questions, ← to go back, ') + chalk.white('R') + chalk.gray(' to Remove, ') + chalk.white('J') + chalk.gray(' to move down, ') + chalk.white('K') + chalk.gray(' to move up, ') + chalk.white('U') + chalk.gray(' Promote (👍), ') + chalk.white('D') + chalk.gray(' Demote/Move to TODO (👎), ') + chalk.white('X/ESC') + chalk.gray(' to Exit.\n'));
+
+    // Safety check: ensure tree.selected is within bounds
+    if (tree.items.length === 0) {
+      console.log(chalk.yellow('No items to display.'));
+      console.log(chalk.gray('\nPress any key to return to main menu...'));
+      await new Promise((resolve) => {
+        process.stdin.once('keypress', () => resolve());
+      });
+      inTree = false;
+      continue;
+    }
+
+    if (tree.selected >= tree.items.length) {
+      tree.selected = tree.items.length - 1;
+    }
+
+    if (tree.selected < 0) {
+      tree.selected = 0;
+    }
+
+    // Calculate window for scrolling (show max 20 items at a time)
+    const maxVisible = 20;
+    let startIdx = 0;
+    let endIdx = tree.items.length;
+
+    if (tree.items.length > maxVisible) {
+      // Center the selected item in the window
+      startIdx = Math.max(0, tree.selected - Math.floor(maxVisible / 2));
+      endIdx = Math.min(tree.items.length, startIdx + maxVisible);
+
+      // Adjust if we're near the end
+      if (endIdx - startIdx < maxVisible) {
+        startIdx = Math.max(0, endIdx - maxVisible);
+      }
+    }
+
+    // Show indicator if there are items above
+    if (startIdx > 0) {
+      console.log(chalk.gray(`  ↑ ${startIdx} more above...`));
+    }
+
+    // Display visible tree items
+    for (let idx = startIdx; idx < endIdx; idx++) {
+      const item = tree.items[idx];
+      const indent = '  '.repeat(item.level);
+      const arrow = tree.expanded[item.key] ? '▼' : (item.type === 'section' ? '▶' : ' ');
+      const prefix = item.type === 'section' || item.type === 'root' ? arrow + ' ' : '  ';
+      const selected = idx === tree.selected ? chalk.cyan('❯ ') : '  ';
+
+      // Truncate long labels to fit terminal width (max 120 chars)
+      const maxLabelWidth = 120;
+      let label = item.label;
+      if (label.length > maxLabelWidth) {
+        label = label.substring(0, maxLabelWidth - 3) + '...';
+      }
+
+      console.log(selected + indent + prefix + (idx === tree.selected ? chalk.cyan(label) : chalk.gray(label)));
+    }
+
+    // Show indicator if there are items below
+    if (endIdx < tree.items.length) {
+      console.log(chalk.gray(`  ↓ ${tree.items.length - endIdx} more below...`));
+    }
+
+    console.log();
+
+    // Handle input
+    const key = await new Promise((resolve) => {
+      readline.emitKeypressEvents(process.stdin);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+      }
+
+      const handler = (str, key) => {
+        process.stdin.removeListener('keypress', handler);
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(false);
+        }
+        resolve(key);
+      };
+
+      process.stdin.on('keypress', handler);
+      process.stdin.resume();
+    });
+
+    if (!key) continue;
+
+    // Handle key presses
+    if (key.ctrl && key.name === 'c') {
+      // Ctrl+C always exits immediately
+      process.exit(0);
+    } else if (key.name === 'x' || key.name === 'escape') {
+      // X or ESC key - exit CLI with confirmation
+      await confirmAndExit();
+    } else if (key.name === 'left') {
+      const current = tree.items[tree.selected];
+      if (!current) continue; // Safety check
+
+      if (tree.expanded[current.key]) {
+        // Collapse expanded section
+        tree.expanded[current.key] = false;
+        buildTree();
+      } else if (current.level > 0) {
+        // Go to parent
+        for (let i = tree.selected - 1; i >= 0; i--) {
+          if (tree.items[i].level < current.level) {
+            tree.selected = i;
+            break;
+          }
+        }
+      } else {
+        // At root level, go back to main menu
+        inTree = false;
+      }
+    } else if (key.name === 'up') {
+      tree.selected = Math.max(0, tree.selected - 1);
+    } else if (key.name === 'down') {
+      tree.selected = Math.min(tree.items.length - 1, tree.selected + 1);
+    } else if (key.name === 'right' || key.name === 'return' || key.name === 'space') {
+      const current = tree.items[tree.selected];
+      if (!current) continue; // Safety check
+      if (current.type === 'section') {
+        if (!tree.expanded[current.key]) {
+          tree.expanded[current.key] = true;
+          // Load requirements for this section
+          if (current.key === 'todo') {
+            tree.todoReqs = await loadSection(current.key, current.section);
+          } else if (current.key === 'verify') {
+            tree.verifyReqs = await loadSection(current.key, current.section);
+          } else if (current.key === 'verified') {
+            tree.verifiedReqs = await loadVerified();
+          } else if (current.key === 'recycled') {
+            tree.recycledReqs = await loadSection(current.key, current.section);
+          }
+          buildTree();
+        } else {
+          tree.expanded[current.key] = false;
+          buildTree();
+        }
+      } else if (current.type === 'requirement') {
+        // Show requirement actions
+        await showRequirementActions(current.req, current.sectionKey, tree);
+        buildTree();
+      } else if (current.type === 'clarification') {
+        // Show clarification requirement with questions
+        await showClarificationActions(current.req, tree, loadClarification);
+        buildTree();
+      } else if (current.type === 'verified') {
+        // Show verified item details (read-only)
+        console.clear();
+        console.log(chalk.bold.green(`\n${current.label}\n`));
+        console.log(chalk.gray('(From CHANGELOG.md - read only)'));
+        console.log(chalk.gray('\nPress any key to go back...'));
+        await new Promise((resolve) => {
+          readline.emitKeypressEvents(process.stdin);
+          if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+          }
+          const handler = (str, key) => {
+            process.stdin.removeListener('keypress', handler);
+            if (process.stdin.isTTY) {
+              process.stdin.setRawMode(false);
+            }
+            resolve();
+          };
+          process.stdin.on('keypress', handler);
+          process.stdin.resume();
+        });
+      } else if (current.type === 'add') {
+        // Handle add requirement
+        await handleAddRequirement(current.key);
+        // Reload TODO section
+        tree.todoReqs = await loadSection('todo', '⏳ Requirements not yet completed');
+        buildTree();
+      }
+    } else if (key.name === 'r') {
+      const current = tree.items[tree.selected];
+      if (!current) continue; // Safety check
+
+      if (current.type === 'requirement') {
+        await deleteRequirement(current.req, current.sectionKey, tree);
+        buildTree();
+      } else if (current.type === 'clarification') {
+        await deleteClarification(current.req, tree);
+        tree.clarificationReqs = await loadClarification();
+        buildTree();
+      } else if (current.type === 'recycled') {
+        await deleteRequirement(current.req, current.sectionKey, tree);
+        tree.recycledReqs = await loadSection('recycled', '♻️ Recycled');
+        buildTree();
+      }
+    } else if (key.name === 'j') {
+      const current = tree.items[tree.selected];
+      if (!current) continue; // Safety check
+
+      if (current.type === 'requirement') {
+        await moveRequirementDown(current.req, current.sectionKey, tree);
+        buildTree();
+        // Move selection down to follow the item
+        if (tree.selected < tree.items.length - 1) {
+          tree.selected++;
+        }
+      }
+    } else if (key.name === 'k') {
+      const current = tree.items[tree.selected];
+      if (!current) continue; // Safety check
+
+      if (current.type === 'requirement') {
+        await moveRequirementUp(current.req, current.sectionKey, tree);
+        buildTree();
+        // Move selection up to follow the item
+        if (tree.selected > 0) {
+          tree.selected--;
+        }
+      }
+    } else if (key.name === 'u') {
+      const current = tree.items[tree.selected];
+      if (!current) continue; // Safety check
+
+      if (current.type === 'requirement') {
+        await promoteRequirement(current.req, current.sectionKey, tree, loadSection, loadVerified);
+        buildTree();
+      }
+    } else if (key.name === 'd') {
+      const current = tree.items[tree.selected];
+      if (!current) continue; // Safety check
+
+      if (current.type === 'clarification') {
+        // D on clarification item = Move to TODO
+        await moveClarificationToTodo(current.req, tree);
+        tree.clarificationReqs = await loadClarification();
+        tree.todoReqs = await loadSection('todo', '⏳ Requirements not yet completed');
+        buildTree();
+      } else if (current.type === 'requirement' || current.type === 'verified') {
+        const sectionKey = current.type === 'verified' ? 'verified' : current.sectionKey;
+        const reqTitle = current.type === 'verified' ? current.label : current.req.title;
+        await demoteRequirement(reqTitle, sectionKey, tree, loadSection, loadVerified);
+        buildTree();
+      }
+    }
+  }
+
+  process.stdin.pause();
+}
+
+// Helper to show goodbye message
+function showGoodbyeMessage() {
+  const hour = new Date().getHours();
+  const message = hour < 21
+    ? '\n👋 Goodbye! Be dreaming about what requirements to add!\n'
+    : '\n👋 Goodbye! Go get some sleep!\n';
+  console.log(chalk.cyan(message));
+}
+
+// Helper to get section title from section key
+function getSectionTitle(sectionKey) {
+  if (sectionKey === 'todo') return '⏳ Requirements not yet completed';
+  if (sectionKey === 'verify') return '✅ Verified by AI screenshot';
+  if (sectionKey === 'recycled') return '♻️ Recycled';
+  return '';
+}
+
+// Helper to get requirement list from tree by section key
+function getRequirementList(tree, sectionKey) {
+  if (sectionKey === 'todo') return tree.todoReqs;
+  if (sectionKey === 'verify') return tree.verifyReqs;
+  if (sectionKey === 'clarification') return tree.clarificationReqs;
+  if (sectionKey === 'recycled') return tree.recycledReqs;
+  return [];
+}
+
+// Helper to show confirmation prompt (r/y for yes, N for no, default N)
+async function confirmAction(message) {
+  console.log();
+  process.stdout.write(chalk.yellow(`${message} `));
+
+  const confirmed = await new Promise((resolve) => {
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+
+    const handler = (str, key) => {
+      process.stdin.removeListener('keypress', handler);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+
+      if (key && (key.ctrl && key.name === 'c')) {
+        process.exit(0);
+      }
+
+      const keyPressed = key ? key.name : str;
+
+      // Handle Enter as default (No)
+      if (keyPressed === 'return') {
+        console.log('N');
+        resolve(false);
+      } else {
+        console.log(keyPressed || ''); // Echo the key
+        if (keyPressed === 'r' || keyPressed === 'y') {
+          resolve(true);
+        } else {
+          resolve(false);
+        }
+      }
+    };
+
+    process.stdin.on('keypress', handler);
+    process.stdin.resume();
+  });
+
+  return confirmed;
+}
+
+// Helper to confirm exit and exit if confirmed (default N)
+async function confirmAndExit() {
+  console.log(chalk.gray('\n[DEBUG] confirmAndExit called'));
+  console.log();
+  process.stdout.write(chalk.yellow(`Are you sure you want to exit? (${chalk.white('x')}/${chalk.white('y')}/${chalk.white('N')}) `));
+
+  const confirmed = await new Promise((resolve) => {
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+
+    const handler = (str, key) => {
+      process.stdin.removeListener('keypress', handler);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+
+      if (key && (key.ctrl && key.name === 'c')) {
+        process.exit(0);
+      }
+
+      const keyPressed = key ? key.name : str;
+
+      // Handle Enter as default (No)
+      if (keyPressed === 'return') {
+        console.log('N');
+        resolve(false);
+      } else {
+        console.log(keyPressed || ''); // Echo the key
+        if (keyPressed === 'x' || keyPressed === 'y') {
+          resolve(true);
+        } else {
+          resolve(false);
+        }
+      }
+    };
+
+    process.stdin.on('keypress', handler);
+    process.stdin.resume();
+  });
+
+  if (confirmed) {
+    showGoodbyeMessage();
+    process.exit(0);
+  }
+}
+
+// Helper to edit clarification responses
+async function editClarificationResponses(req, tree) {
+  const { getRequirementsPath } = require('@vibecodingmachine/core');
+  const reqPath = await getRequirementsPath();
+
+  console.clear();
+  console.log(chalk.bold.cyan('\n✍️  Edit Clarification Responses\n'));
+  console.log(chalk.white(`${req.title}\n`));
+
+  const responses = [];
+
+  for (let i = 0; i < req.questions.length; i++) {
+    const q = req.questions[i];
+    console.log(chalk.cyan(`\n${q.question}`));
+
+    if (q.response) {
+      console.log(chalk.gray(`Current response: ${q.response}`));
+    }
+
+    const answer = await inquirer.prompt([{
+      type: 'input',
+      name: 'response',
+      message: 'Your response (press Enter to skip):',
+      default: q.response || ''
+    }]);
+
+    responses.push(answer.response);
+  }
+
+  // Update the file with responses
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  let inClarificationSection = false;
+  let inCurrentReq = false;
+  let questionIndex = 0;
+  const newLines = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    if (line.includes('❓ Requirements needing manual feedback')) {
+      inClarificationSection = true;
+      newLines.push(line);
+      continue;
+    }
+
+    if (inClarificationSection && line.startsWith('##') && !line.includes('❓ Requirements needing manual feedback')) {
+      inClarificationSection = false;
+      newLines.push(line);
+      continue;
+    }
+
+    if (inClarificationSection && line.trim() === `- ${req.title}`) {
+      inCurrentReq = true;
+      questionIndex = 0;
+      newLines.push(line);
+      continue;
+    }
+
+    if (inCurrentReq && (line.trim().startsWith('- ') || line.startsWith('##'))) {
+      inCurrentReq = false;
+      newLines.push(line);
+      continue;
+    }
+
+    if (inCurrentReq && line.trim().match(/^\d+\./)) {
+      // This is a question line
+      newLines.push(line);
+      // Add or update response on next line
+      if (responses[questionIndex]) {
+        newLines.push(`   Response: ${responses[questionIndex]}`);
+      }
+      questionIndex++;
+      // Skip existing response line if any
+      if (i + 1 < lines.length && lines[i + 1].trim().startsWith('Response:')) {
+        i++; // Skip the old response line
+      }
+      continue;
+    }
+
+    if (!inCurrentReq || !line.trim().startsWith('Response:')) {
+      newLines.push(line);
+    }
+  }
+
+  await fs.writeFile(reqPath, newLines.join('\n'));
+  console.log(chalk.green('\n✓ Responses saved!'));
+  await new Promise(resolve => setTimeout(resolve, 1000));
+}
+
+// Helper to move clarification requirement back to TODO
+async function moveClarificationToTodo(req, tree) {
+  const { getRequirementsPath } = require('@vibecodingmachine/core');
+  const reqPath = await getRequirementsPath();
+
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  let inClarificationSection = false;
+  let inCurrentReq = false;
+  let reqLines = [];
+  let clarificationSectionStart = -1;
+  let todoSectionStart = -1;
+  const newLines = [];
+
+  // First pass: find sections and extract requirement
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    if (line.includes('❓ Requirements needing manual feedback')) {
+      inClarificationSection = true;
+      clarificationSectionStart = i;
+      continue;
+    }
+
+    if (line.includes('⏳ Requirements not yet completed')) {
+      todoSectionStart = i;
+      inClarificationSection = false;
+    }
+
+    if (inClarificationSection && line.trim() === `- ${req.title}`) {
+      inCurrentReq = true;
+      reqLines.push(line);
+      continue;
+    }
+
+    if (inCurrentReq && (line.trim().startsWith('- ') || line.startsWith('##'))) {
+      inCurrentReq = false;
+    }
+
+    if (inCurrentReq) {
+      reqLines.push(line);
+    }
+  }
+
+  // Second pass: rebuild file
+  inClarificationSection = false;
+  inCurrentReq = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    if (line.includes('❓ Requirements needing manual feedback')) {
+      inClarificationSection = true;
+      newLines.push(line);
+      continue;
+    }
+
+    if (line.includes('⏳ Requirements not yet completed')) {
+      inClarificationSection = false;
+      newLines.push(line);
+      // Add the requirement to TODO section (at the top)
+      newLines.push(`- ${req.title}`);
+      continue;
+    }
+
+    if (inClarificationSection && line.trim() === `- ${req.title}`) {
+      inCurrentReq = true;
+      continue; // Skip this line
+    }
+
+    if (inCurrentReq && (line.trim().startsWith('- ') || line.startsWith('##'))) {
+      inCurrentReq = false;
+    }
+
+    if (!inCurrentReq) {
+      newLines.push(line);
+    }
+  }
+
+  await fs.writeFile(reqPath, newLines.join('\n'));
+  console.log(chalk.green('\n✓ Moved to TODO!'));
+  await new Promise(resolve => setTimeout(resolve, 1000));
+}
+
+// Helper to move clarification requirement to recycled (used to delete)
+async function deleteClarification(req, tree) {
+  const { getRequirementsPath } = require('@vibecodingmachine/core');
+  const reqPath = await getRequirementsPath();
+
+  const truncatedTitle = req.title.length > 50 ? req.title.substring(0, 50) + '...' : req.title;
+
+  if (await confirmAction(`Remove? (r/y/N)`)) {
+    // Move to recycled instead of deleting
+    await moveRequirementToRecycled(reqPath, req.title, '❓ Requirements needing manual feedback');
+
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+
+    let inClarificationSection = false;
+    let inCurrentReq = false;
+    const newLines = [];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      if (line.includes('❓ Requirements needing manual feedback')) {
+        inClarificationSection = true;
+        newLines.push(line);
+        continue;
+      }
+
+      if (inClarificationSection && line.startsWith('##') && !line.includes('❓ Requirements needing manual feedback')) {
+        inClarificationSection = false;
+      }
+
+      if (inClarificationSection && line.trim() === `- ${req.title}`) {
+        inCurrentReq = true;
+        continue; // Skip this line
+      }
+
+      if (inCurrentReq && (line.trim().startsWith('- ') || line.startsWith('##'))) {
+        inCurrentReq = false;
+      }
+
+      if (!inCurrentReq) {
+        newLines.push(line);
+      }
+    }
+
+    await fs.writeFile(reqPath, newLines.join('\n'));
+  }
+}
+
+// Helper to show actions for a requirement
+async function showClarificationActions(req, tree, loadClarification) {
+  const actions = [
+    { label: '✍️  Add/Edit Responses', value: 'edit-responses' },
+    { label: '↩️  Move back to TODO (after clarification)', value: 'move-to-todo' },
+    { label: '🗑️  Delete', value: 'delete' }
+  ];
+
+  let selected = 0;
+
+  while (true) {
+    // Redraw entire screen on each selection change
+    console.clear();
+    console.log(chalk.bold.yellow(`\n❓ Requirement Needing Clarification\n`));
+    console.log(chalk.white(`${req.title}\n`));
+
+    // Display AI findings if available
+    if (req.findings) {
+      console.log(chalk.bold.green('AI Found in Codebase:\n'));
+      console.log(chalk.gray(`${req.findings}\n`));
+    }
+
+    // Display questions
+    console.log(chalk.bold.cyan('Clarifying Questions:\n'));
+    req.questions.forEach((q, idx) => {
+      console.log(chalk.cyan(`${idx + 1}. ${q.question}`));
+      if (q.response) {
+        console.log(chalk.green(`   Response: ${q.response}`));
+      } else {
+        console.log(chalk.gray(`   (No response yet)`));
+      }
+      console.log();
+    });
+
+    // Display menu
+    console.log(chalk.gray('\nWhat would you like to do? (↑/↓/Enter to select, ESC/← to go back)\n'));
+    actions.forEach((action, idx) => {
+      if (idx === selected) {
+        console.log(chalk.cyan(`❯ ${action.label}`));
+      } else {
+        console.log(`  ${action.label}`);
+      }
+    });
+
+    // Handle input
+    const key = await new Promise((resolve) => {
+      readline.emitKeypressEvents(process.stdin);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+      }
+
+      const handler = (str, key) => {
+        process.stdin.removeListener('keypress', handler);
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(false);
+        }
+        resolve(key);
+      };
+
+      process.stdin.once('keypress', handler);
+    });
+
+    if (key.name === 'up') {
+      selected = Math.max(0, selected - 1);
+    } else if (key.name === 'down') {
+      selected = Math.min(actions.length - 1, selected + 1);
+    } else if (key.name === 'return' || key.name === 'space') {
+      const action = actions[selected].value;
+
+      if (action === 'edit-responses') {
+        await editClarificationResponses(req, tree);
+        tree.clarificationReqs = await loadClarification();
+        return;
+      } else if (action === 'move-to-todo') {
+        await moveClarificationToTodo(req, tree);
+        tree.clarificationReqs = await loadClarification();
+        return;
+      } else if (action === 'delete') {
+        await deleteClarification(req, tree);
+        tree.clarificationReqs = await loadClarification();
+        return;
+      }
+    } else if (key.name === 'escape' || key.name === 'left') {
+      return;
+    }
+  }
+}
+async function showRequirementActions(req, sectionKey, tree) {
+  const actions = [
+    { label: '👍 Thumbs up (move to top)', value: 'thumbs-up' },
+    { label: '👎 Thumbs down (move to bottom)', value: 'thumbs-down' },
+    { label: '⬆️  Move up', value: 'move-up' },
+    { label: '⬇️  Move down', value: 'move-down' },
+    { label: '🗑️  Delete', value: 'delete' }
+  ];
+
+  let selected = 0;
+  let isFirstRender = true;
+  let lastMenuLines = 0;
+
+  const displayMenu = () => {
+    // Clear previous menu (but not on first render)
+    if (!isFirstRender && lastMenuLines > 0) {
+      // Only move up by menu lines (header stays on screen)
+      readline.moveCursor(process.stdout, 0, -lastMenuLines);
+      readline.clearScreenDown(process.stdout);
+    }
+
+    // Display requirement title and details (only on first render)
+    if (isFirstRender) {
+      console.log(chalk.bold.yellow(`\n${req.title}\n`));
+      if (req.details.length > 0) {
+        console.log(chalk.gray(req.details.join('\n')));
+        console.log();
+      }
+    }
+
+    // Track menu lines printed this render (this is what we clear and reprint)
+    let menuLines = 0;
+
+    // Display menu (always reprinted)
+    console.log();
+    console.log(chalk.gray('What would you like to do? (↑/↓/Enter to select, ESC/← to go back)'));
+    console.log();
+    menuLines += 3; // Blank line + help text + blank line
+    actions.forEach((action, idx) => {
+      if (idx === selected) {
+        console.log(chalk.cyan(`❯ ${action.label}`));
+      } else {
+        console.log(`  ${action.label}`);
+      }
+      menuLines++;
+    });
+
+    lastMenuLines = menuLines;
+    isFirstRender = false;
+  };
+
+  while (true) {
+    displayMenu();
+
+    // Handle input
+    const key = await new Promise((resolve) => {
+      readline.emitKeypressEvents(process.stdin);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+      }
+
+      const handler = (str, key) => {
+        process.stdin.removeListener('keypress', handler);
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(false);
+        }
+        resolve(key);
+      };
+
+      process.stdin.on('keypress', handler);
+      process.stdin.resume();
+    });
+
+    if (!key) continue;
+
+    if ((key.ctrl && key.name === 'c') || key.name === 'escape' || key.name === 'left') {
+      return; // Go back
+    } else if (key.name === 'up') {
+      selected = Math.max(0, selected - 1);
+    } else if (key.name === 'down') {
+      selected = Math.min(actions.length - 1, selected + 1);
+    } else if (key.name === 'return' || key.name === 'right') {
+      await performRequirementAction(actions[selected].value, req, sectionKey, tree);
+      return;
+    }
+  }
+}
+
+// Helper to perform action on requirement
+async function performRequirementAction(action, req, sectionKey, tree) {
+  const reqList = getRequirementList(tree, sectionKey);
+  const sectionTitle = getSectionTitle(sectionKey);
+  const reqIndex = reqList.findIndex(r => r.title === req.title);
+
+
+  if (reqIndex === -1) return;
+
+  const { getRequirementsPath } = require('@vibecodingmachine/core');
+  const reqPath = await getRequirementsPath();
+
+  switch (action) {
+    case 'thumbs-up':
+      const thumbsUpReq = reqList.splice(reqIndex, 1)[0];
+      reqList.unshift(thumbsUpReq);
+      await saveRequirementsOrder(reqPath, sectionTitle, reqList);
+      console.log(chalk.green('\n✓ Moved to top\n'));
+      break;
+    case 'thumbs-down':
+      const thumbsDownReq = reqList.splice(reqIndex, 1)[0];
+      reqList.push(thumbsDownReq);
+      await saveRequirementsOrder(reqPath, sectionTitle, reqList);
+      console.log(chalk.yellow('\n✓ Moved to bottom\n'));
+      break;
+    case 'move-up':
+      if (reqIndex > 0) {
+        [reqList[reqIndex], reqList[reqIndex - 1]] = [reqList[reqIndex - 1], reqList[reqIndex]];
+        await saveRequirementsOrder(reqPath, sectionTitle, reqList);
+        console.log(chalk.green('\n✓ Moved up\n'));
+      }
+      break;
+    case 'move-down':
+      if (reqIndex < reqList.length - 1) {
+        [reqList[reqIndex], reqList[reqIndex + 1]] = [reqList[reqIndex + 1], reqList[reqIndex]];
+        await saveRequirementsOrder(reqPath, sectionTitle, reqList);
+        console.log(chalk.green('\n✓ Moved down\n'));
+      }
+      break;
+    case 'delete':
+      if (await confirmAction('Are you sure you want to delete this requirement?')) {
+        reqList.splice(reqIndex, 1);
+        await saveRequirementsOrder(reqPath, sectionTitle, reqList);
+        console.log(chalk.green('\n✓ Deleted\n'));
+      }
+      break;
+  }
+
+  await new Promise(resolve => setTimeout(resolve, 1000));
+}
+
+// Helper to move requirement to recycled section (used to delete)
+async function deleteRequirement(req, sectionKey, tree) {
+  const reqList = getRequirementList(tree, sectionKey);
+  const sectionTitle = getSectionTitle(sectionKey);
+  const reqIndex = reqList.findIndex(r => r.title === req.title);
+
+  if (reqIndex === -1) return;
+
+  const { getRequirementsPath } = require('@vibecodingmachine/core');
+  const reqPath = await getRequirementsPath();
+
+  const truncatedTitle = req.title.substring(0, 50) + (req.title.length > 50 ? '...' : '');
+  if (await confirmAction(`Remove? (r/y/N)`)) {
+    // Move to recycled instead of deleting
+    await moveRequirementToRecycled(reqPath, req.title, sectionTitle);
+    reqList.splice(reqIndex, 1);
+  }
+}
+
+// Helper to move requirement to recycled section
+async function moveRequirementToRecycled(reqPath, requirementTitle, fromSection) {
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find the requirement block (### header format)
+  let requirementStartIndex = -1;
+  let requirementEndIndex = -1;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.startsWith('###')) {
+      const title = line.replace(/^###\s*/, '').trim();
+      if (title && title.includes(requirementTitle)) {
+        requirementStartIndex = i;
+        // Find the end of this requirement (next ### or ## header)
+        for (let j = i + 1; j < lines.length; j++) {
+          const nextLine = lines[j].trim();
+          if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
+            requirementEndIndex = j;
+            break;
+          }
+        }
+        if (requirementEndIndex === -1) {
+          requirementEndIndex = lines.length;
+        }
+        break;
+      }
+    }
+  }
+
+  if (requirementStartIndex === -1) {
+    console.log(chalk.yellow('⚠️  Could not find requirement to recycle'));
+    return;
+  }
+
+  // Extract the requirement block
+  const requirementBlock = lines.slice(requirementStartIndex, requirementEndIndex);
+
+  // Remove the requirement from its current location
+  lines.splice(requirementStartIndex, requirementEndIndex - requirementStartIndex);
+
+  // Find or create Recycled section
+  let recycledIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes('♻️ Recycled') || lines[i].includes('🗑️ Recycled')) {
+      recycledIndex = i;
+      break;
+    }
+  }
+
+  // If Recycled section doesn't exist, create it before the last section
+  if (recycledIndex === -1) {
+    // Find the last section header
+    let lastSectionIndex = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (lines[i].startsWith('##') && !lines[i].startsWith('###')) {
+        lastSectionIndex = i;
+        break;
+      }
+    }
+
+    // Insert new Recycled section
+    const insertIndex = lastSectionIndex > 0 ? lastSectionIndex : lines.length;
+    lines.splice(insertIndex, 0, '', '## ♻️ Recycled', '');
+    recycledIndex = insertIndex + 1;
+  }
+
+  // Insert requirement block at TOP of Recycled list
+  let insertIndex = recycledIndex + 1;
+  while (insertIndex < lines.length && lines[insertIndex].trim() === '') {
+    insertIndex++;
+  }
+  lines.splice(insertIndex, 0, ...requirementBlock);
+  // Add blank line after if needed
+  if (insertIndex + requirementBlock.length < lines.length && lines[insertIndex + requirementBlock.length].trim() !== '') {
+    lines.splice(insertIndex + requirementBlock.length, 0, '');
+  }
+
+  // Save
+  await fs.writeFile(reqPath, lines.join('\n'));
+}
+
+// Helper to move requirement down with 'j' key
+async function moveRequirementDown(req, sectionKey, tree) {
+  const reqList = getRequirementList(tree, sectionKey);
+  const sectionTitle = getSectionTitle(sectionKey);
+  const reqIndex = reqList.findIndex(r => r.title === req.title);
+
+  if (reqIndex === -1 || reqIndex >= reqList.length - 1) return;
+
+  const { getRequirementsPath } = require('@vibecodingmachine/core');
+  const reqPath = await getRequirementsPath();
+
+  [reqList[reqIndex], reqList[reqIndex + 1]] = [reqList[reqIndex + 1], reqList[reqIndex]];
+  await saveRequirementsOrder(reqPath, sectionTitle, reqList);
+}
+
+// Helper to move requirement up with 'k' key
+async function moveRequirementUp(req, sectionKey, tree) {
+  const reqList = getRequirementList(tree, sectionKey);
+  const sectionTitle = getSectionTitle(sectionKey);
+  const reqIndex = reqList.findIndex(r => r.title === req.title);
+
+  if (reqIndex === -1 || reqIndex === 0) return;
+
+  const { getRequirementsPath } = require('@vibecodingmachine/core');
+  const reqPath = await getRequirementsPath();
+
+  [reqList[reqIndex], reqList[reqIndex - 1]] = [reqList[reqIndex - 1], reqList[reqIndex]];
+  await saveRequirementsOrder(reqPath, sectionTitle, reqList);
+}
+
+// Helper to promote requirement to next list (TODO -> TO VERIFY -> VERIFIED)
+async function promoteRequirement(req, sectionKey, tree, loadSection, loadVerified) {
+  const { getRequirementsPath, promoteTodoToVerify, promoteToVerified } = require('@vibecodingmachine/core');
+  const reqPath = await getRequirementsPath();
+
+  if (sectionKey === 'todo') {
+    // TODO -> TO VERIFY: Use shared function
+    const success = await promoteTodoToVerify(reqPath, req.title);
+    if (success) {
+      // Reload sections
+      tree.todoReqs = await loadSection('todo', '⏳ Requirements not yet completed');
+      tree.verifyReqs = await loadSection('verify', '✅ Verified by AI screenshot');
+    }
+  } else if (sectionKey === 'verify') {
+    // TO VERIFY -> VERIFIED: Use shared function
+    const success = await promoteToVerified(reqPath, req.title);
+    if (success) {
+      // Reload sections
+      tree.verifyReqs = await loadSection('verify', '✅ Verified by AI screenshot');
+      tree.verifiedReqs = await loadVerified();
+    }
+  }
+}
+
+// Helper to demote requirement to previous list (VERIFIED -> TODO, TO VERIFY -> TODO)
+async function demoteRequirement(reqTitle, sectionKey, tree, loadSection, loadVerified) {
+  const { getRequirementsPath, demoteVerifyToTodo, demoteFromVerifiedToTodo } = require('@vibecodingmachine/core');
+  const reqPath = await getRequirementsPath();
+
+  if (sectionKey === 'verify') {
+    // TO VERIFY -> TODO: Use shared function
+    const success = await demoteVerifyToTodo(reqPath, reqTitle);
+    if (success) {
+      // Reload sections
+      tree.todoReqs = await loadSection('todo', '⏳ Requirements not yet completed');
+      tree.verifyReqs = await loadSection('verify', '✅ Verified by AI screenshot');
+    }
+  } else if (sectionKey === 'verified') {
+    // VERIFIED -> TODO: Use shared function (with TRY AGAIN prefix)
+    const success = await demoteFromVerifiedToTodo(reqPath, reqTitle);
+    if (success) {
+      // Reload sections
+      tree.todoReqs = await loadSection('todo', '⏳ Requirements not yet completed');
+      tree.verifiedReqs = await loadVerified();
+    }
+  }
+}
+
+// Helper to handle adding requirements
+async function handleAddRequirement(type) {
+  const reqCommands = require('../commands/requirements');
+  const packages = ['all', 'cli', 'core', 'electron-app', 'web', 'mobile'];
+
+  if (type === 'add-one') {
+    try {
+      // Get saved package from config
+      const config = await readConfig();
+      let selectedPackage = config.lastPackage || ['all'];
+      // Ensure it's an array
+      if (typeof selectedPackage === 'string') selectedPackage = [selectedPackage];
+
+      let askPackage = !config.lastPackage;
+      let name = '';
+      let pkg = selectedPackage;
+
+      while (true) {
+        if (askPackage) {
+          const answer = await inquirer.prompt([{
+            type: 'checkbox',
+            name: 'pkg',
+            message: 'Select package(s):',
+            choices: packages.map(p => ({
+              name: p,
+              value: p,
+              checked: pkg.includes(p)
+            })),
+            validate: (answer) => {
+              if (answer.length < 1) return 'You must choose at least one package.';
+              return true;
+            }
+          }]);
+          pkg = answer.pkg;
+
+          // Save to config
+          config.lastPackage = pkg;
+          await writeConfig(config);
+          askPackage = false;
+        }
+
+        // Ask for requirement name
+        const pkgDisplay = pkg.join(', ');
+        const nameAnswer = await inquirer.prompt([{
+          type: 'input',
+          name: 'name',
+          message: `Enter requirement name (Package: ${pkgDisplay}) [Type < to change package]:`
+        }]);
+
+        name = nameAnswer.name;
+
+        if (name === '<') {
+          askPackage = true;
+          continue;
+        }
+
+        break;
+      }
+
+      // Then ask for multiline description (press Enter twice to finish)
+      console.log(chalk.gray('\nEnter description (press Enter twice on empty line to finish):\n'));
+      const descriptionLines = [];
+      let emptyLineCount = 0;
+      let isFirstLine = true;
+
+      while (true) {
+        try {
+          const { line } = await inquirer.prompt([{
+            type: 'input',
+            name: 'line',
+            message: isFirstLine ? 'Description:' : ''
+          }]);
+
+          isFirstLine = false;
+
+          if (line.trim() === '') {
+            emptyLineCount++;
+            if (emptyLineCount >= 2) {
+              break; // Two empty lines = done
+            }
+          } else {
+            emptyLineCount = 0;
+            descriptionLines.push(line);
+          }
+        } catch (err) {
+          break; // ESC pressed
+        }
+      }
+
+      const description = descriptionLines.join('\n');
+      await reqCommands.add(name, pkg, description);
+      // Message already printed by reqCommands.add()
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    } catch (err) {
+      // ESC pressed
+    }
+  } else if (type === 'add-many') {
+    try {
+      console.log(chalk.cyan('\nAdding multiple requirements:\n'));
+      const requirements = [];
+      let done = false;
+
+      while (!done) {
+        try {
+          // Ask for package
+          const { package } = await inquirer.prompt([{
+            type: 'list',
+            name: 'package',
+            message: `Package for requirement ${requirements.length + 1}:`,
+            choices: packages.map(p => ({ name: p, value: p })),
+            default: 'all'
+          }]);
+
+          // Ask for name
+          const { name } = await inquirer.prompt([{
+            type: 'input',
+            name: 'name',
+            message: `Name for requirement ${requirements.length + 1}:`
+          }]);
+
+          if (name.trim() === '') {
+            done = true;
+          } else {
+            // Ask for description
+            console.log(chalk.gray('\nEnter description (press Enter twice on empty line to finish):\n'));
+            const descriptionLines = [];
+            let emptyLineCount = 0;
+            let isFirstLine = true;
+
+            while (true) {
+              try {
+                const { line } = await inquirer.prompt([{
+                  type: 'input',
+                  name: 'line',
+                  message: isFirstLine ? 'Description:' : ''
+                }]);
+
+                isFirstLine = false;
+
+                if (line.trim() === '') {
+                  emptyLineCount++;
+                  if (emptyLineCount >= 2) {
+                    break;
+                  }
+                } else {
+                  emptyLineCount = 0;
+                  descriptionLines.push(line);
+                }
+              } catch (err) {
+                break;
+              }
+            }
+
+            const description = descriptionLines.join('\n');
+            requirements.push({ name, package, description });
+          }
+        } catch (err) {
+          done = true;
+        }
+      }
+
+      if (requirements.length > 0) {
+        for (const req of requirements) {
+          await reqCommands.add(req.name, req.package, req.description);
+        }
+        console.log(chalk.green(`\n✓ Added ${requirements.length} requirement(s)\n`));
+        await new Promise(resolve => setTimeout(resolve, 1000));
+      }
+    } catch (err) {
+      // ESC pressed
+    }
+  }
+}
+
+// Helper to show requirements from a specific section with actions
+async function showRequirementsBySection(sectionTitle) {
+  const { getRequirementsPath } = require('@vibecodingmachine/core');
+  const reqPath = await getRequirementsPath();
+
+  if (!reqPath || !await fs.pathExists(reqPath)) {
+    console.log(chalk.yellow('No requirements file found.'));
+    return;
+  }
+
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  let inSection = false;
+  const requirements = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Check if we're entering the target section
+    if (line.includes(sectionTitle)) {
+      inSection = true;
+      continue;
+    }
+
+    // Check if we're leaving the section (hit another ## section)
+    if (inSection && line.startsWith('## ') && !line.includes(sectionTitle)) {
+      break;
+    }
+
+    // Collect requirements in the section (formatted as bullet points with -)
+    if (inSection && line.trim().startsWith('- ')) {
+      const title = line.trim().substring(2); // Remove "- " prefix
+      const details = [];
+
+      // Collect details (continuation lines until next bullet point or section)
+      for (let j = i + 1; j < lines.length; j++) {
+        if (lines[j].trim().startsWith('- ') || lines[j].startsWith('##')) {
+          break;
+        }
+        if (lines[j].trim()) {
+          details.push(lines[j].trim());
+        }
+      }
+
+      requirements.push({ title, details, lineIndex: i });
+    }
+  }
+
+  if (requirements.length === 0) {
+    console.log(chalk.gray('  (No requirements in this section)'));
+    return;
+  }
+
+  // Show interactive list
+  let inRequirementsList = true;
+  while (inRequirementsList) {
+    try {
+      console.log(chalk.bold.cyan(`\n${sectionTitle}\n`));
+      console.log(chalk.green(`Total: ${requirements.length} requirement(s)\n`));
+
+      const choices = requirements.map((req, index) => ({
+        name: `${index + 1}. ${req.title}`,
+        value: index
+      }));
+
+      const { selectedIndex } = await inquirer.prompt([{
+        type: 'list',
+        name: 'selectedIndex',
+        message: 'Select a requirement (ESC to go back):',
+        choices: choices,
+        pageSize: 15
+      }]);
+
+      // Show actions for selected requirement
+      const requirement = requirements[selectedIndex];
+      console.log(chalk.bold.yellow(`\n${requirement.title}\n`));
+      if (requirement.details.length > 0) {
+        console.log(chalk.gray(requirement.details.join('\n')));
+        console.log();
+      }
+
+      const { action } = await inquirer.prompt([{
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to do? (ESC to go back)',
+        choices: [
+          { name: '👍 Thumbs up (prioritize)', value: 'thumbs-up' },
+          { name: '👎 Thumbs down (deprioritize)', value: 'thumbs-down' },
+          { name: '⬆️  Move up', value: 'move-up' },
+          { name: '⬇️  Move down', value: 'move-down' },
+          { name: '🗑️  Delete', value: 'delete' }
+        ]
+      }]);
+
+      // Perform action
+      switch (action) {
+        case 'thumbs-up':
+          // Move to top of list
+          const thumbsUpReq = requirements.splice(selectedIndex, 1)[0];
+          requirements.unshift(thumbsUpReq);
+          await saveRequirementsOrder(reqPath, sectionTitle, requirements);
+          console.log(chalk.green('\n✓ Moved to top (prioritized)\n'));
+          break;
+        case 'thumbs-down':
+          // Move to bottom of list
+          const thumbsDownReq = requirements.splice(selectedIndex, 1)[0];
+          requirements.push(thumbsDownReq);
+          await saveRequirementsOrder(reqPath, sectionTitle, requirements);
+          console.log(chalk.yellow('\n✓ Moved to bottom (deprioritized)\n'));
+          break;
+        case 'move-up':
+          if (selectedIndex > 0) {
+            [requirements[selectedIndex], requirements[selectedIndex - 1]] =
+              [requirements[selectedIndex - 1], requirements[selectedIndex]];
+            await saveRequirementsOrder(reqPath, sectionTitle, requirements);
+            console.log(chalk.green('\n✓ Moved up\n'));
+          } else {
+            console.log(chalk.yellow('\n⚠ Already at top\n'));
+          }
+          break;
+        case 'move-down':
+          if (selectedIndex < requirements.length - 1) {
+            [requirements[selectedIndex], requirements[selectedIndex + 1]] =
+              [requirements[selectedIndex + 1], requirements[selectedIndex]];
+            await saveRequirementsOrder(reqPath, sectionTitle, requirements);
+            console.log(chalk.green('\n✓ Moved down\n'));
+          } else {
+            console.log(chalk.yellow('\n⚠ Already at bottom\n'));
+          }
+          break;
+        case 'delete':
+          const { confirmDelete } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'confirmDelete',
+            message: 'Are you sure you want to delete this requirement?',
+            default: false
+          }]);
+          if (confirmDelete) {
+            requirements.splice(selectedIndex, 1);
+            await saveRequirementsOrder(reqPath, sectionTitle, requirements);
+            console.log(chalk.green('\n✓ Requirement deleted\n'));
+            if (requirements.length === 0) {
+              console.log(chalk.gray('No more requirements in this section.\n'));
+              inRequirementsList = false;
+            }
+          } else {
+            console.log(chalk.yellow('\nCancelled\n'));
+          }
+          break;
+      }
+    } catch (error) {
+      // ESC pressed - exit list
+      inRequirementsList = false;
+    }
+  }
+}
+
+// Helper to save reordered requirements back to file
+async function saveRequirementsOrder(reqPath, sectionTitle, requirements) {
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  let inSection = false;
+  let sectionStartIndex = -1;
+  let sectionEndIndex = -1;
+
+  // Find section boundaries
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(sectionTitle)) {
+      inSection = true;
+      sectionStartIndex = i;
+      continue;
+    }
+    // Stop at next ## header (but not ### which are requirement headers)
+    if (inSection && lines[i].startsWith('## ') && !lines[i].startsWith('###') && !lines[i].includes(sectionTitle)) {
+      sectionEndIndex = i;
+      break;
+    }
+  }
+
+  if (sectionEndIndex === -1) {
+    sectionEndIndex = lines.length;
+  }
+
+  // Rebuild section with new order (### header format)
+  const newSectionLines = [lines[sectionStartIndex]];
+  for (const req of requirements) {
+    // Add requirement header
+    newSectionLines.push(`### ${req.title}`);
+    // Add package if present
+    if (req.package && req.package !== 'all') {
+      newSectionLines.push(`PACKAGE: ${req.package}`);
+    }
+    // Add description if present
+    if (req.details && req.details.length > 0) {
+      req.details.forEach(line => {
+        if (line.trim()) {
+          newSectionLines.push(line);
+        }
+      });
+    }
+    // Add blank line after requirement
+    newSectionLines.push('');
+  }
+
+  // Replace section in content
+  const newLines = [
+    ...lines.slice(0, sectionStartIndex),
+    ...newSectionLines,
+    ...lines.slice(sectionEndIndex)
+  ];
+
+  await fs.writeFile(reqPath, newLines.join('\n'));
+}
+
+// Helper to show verified requirements from CHANGELOG
+async function showRequirementsFromChangelog() {
+  const { getVibeCodingMachineDir, checkVibeCodingMachineExists } = require('@vibecodingmachine/core');
+
+  const allnightStatus = await checkVibeCodingMachineExists();
+  let changelogPath;
+
+  if (allnightStatus.insideExists) {
+    const allnightDir = await getVibeCodingMachineDir();
+    changelogPath = path.join(path.dirname(allnightDir), 'CHANGELOG.md');
+  } else if (allnightStatus.siblingExists) {
+    changelogPath = path.join(process.cwd(), 'CHANGELOG.md');
+  }
+
+  if (!changelogPath || !await fs.pathExists(changelogPath)) {
+    console.log(chalk.yellow('No CHANGELOG.md found.'));
+    return;
+  }
+
+  const content = await fs.readFile(changelogPath, 'utf8');
+  const lines = content.split('\n');
+  let count = 0;
+
+  console.log(chalk.bold.cyan('Verified Requirements (from CHANGELOG.md):\n'));
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('- ') && trimmed.length > 10) {
+      count++;
+      console.log(chalk.green(`${count}. ${trimmed.substring(2)}`));
+    }
+  }
+
+  if (count === 0) {
+    console.log(chalk.gray('  (No verified requirements yet)'));
+  } else {
+    console.log(chalk.green(`\nTotal: ${count} requirement(s)`));
+  }
+}
+
+// Custom menu with both arrow keys and letter shortcuts
+async function showQuickMenu(items, initialSelectedIndex = 0) {
+  return new Promise((resolve) => {
+    // Skip blank and info items when setting initial index
+    let selectedIndex = initialSelectedIndex;
+    while (selectedIndex < items.length && (items[selectedIndex].type === 'blank' || items[selectedIndex].type === 'info')) {
+      selectedIndex++;
+    }
+    if (selectedIndex >= items.length) selectedIndex = 0;
+
+    let isFirstRender = true;
+    let lastLinesPrinted = 0;
+
+    // Helper to calculate visual lines occupied by text
+    const getVisualLineCount = (text) => {
+      const columns = process.stdout.columns || 80;
+      let lineCount = 0;
+
+      // Strip ANSI codes for length calculation
+      // Simple regex for stripping ANSI codes
+      const stripAnsi = (str) => str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
+
+      const lines = text.split('\n');
+      for (const line of lines) {
+        const visualLength = stripAnsi(line).length;
+        // If line is empty, it still takes 1 line
+        if (visualLength === 0) {
+          lineCount += 1;
+        } else {
+          // Calculate wrapped lines
+          lineCount += Math.ceil(visualLength / columns);
+        }
+      }
+      return lineCount;
+    };
+
+    const displayMenu = () => {
+      // Clear previous menu (move cursor up and clear lines) - but not on first render
+      if (!isFirstRender && lastLinesPrinted > 0) {
+        // Move cursor up by the number of lines we printed last time
+        readline.moveCursor(process.stdout, 0, -lastLinesPrinted);
+        readline.clearScreenDown(process.stdout);
+      }
+      isFirstRender = false;
+
+      // Track lines printed this render
+      let linesPrinted = 0;
+
+      // Display menu with highlight - all items get letters except info items
+      let letterIndex = 0;
+      items.forEach((item, index) => {
+        const isSelected = index === selectedIndex;
+        let output = '';
+
+        if (item.type === 'blank') {
+          // Blank separator line
+          console.log();
+          linesPrinted++;
+        } else if (item.type === 'info') {
+          // Info items are display-only, no letter, no selection
+          output = chalk.gray(`  ${item.name}`);
+          console.log(output);
+          linesPrinted += getVisualLineCount(`  ${item.name}`);
+        } else {
+          // All other items have letters (Exit always uses 'x')
+          let letter;
+          if (item.value === 'exit') {
+            letter = 'x';
+          } else {
+            letter = indexToLetter(letterIndex);
+            letterIndex++;
+          }
+
+          if (isSelected) {
+            output = chalk.cyan(`❯ ${letter}) ${item.name}`);
+            console.log(output);
+          } else if (item.type === 'setting') {
+            // Settings in gray
+            output = chalk.gray(`  ${letter}) ${item.name}`);
+            console.log(output);
+          } else {
+            // Actions in default color
+            output = `  ${letter}) ${item.name}`;
+            console.log(output);
+          }
+
+          // Calculate lines based on the actual text printed (including indentation/prefix)
+          // We reconstruct the raw string that was logged to calculate wrapping correctly
+          let rawString = '';
+          if (isSelected) {
+            rawString = `❯ ${letter}) ${item.name}`;
+          } else {
+            rawString = `  ${letter}) ${item.name}`;
+          }
+          linesPrinted += getVisualLineCount(rawString);
+        }
+      });
+
+      // Count all items with letters (excluding exit, blank, and info)
+      const letterCount = items.filter(item => item.type !== 'blank' && item.type !== 'info' && item.value !== 'exit').length;
+      const lastLetter = letterCount > 0 ? indexToLetter(letterCount - 1) : 'a';
+      const rangeText = letterCount > 1 ? `a-${lastLetter}` : (letterCount === 1 ? 'a' : '');
+      const helpText = rangeText ? `${rangeText}, x` : 'x';
+      const helpString = `\n  ↑/↓ to navigate, →/Enter to select, ←/X to exit, or press a letter (${helpText})`;
+      console.log(chalk.gray(helpString));
+      linesPrinted += getVisualLineCount(helpString);
+
+      // Save for next render
+      lastLinesPrinted = linesPrinted;
+    };
+
+    const cleanup = () => {
+      if (process.stdin.isTTY && process.stdin.setRawMode) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.removeListener('keypress', onKeypress);
+      process.stdin.pause();
+    };
+
+    const selectOption = (index) => {
+      // Debug: Log what's being selected
+      console.log(chalk.yellow(`\n[DEBUG] selectOption called with index: ${index}`));
+      console.log(chalk.yellow(`[DEBUG] Item at index ${index}: value="${items[index].value}", name="${items[index].name}"\n`));
+
+      cleanup();
+      // Don't clear screen for exit - we want to keep the status visible
+      if (items[index].value !== 'exit') {
+        // Clear the prompt line for non-exit options
+        readline.moveCursor(process.stdout, 0, -(items.length - index));
+        readline.clearScreenDown(process.stdout);
+        console.log(chalk.cyan(`  → ${items[index].name}\n`));
+      }
+      // Always log what value is being resolved
+      console.log(chalk.yellow(`[DEBUG] Resolving value: "${items[index].value}" from index ${index}\n`));
+      resolve({ value: items[index].value, selectedIndex: index });
+    };
+
+    displayMenu();
+
+    // Set up keypress listener
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+
+    const onKeypress = (str, key) => {
+      if (!key) return;
+
+      // Ctrl+C to exit
+      if (key.ctrl && key.name === 'c') {
+        cleanup();
+        process.exit(0);
+        return;
+      }
+
+      // ESC or left arrow to exit with confirmation
+      if (key.name === 'escape' || key.name === 'left') {
+        cleanup();
+        // Don't clear screen for exit - keep status visible
+        resolve({ value: 'exit', selectedIndex });
+        return;
+      }
+
+      // Letter keys for instant selection - 'x' always maps to exit
+      if (str && str.length === 1) {
+        if (str === 'x') {
+          // 'x' always maps to exit (will trigger confirmAndExit)
+          cleanup();
+          // Don't clear screen for exit - keep status visible
+          resolve({ value: 'exit', selectedIndex });
+          return;
+        } else if (str >= 'a' && str <= 'z') {
+          // Other letters map to all items (settings + actions, excluding exit, blank, and info)
+          const letterIndex = str.charCodeAt(0) - 97; // Convert letter to index (a=0, b=1, etc.)
+
+          // Find the nth item with a letter (excluding exit, blank, and info)
+          let letterCount = 0;
+          for (let i = 0; i < items.length; i++) {
+            if (items[i].type !== 'blank' && items[i].type !== 'info' && items[i].value !== 'exit') {
+              if (letterCount === letterIndex) {
+                selectOption(i);
+                return;
+              }
+              letterCount++;
+            }
+          }
+        }
+      }
+
+      // Arrow keys for navigation
+      if (key.name === 'up') {
+        // Skip blank and info lines when navigating
+        let newIndex = selectedIndex > 0 ? selectedIndex - 1 : items.length - 1;
+        while ((items[newIndex].type === 'blank' || items[newIndex].type === 'info') && newIndex !== selectedIndex) {
+          newIndex = newIndex > 0 ? newIndex - 1 : items.length - 1;
+        }
+        selectedIndex = newIndex;
+        displayMenu();
+      } else if (key.name === 'down') {
+        // Skip blank and info lines when navigating
+        let newIndex = selectedIndex < items.length - 1 ? selectedIndex + 1 : 0;
+        while ((items[newIndex].type === 'blank' || items[newIndex].type === 'info') && newIndex !== selectedIndex) {
+          newIndex = newIndex < items.length - 1 ? newIndex + 1 : 0;
+        }
+        selectedIndex = newIndex;
+        displayMenu();
+      } else if (key.name === 'return' || key.name === 'right') {
+        // Don't allow selecting blank or info lines
+        if (items[selectedIndex].type !== 'blank' && items[selectedIndex].type !== 'info') {
+          selectOption(selectedIndex);
+        }
+      }
+    };
+
+    process.stdin.on('keypress', onKeypress);
+    process.stdin.resume();
+  });
+}
+
+async function showProviderManagerMenu() {
+  const definitions = getProviderDefinitions();
+  const defMap = new Map(definitions.map(def => [def.id, def]));
+  const prefs = await getProviderPreferences();
+  let order = prefs.order.slice();
+  let enabled = { ...prefs.enabled };
+  let selectedIndex = 0;
+  let dirty = false;
+
+  // Initialize ProviderManager to check rate limits
+  const ProviderManager = require('@vibecodingmachine/core/src/ide-integration/provider-manager.cjs');
+  const providerManager = new ProviderManager();
+
+  const render = () => {
+    process.stdout.write('\x1Bc');
+    console.log(chalk.bold.cyan('⚙ Provider Order & Availability\n'));
+    console.log(chalk.gray('  ↑/↓ move selection    j/k reorder    e enable    d disable    Space toggle    Enter save/select    Esc cancel\n'));
+
+    order.forEach((id, idx) => {
+      const def = defMap.get(id);
+      if (!def) return;
+      const isSelected = idx === selectedIndex;
+      const isEnabled = enabled[id] !== false;
+      const statusLabel = isEnabled ? chalk.green('ENABLED') : chalk.red('DISABLED');
+      const typeLabel = def.type === 'ide' ? chalk.cyan('IDE') : chalk.cyan('LLM');
+      const prefix = isSelected ? chalk.cyan('❯') : ' ';
+      let line = `${prefix} ${idx + 1}. ${def.name} ${chalk.gray(`(${def.id})`)}  ${typeLabel}  ${statusLabel}`;
+
+      // Check for rate limits
+      const timeUntilReset = providerManager.getTimeUntilReset(id, def.model || id);
+      if (timeUntilReset) {
+        const resetTime = Date.now() + timeUntilReset;
+        const resetDate = new Date(resetTime);
+        const timeStr = resetDate.toLocaleString('en-US', {
+          weekday: 'short',
+          month: 'short',
+          day: 'numeric',
+          hour: 'numeric',
+          minute: '2-digit',
+          hour12: true,
+          timeZoneName: 'short'
+        });
+        line += ` ${chalk.red('⏰ Rate limited until ' + timeStr)}`;
+      }
+
+      console.log(line);
+    });
+
+    console.log();
+    if (dirty) {
+      console.log(chalk.yellow('Pending changes will be saved on Enter...'));
+    } else {
+      console.log(chalk.gray('No pending changes.'));
+    }
+  };
+
+  return new Promise((resolve) => {
+    const cleanup = () => {
+      if (process.stdin.isTTY && process.stdin.setRawMode) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.removeListener('keypress', onKeypress);
+      process.stdin.pause();
+    };
+
+    const saveAndExit = async (selectedId) => {
+      cleanup();
+      if (dirty) {
+        await saveProviderPreferences(order, enabled);
+      }
+      if (selectedId) {
+        const { setAutoConfig } = require('./config');
+        await setAutoConfig({ agent: selectedId, ide: selectedId });
+        const def = defMap.get(selectedId);
+        console.log(chalk.green(`\n✓ Active provider set to ${def?.name || selectedId}\n`));
+      } else {
+        console.log();
+      }
+      resolve(selectedId || null);
+    };
+
+    const cancel = () => {
+      cleanup();
+      console.log('\n');
+      resolve(null);
+    };
+
+    const moveSelection = (delta) => {
+      const next = selectedIndex + delta;
+      if (next >= 0 && next < order.length) {
+        selectedIndex = next;
+        render();
+      }
+    };
+
+    const reorder = (delta) => {
+      const target = selectedIndex + delta;
+      if (target < 0 || target >= order.length) return;
+      const temp = order[selectedIndex];
+      order[selectedIndex] = order[target];
+      order[target] = temp;
+      selectedIndex = target;
+      dirty = true;
+      render();
+    };
+
+    const toggle = (value) => {
+      const id = order[selectedIndex];
+      enabled[id] = value;
+      dirty = true;
+      render();
+    };
+
+    const onKeypress = (str, key = {}) => {
+      if (key.ctrl && key.name === 'c') {
+        cancel();
+        return;
+      }
+
+      switch (key.name) {
+        case 'up':
+          moveSelection(-1);
+          break;
+        case 'down':
+          moveSelection(1);
+          break;
+        case 'j':
+          reorder(1);
+          break;
+        case 'k':
+          reorder(-1);
+          break;
+        case 'e':
+          toggle(true);
+          break;
+        case 'd':
+          toggle(false);
+          break;
+        case 'space':
+          toggle(!(enabled[order[selectedIndex]] !== false));
+          break;
+        case 'return':
+          saveAndExit(order[selectedIndex]);
+          break;
+        case 'escape':
+        case 'x':
+          cancel();
+          break;
+        default:
+          break;
+      }
+    };
+
+    if (process.stdin.isTTY && process.stdin.setRawMode) {
+      process.stdin.setRawMode(true);
+    }
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.on('keypress', onKeypress);
+    process.stdin.resume();
+
+    render();
+  });
+}
+
+async function showSettings() {
+  console.log(chalk.bold.cyan('\n⚙️  Settings\n'));
+
+  const { setConfigValue } = require('@vibecodingmachine/core');
+  const { getAutoConfig, setAutoConfig } = require('./config');
+  const currentHostnameEnabled = await isComputerNameEnabled();
+  const hostname = getHostname();
+  const autoConfig = await getAutoConfig();
+  const currentIDE = autoConfig.ide || 'claude-code';
+
+  // Show current settings
+  console.log(chalk.gray('Current settings:'));
+  console.log(chalk.gray('  Computer Name:            '), chalk.cyan(hostname));
+  console.log(chalk.gray('  Current IDE:              '), chalk.cyan(formatIDEName(currentIDE)));
+  console.log(chalk.gray('  Use Hostname in Req File: '), currentHostnameEnabled ? chalk.green('Enabled ✓') : chalk.yellow('Disabled ○'));
+  console.log();
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'What would you like to do?',
+      choices: [
+        {
+          name: 'Change IDE',
+          value: 'change-ide'
+        },
+        {
+          name: currentHostnameEnabled ? 'Disable hostname in requirements file' : 'Enable hostname in requirements file',
+          value: 'toggle-hostname'
+        },
+        {
+          name: 'Back to main menu',
+          value: 'back'
+        }
+      ]
+    }
+  ]);
+
+  if (action === 'change-ide') {
+    const { ide } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'ide',
+        message: 'Select IDE:',
+        choices: [
+          { name: 'Claude Code CLI (recommended - Anthropic Claude)', value: 'claude-code' },
+          { name: 'Aider CLI (best for Ollama & Bedrock)', value: 'aider' },
+          { name: 'Continue CLI (Ollama support, but --auto mode doesn\'t execute code)', value: 'continue' },
+          { name: 'Cline CLI (local AI alternative, but has Ollama connection issues)', value: 'cline' },
+          { name: 'Cursor', value: 'cursor' },
+          { name: 'VS Code', value: 'vscode' },
+          { name: 'Windsurf', value: 'windsurf' }
+        ],
+        default: currentIDE
+      }
+    ]);
+
+    // Save to config
+    const newConfig = { ...autoConfig, ide };
+    await setAutoConfig(newConfig);
+
+    console.log(chalk.green('\n✓'), `IDE changed to ${chalk.cyan(formatIDEName(ide))}`);
+    console.log(chalk.gray('  Note: This will be used for the next Auto Mode session.'));
+    console.log();
+  } else if (action === 'toggle-hostname') {
+    const newValue = !currentHostnameEnabled;
+
+    // Save to shared config (same location as Electron app)
+    await setConfigValue('computerNameEnabled', newValue);
+
+    const statusText = newValue ? chalk.green('enabled') : chalk.yellow('disabled');
+    console.log(chalk.green('\n✓'), `Hostname in requirements file ${statusText}`);
+
+    if (newValue) {
+      console.log(chalk.gray('\n  Requirements file will be:'), chalk.cyan(`REQUIREMENTS-${hostname}.md`));
+    } else {
+      console.log(chalk.gray('\n  Requirements file will be:'), chalk.cyan('REQUIREMENTS.md'));
+    }
+
+    console.log(chalk.gray('\n  Note: You may need to rename your existing requirements file.'));
+    console.log(chalk.gray('  Note: This setting is now synced with the Electron app.'));
+    console.log();
+  }
+}
+
+async function startInteractive() {
+  // STRICT AUTH CHECK (only if enabled)
+  const authEnabled = process.env.AUTH_ENABLED === 'true';
+
+  if (authEnabled) {
+    const auth = require('./auth');
+    const isAuth = await auth.isAuthenticated();
+
+    if (!isAuth) {
+      console.clear();
+      console.log(chalk.bold.cyan('\nVibe Coding Machine CLI'));
+      console.log(chalk.cyan('\n🔒 Authentication Required'));
+      console.log(chalk.gray('Opening browser for Google authentication...\n'));
+
+      try {
+        await auth.login();
+        console.log(chalk.green('\n✓ Authentication successful!\n'));
+        // Continue to interactive mode after successful login
+      } catch (error) {
+        console.error(chalk.red('\n✗ Login failed:'), error.message);
+        if (error.message && error.message.includes('redirect_uri_mismatch')) {
+          console.log(chalk.yellow('\n⚠️  Troubleshooting:'));
+          console.log(chalk.gray('This error usually means the redirect URI is not whitelisted in Google Cloud Console.'));
+          console.log(chalk.gray('Ensure "https://<your-cognito-domain>/oauth2/idpresponse" is added to "Authorized redirect URIs".'));
+        }
+        process.exit(1);
+      }
+    }
+  } else {
+    // Auth disabled - show warning
+    console.log(chalk.yellow('\n⚠️  Authentication is currently disabled'));
+    console.log(chalk.gray('Set AUTH_ENABLED=true to enable authentication\n'));
+  }
+
+  // Ensure Auto Mode is stopped when CLI starts
+  const { stopAutoMode } = require('./auto-mode');
+  await stopAutoMode('startup');
+
+  await showWelcomeScreen();
+
+  let exit = false;
+  let lastSelectedIndex = 0; // Track last selected menu item
+  while (!exit) {
+    try {
+      const autoStatus = await checkAutoModeStatus();
+      const repoPath = process.cwd(); // Always use current working directory
+
+      // Check if .vibecodingmachine exists (inside repo or as sibling)
+      const allnightStatus = await checkVibeCodingMachineExists();
+
+      // Get current settings for display
+      const { getAutoConfig } = require('./config');
+      const autoConfig = await getAutoConfig();
+      const currentIDE = autoConfig.ide || 'claude-code';
+      const useHostname = await isComputerNameEnabled();
+
+      // Build dynamic menu items - settings at top (gray, no letters), actions below (with letters)
+      const items = [];
+
+      // Get current agent (unified IDE + LLM)
+      const currentAgent = autoConfig.agent || autoConfig.ide || 'ollama';
+      let agentDisplay = `Current Agent: ${chalk.cyan(getAgentDisplayName(currentAgent))}`;
+
+      // Check for rate limits (for LLM-based agents and Claude Code)
+      if (currentAgent === 'ollama' || currentAgent === 'groq' || currentAgent === 'anthropic' || currentAgent === 'bedrock' || currentAgent === 'claude-code') {
+        try {
+          const ProviderManager = require('@vibecodingmachine/core/src/ide-integration/provider-manager.cjs');
+          const providerManager = new ProviderManager();
+          const fs = require('fs');
+          const path = require('path');
+          const os = require('os');
+
+          const configPath = path.join(os.homedir(), '.config', 'allnightai', 'config.json');
+
+          if (fs.existsSync(configPath)) {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+            // Get the model based on the current agent type
+            let model;
+            if (currentAgent === 'groq') {
+              model = config.auto?.groqModel || config.auto?.aiderModel || config.auto?.llmModel;
+              // Remove groq/ prefix if present
+              if (model && model.includes('groq/')) {
+                model = model.split('/')[1];
+              }
+            } else if (currentAgent === 'anthropic') {
+              model = config.auto?.anthropicModel || config.auto?.aiderModel || config.auto?.llmModel;
+            } else if (currentAgent === 'ollama') {
+              const rawModel = config.auto?.llmModel || config.auto?.aiderModel;
+              // Only use if it doesn't have groq/ prefix
+              model = rawModel && !rawModel.includes('groq/') ? rawModel : null;
+            } else if (currentAgent === 'bedrock') {
+              model = 'anthropic.claude-sonnet-4-v1';
+            } else if (currentAgent === 'claude-code') {
+              model = 'claude-code-cli';
+            }
+
+            // For Claude Code, use fixed model name
+            const checkModel = currentAgent === 'claude-code' ? 'claude-code-cli' : model;
+            const provider = currentAgent === 'ollama' ? 'ollama' : currentAgent;
+
+            if (checkModel) {
+              const timeUntilReset = providerManager.getTimeUntilReset(provider, checkModel);
+
+              if (timeUntilReset) {
+                const resetTime = Date.now() + timeUntilReset;
+                const resetDate = new Date(resetTime);
+                const timeStr = resetDate.toLocaleString('en-US', {
+                  weekday: 'short',
+                  month: 'short',
+                  day: 'numeric',
+                  hour: 'numeric',
+                  minute: '2-digit',
+                  hour12: true,
+                  timeZoneName: 'short'
+                });
+                agentDisplay += ` ${chalk.red('⏰ Rate limited until ' + timeStr)}`;
+              }
+            }
+          }
+        } catch (err) {
+          // Silently ignore rate limit check errors
+        }
+      }
+
+      // Settings at top (gray, left-justified, no letters)
+
+
+
+      // Get stop condition from already loaded autoConfig (line 1704)
+      const stopCondition = autoConfig.neverStop ? 'Never Stop' :
+        autoConfig.maxChats ? `Stop after ${autoConfig.maxChats}` :
+          'Never Stop';
+
+      // Get restart CLI setting from autoConfig
+      const restartCLI = autoConfig.restartCLI ? chalk.green('Enabled ✓') : chalk.yellow('Disabled ○');
+
+      if (autoStatus.running) {
+        items.push({
+          type: 'setting',
+          name: `Auto Mode: ${chalk.green('Running ✓')}`,
+          value: 'setting:auto-stop'
+        });
+      } else {
+        items.push({
+          type: 'setting',
+          name: `Auto Mode: ${chalk.yellow('Stopped ○')}`,
+          value: 'setting:auto-start'
+        });
+      }
+
+      // Add separate stop condition setting
+      items.push({
+        type: 'setting',
+        name: `  └─ Stop Condition: ${chalk.cyan(stopCondition)}`,
+        value: 'setting:auto-stop-condition'
+      });
+
+      // Add restart CLI setting
+      items.push({
+        type: 'setting',
+        name: `  └─ Restart CLI after each completed requirement: ${restartCLI}`,
+        value: 'setting:restart-cli'
+      });
+
+      // Add setup alias setting
+      items.push({
+        type: 'setting',
+        name: `  └─ Setup 'vcm' alias`,
+        value: 'setting:setup-alias'
+      });
+
+      // Add current agent setting
+      items.push({
+        type: 'setting',
+        name: `  └─ ${agentDisplay}`,
+        value: 'setting:agent'
+      });
+
+
+
+      // Add Requirements as a selectable setting with counts
+      const hasRequirements = await requirementsExists();
+      const counts = hasRequirements ? await countRequirements() : null;
+      let requirementsText = 'Requirements: ';
+      if (counts) {
+        const total = counts.todoCount + counts.toVerifyCount + counts.verifiedCount;
+        if (total > 0) {
+          const todoPercent = Math.round((counts.todoCount / total) * 100);
+          const toVerifyPercent = Math.round((counts.toVerifyCount / total) * 100);
+          const verifiedPercent = Math.round((counts.verifiedCount / total) * 100);
+          requirementsText += `${chalk.yellow(counts.todoCount + ' (' + todoPercent + '%) TODO')}, ${chalk.cyan(counts.toVerifyCount + ' (' + toVerifyPercent + '%) TO VERIFY')}, ${chalk.green(counts.verifiedCount + ' (' + verifiedPercent + '%) VERIFIED')}`;
+
+          // Add warning if no TODO requirements
+          if (counts.todoCount === 0) {
+            requirementsText += ` ${chalk.red('⚠️ No requirements to work on')}`;
+          }
+        } else {
+          requirementsText = '';
+        }
+      } else if (allnightStatus.exists) {
+        requirementsText += chalk.yellow('Not found');
+      } else {
+        requirementsText += chalk.yellow('Not initialized');
+      }
+
+      if (requirementsText !== '') {
+        items.push({
+          type: 'setting',
+          name: requirementsText,
+          value: 'setting:requirements'
+        });
+      }
+
+      items.push({
+        type: 'setting',
+        name: `  └─ Use Hostname in Req File: ${useHostname ? chalk.green('Enabled ✓') : chalk.yellow('Disabled ○')}`,
+        value: 'setting:hostname'
+      });
+
+      // Add "Next TODO Requirement" as a separate menu item if there are TODO items
+      if (counts && counts.todoCount > 0) {
+        // Get the actual next requirement text (new header format)
+        let nextReqText = '...';
+        let count = 0;
+        try {
+          const hostname = await getHostname();
+          const reqFilename = await getRequirementsFilename(hostname);
+          const reqPath = path.join(repoPath, '.vibecodingmachine', reqFilename);
+
+          if (await fs.pathExists(reqPath)) {
+            const reqContent = await fs.readFile(reqPath, 'utf8');
+            const lines = reqContent.split('\n');
+            let inTodoSection = false;
+
+            // Find first non-empty requirement in TODO section
+            for (let i = 0; i < lines.length; i++) {
+              const line = lines[i].trim();
+
+              // Check if we're in the TODO section (same logic as auto-direct.js)
+              if (line.includes('## ⏳ Requirements not yet completed') ||
+                line.includes('Requirements not yet completed')) {
+                inTodoSection = true;
+                continue;
+              }
+
+              // If we hit another section header, stop looking
+              if (inTodoSection && line.startsWith('##') && !line.startsWith('###')) {
+                break;
+              }
+
+              // If we're in TODO section and find a requirement header (###)
+              if (inTodoSection && line.startsWith('###')) {
+                const title = line.replace(/^###\s*/, '').trim();
+                // Skip empty titles
+                if (title && title.length > 0) {
+                  count++;
+                  let description = '';
+
+                  // Read subsequent lines for description
+                  for (let j = i + 1; j < lines.length; j++) {
+                    const nextLine = lines[j].trim();
+                    // Stop if we hit another requirement or section
+                    if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
+                      break;
+                    }
+                    description += nextLine + '\n';
+                  }
+                  nextReqText = title;
+                  break;
+                }
+              }
+            }
+          }
+        } catch (err) {
+          console.error('Error getting next requirement:', err.message);
+        }
+
+        // Add "Next TODO Requirement" to the menu
+        items.push({
+          type: 'info',
+          name: `Next TODO Requirement: ${nextReqText}`,
+          value: 'next-req'
+        });
+      }
+
+      // Add warning message if no TODO requirements and Auto Mode is stopped
+      if (counts && counts.todoCount === 0 && !autoStatus.running) {
+        items.push({
+          type: 'setting',
+          name: chalk.red('  ⚠️  No requirements to work on - cannot start Auto Mode'),
+          value: 'setting:no-requirements'
+        });
+      }
+
+      // Blank separator line
+      items.push({ type: 'blank', name: '', value: 'blank' });
+
+      // Action items (with letters)
+      // Only show Initialize option if neither directory exists
+      if (!allnightStatus.exists) {
+        items.push({ type: 'action', name: 'Initialize repository (.vibecodingmachine)', value: 'repo:init' });
+      }
+
+      items.push({ type: 'action', name: 'Logout', value: 'logout' });
+      items.push({ type: 'action', name: 'Exit', value: 'exit' });
+
+
+      // Use custom quick menu with last selected index
+      const result = await showQuickMenu(items, lastSelectedIndex);
+      const action = result.value;
+      lastSelectedIndex = result.selectedIndex;
+
+      // Handle cancel (ESC key)
+      if (action === '__cancel__') {
+        // Just refresh and continue
+        continue;
+      }
+
+      // Debug: Log the action being processed
+      if (process.env.DEBUG) {
+        console.log(chalk.gray(`[DEBUG] Processing action: ${action}`));
+      }
+
+      // Ensure action is a string (safety check)
+      const actionStr = String(action || '').trim();
+
+      // Log action for debugging (always show, not just in DEBUG mode)
+      console.log(chalk.yellow(`\n[DEBUG] Action received: "${actionStr}" (type: ${typeof action})\n`));
+
+      switch (actionStr) {
+        case 'setting:agent': {
+          await showProviderManagerMenu();
+          await showWelcomeScreen();
+          break;
+        }
+        case 'setting:provider': {
+          // Switch AI provider - run provider setup only, don't start auto mode
+          // Note: Continue CLI doesn't have provider setup - models are configured in ~/.continue/config.yaml
+          if (currentIDE === 'continue') {
+            console.log(chalk.cyan('\n📝 Continue CLI Models\n'));
+
+            // Read Continue CLI config to show current models
+            try {
+              const fs = require('fs');
+              const path = require('path');
+              const os = require('os');
+              const yaml = require('js-yaml');
+              const { spawn } = require('child_process');
+              const configPath = path.join(os.homedir(), '.continue', 'config.yaml');
+
+              if (fs.existsSync(configPath)) {
+                const config = yaml.load(fs.readFileSync(configPath, 'utf8'));
+                const models = config.models || [];
+
+                if (models.length > 0) {
+                  // Check which models are downloaded
+                  const { execSync } = require('child_process');
+                  let installedNames = [];
+                  try {
+                    const installedModels = execSync('curl -s http://localhost:11434/api/tags', { encoding: 'utf8' });
+                    const modelsData = JSON.parse(installedModels);
+                    installedNames = modelsData.models.map(m => m.name.replace(':latest', ''));
+                  } catch (error) {
+                    console.log(chalk.yellow('  ⚠️  Could not check Ollama (is it running?)\n'));
+                  }
+
+                  // Build choices with status indicators
+                  const choices = models.map((model, idx) => {
+                    const modelName = model.model;
+                    const displayName = model.name || modelName;
+                    const isInstalled = installedNames.some(name =>
+                      name === modelName || name === modelName.replace(':latest', '')
+                    );
+                    const statusIcon = isInstalled ? chalk.green('✓') : chalk.yellow('⚠');
+                    const statusText = isInstalled ? chalk.gray('(installed)') : chalk.yellow('(needs download)');
+
+                    return {
+                      name: `${statusIcon} ${displayName} ${statusText}`,
+                      value: { model, isInstalled, index: idx }
+                    };
+                  });
+
+                  choices.push({ name: chalk.gray('← Back to menu'), value: null });
+
+                  const inquirer = require('inquirer');
+                  const { selection } = await inquirer.prompt([
+                    {
+                      type: 'list',
+                      name: 'selection',
+                      message: 'Select model to use:',
+                      choices: choices
+                    }
+                  ]);
+
+                  if (selection) {
+                    const { model, isInstalled, index } = selection;
+                    const modelName = model.model;
+
+                    // If not installed, download it first
+                    if (!isInstalled) {
+                      console.log(chalk.cyan(`\n📥 Downloading ${modelName}...\n`));
+                      console.log(chalk.gray('This may take a few minutes depending on model size...\n'));
+
+                      // Use Ollama HTTP API for model download
+                      const https = require('http');
+                      const downloadRequest = https.request({
+                        hostname: 'localhost',
+                        port: 11434,
+                        path: '/api/pull',
+                        method: 'POST',
+                        headers: {
+                          'Content-Type': 'application/json',
+                        }
+                      }, (res) => {
+                        let lastStatus = '';
+                        res.on('data', (chunk) => {
+                          try {
+                            const lines = chunk.toString().split('\n').filter(l => l.trim());
+                            lines.forEach(line => {
+                              const data = JSON.parse(line);
+                              if (data.status) {
+                                if (data.total && data.completed) {
+                                  // Show progress bar with percentage
+                                  const percent = Math.round((data.completed / data.total) * 100);
+                                  const completedMB = Math.round(data.completed / 1024 / 1024);
+                                  const totalMB = Math.round(data.total / 1024 / 1024);
+                                  const remainingMB = totalMB - completedMB;
+
+                                  // Create progress bar (50 chars wide)
+                                  const barWidth = 50;
+                                  const filledWidth = Math.round((percent / 100) * barWidth);
+                                  const emptyWidth = barWidth - filledWidth;
+                                  const bar = chalk.green('█'.repeat(filledWidth)) + chalk.gray('░'.repeat(emptyWidth));
+
+                                  process.stdout.write(`\r${bar} ${chalk.cyan(percent + '%')} ${chalk.white(completedMB + 'MB')} / ${chalk.gray(totalMB + 'MB')} ${chalk.yellow('(' + remainingMB + 'MB remaining)')}`);
+                                } else if (data.status !== lastStatus) {
+                                  lastStatus = data.status;
+                                  process.stdout.write(`\r${chalk.gray(data.status)}`.padEnd(120));
+                                }
+                              }
+                            });
+                          } catch (e) {
+                            // Ignore JSON parse errors for streaming responses
+                          }
+                        });
+                      });
+
+                      downloadRequest.on('error', (error) => {
+                        console.log(chalk.red(`\n\n✗ Download failed: ${error.message}\n`));
+                      });
+
+                      downloadRequest.write(JSON.stringify({ name: modelName }));
+                      downloadRequest.end();
+
+                      await new Promise((resolve) => {
+                        downloadRequest.on('close', () => {
+                          console.log(chalk.green(`\n\n✓ Successfully downloaded ${modelName}\n`));
+                          resolve();
+                        });
+                      });
+                    }
+
+                    // Move selected model to the top of the list
+                    const updatedModels = [...models];
+                    const [selectedModel] = updatedModels.splice(index, 1);
+                    updatedModels.unshift(selectedModel);
+
+                    // Update config file
+                    config.models = updatedModels;
+                    fs.writeFileSync(configPath, yaml.dump(config), 'utf8');
+
+                    console.log(chalk.green(`✓ Set ${model.name || modelName} as default model\n`));
+                    console.log(chalk.gray('Press Enter to continue...'));
+                    await inquirer.prompt([
+                      {
+                        type: 'input',
+                        name: 'continue',
+                        message: ''
+                      }
+                    ]);
+                  }
+                } else {
+                  console.log(chalk.yellow('  ⚠️  No models configured in config.yaml\n'));
+                  console.log(chalk.gray('  Config file:'), chalk.cyan(configPath), '\n');
+
+                  const inquirer = require('inquirer');
+                  await inquirer.prompt([
+                    {
+                      type: 'input',
+                      name: 'continue',
+                      message: 'Press Enter to return to menu...',
+                    }
+                  ]);
+                }
+              } else {
+                console.log(chalk.yellow('  ⚠️  Config file not found\n'));
+                console.log(chalk.gray('  Expected location:'), chalk.cyan(configPath), '\n');
+
+                const inquirer = require('inquirer');
+                await inquirer.prompt([
+                  {
+                    type: 'input',
+                    name: 'continue',
+                    message: 'Press Enter to return to menu...',
+                  }
+                ]);
+              }
+            } catch (error) {
+              console.log(chalk.red(`  ✗ Error: ${error.message}\n`));
+
+              const inquirer = require('inquirer');
+              await inquirer.prompt([
+                {
+                  type: 'input',
+                  name: 'continue',
+                  message: 'Press Enter to return to menu...',
+                }
+              ]);
+            }
+
+            await showWelcomeScreen();
+          } else {
+            console.log(chalk.cyan('\n🔄 Switching AI Provider...\n'));
+            await auto.start({ ide: currentIDE, forceProviderSetup: true, configureOnly: true });
+            await showWelcomeScreen();
+          }
+          break;
+        }
+        case 'setting:hostname': {
+          // Toggle hostname setting
+          const { setConfigValue } = require('@vibecodingmachine/core');
+          const newValue = !useHostname;
+          await setConfigValue('computerNameEnabled', newValue);
+          const statusText = newValue ? chalk.green('enabled') : chalk.yellow('disabled');
+          console.log(chalk.green('\n✓'), `Hostname in requirements file ${statusText}\n`);
+          await showWelcomeScreen();
+          break;
+        }
+        case 'setting:auto-start': {
+          try {
+            console.log(chalk.bold.cyan('\n🚀 Starting Auto Mode...\n'));
+            // Check if there are requirements to work on
+            const hasRequirements = await requirementsExists();
+            const counts = hasRequirements ? await countRequirements() : null;
+
+            if (!counts || counts.todoCount === 0) {
+              console.log(chalk.red('\n⚠️  Cannot start Auto Mode: No requirements to work on'));
+              console.log(chalk.gray('  Add requirements first using "Requirements" menu option\n'));
+              const inquirer = require('inquirer');
+              await inquirer.prompt([{
+                type: 'input',
+                name: 'continue',
+                message: 'Press Enter to return to menu...',
+              }]);
+              await showWelcomeScreen();
+              break;
+            }
+
+            // Start auto mode - use saved config settings
+            try {
+              // Get current config
+              const { getAutoConfig } = require('./config');
+              const currentConfig = await getAutoConfig();
+
+              // Use saved maxChats/neverStop settings
+              const options = { ide: currentIDE };
+              if (currentConfig.neverStop) {
+                options.neverStop = true;
+              } else if (currentConfig.maxChats) {
+                options.maxChats = currentConfig.maxChats;
+              } else {
+                // Default to never stop if not configured
+                options.neverStop = true;
+              }
+              console.log(chalk.gray(`\n[DEBUG] Calling auto.start with options:`, JSON.stringify(options, null, 2)));
+              console.log(chalk.gray('[DEBUG] Step 1: Starting auto mode...'));
+              try {
+                // Simple approach - just call auto.start(), no blessed UI
+                // Ensure stdin is NOT in raw mode before starting auto mode
+                // (otherwise Ctrl+C won't work)
+                if (process.stdin.isTTY && process.stdin.setRawMode) {
+                  process.stdin.setRawMode(false);
+                }
+
+                // ALWAYS use auto:direct (supports both LLM and IDE agents with proper looping)
+                const currentAgent = currentConfig.agent || currentConfig.ide || 'ollama';
+                console.log(chalk.gray('[DEBUG] Using auto:direct for agent:', currentAgent));
+                const { handleAutoStart: handleDirectAutoStart } = require('../commands/auto-direct');
+                await handleDirectAutoStart({ maxChats: options.maxChats });
+
+                // Prompt user before returning to menu (so they can read the output)
+                console.log('');
+                const inquirer = require('inquirer');
+                await inquirer.prompt([{
+                  type: 'input',
+                  name: 'continue',
+                  message: 'Press Enter to return to menu...',
+                }]);
+
+                await showWelcomeScreen();
+                break;
+
+              } catch (error) {
+                // Check if it's a cancellation (ESC) or actual error
+                if (error.message && error.message.includes('User force closed')) {
+                  console.log(chalk.yellow('\nCancelled\n'));
+                } else {
+                  console.log(chalk.red(`\n✗ Error starting Auto Mode: ${error.message}`));
+                  // Always show stack trace for debugging
+                  if (error.stack) {
+                    console.log(chalk.gray('\nStack trace:'));
+                    console.log(chalk.gray(error.stack.split('\n').slice(0, 10).join('\n')));
+                  }
+                  // Give user time to read the error
+                  console.log(chalk.yellow('\nReturning to menu in 5 seconds...'));
+                  await new Promise(resolve => setTimeout(resolve, 5000));
+                }
+                await showWelcomeScreen();
+              }
+            } catch (error) {
+              // Catch any errors in the inner try block (line 2066)
+              console.log(chalk.red(`\n✗ Error in auto mode setup: ${error.message}`));
+              if (error.stack) {
+                console.log(chalk.gray(error.stack));
+              }
+              const inquirer = require('inquirer');
+              await inquirer.prompt([{
+                type: 'input',
+                name: 'continue',
+                message: 'Press Enter to return to menu...',
+              }]);
+              await showWelcomeScreen();
+            }
+          } catch (error) {
+            // Catch any errors in the outer try block
+            console.log(chalk.red(`\n✗ Unexpected error: ${error.message}`));
+            if (error.stack) {
+              console.log(chalk.gray(error.stack));
+            }
+            const inquirer = require('inquirer');
+            await inquirer.prompt([{
+              type: 'input',
+              name: 'continue',
+              message: 'Press Enter to return to menu...',
+            }]);
+            await showWelcomeScreen();
+          }
+          break;
+        }
+        case 'setting:no-requirements': {
+          // User clicked on the warning message - show helpful info
+          console.log(chalk.red('\n⚠️  No requirements to work on'));
+          console.log(chalk.gray('\nTo start Auto Mode, you need at least one requirement in the "Requirements not yet completed" section.'));
+          console.log(chalk.gray('\nYou can:'));
+          console.log(chalk.cyan('  1. Add requirements using the "Requirements" menu option'));
+          console.log(chalk.cyan('  2. Or wait for requirements to be added to your REQUIREMENTS file\n'));
+          const inquirer = require('inquirer');
+          await inquirer.prompt([{
+            type: 'input',
+            name: 'continue',
+            message: 'Press Enter to return to menu...',
+          }]);
+          await showWelcomeScreen();
+          break;
+        }
+        case 'setting:auto-stop':
+          // Stop auto mode
+          await auto.stop();
+          await showWelcomeScreen();
+          break;
+        case 'setting:auto-stop-condition': {
+          // Modify stop condition
+          try {
+            const inquirer = require('inquirer');
+
+            // Get current config
+            const { getAutoConfig, setAutoConfig } = require('./config');
+            const currentConfig = await getAutoConfig();
+
+            // Determine default value for prompt
+            let defaultMaxChats = '';
+            if (currentConfig.neverStop) {
+              defaultMaxChats = '';
+            } else if (currentConfig.maxChats) {
+              defaultMaxChats = String(currentConfig.maxChats);
+            }
+
+            console.log(chalk.bold.cyan('\n⚙️  Configure Stop Condition\n'));
+
+            const { maxChats } = await inquirer.prompt([{
+              type: 'input',
+              name: 'maxChats',
+              message: 'Max chats (leave empty for never stop):',
+              default: defaultMaxChats
+            }]);
+
+            // Update config
+            const newConfig = { ...currentConfig };
+            if (maxChats && maxChats.trim() !== '') {
+              newConfig.maxChats = parseInt(maxChats);
+              newConfig.neverStop = false;
+              console.log(chalk.green('\n✓'), `Stop condition updated: ${chalk.cyan(`Stop after ${newConfig.maxChats}`)}\n`);
+            } else {
+              delete newConfig.maxChats;
+              newConfig.neverStop = true;
+              console.log(chalk.green('\n✓'), `Stop condition updated: ${chalk.cyan('Never Stop')}\n`);
+            }
+
+            await setAutoConfig(newConfig);
+          } catch (error) {
+            console.log(chalk.red('\n✗ Error updating stop condition:', error.message));
+          }
+          await showWelcomeScreen();
+          break;
+        }
+        case 'setting:restart-cli': {
+          // Toggle restart CLI setting
+          try {
+            const { getAutoConfig, setAutoConfig } = require('./config');
+            const currentConfig = await getAutoConfig();
+            const newConfig = { ...currentConfig, restartCLI: !currentConfig.restartCLI };
+            await setAutoConfig(newConfig);
+            const statusText = newConfig.restartCLI ? chalk.green('enabled') : chalk.yellow('disabled');
+            console.log(chalk.green('\n✓'), `Restart CLI after each completed requirement ${statusText}\n`);
+          } catch (error) {
+            console.log(chalk.red('\n✗ Error updating restart CLI setting:', error.message));
+          }
+          await showWelcomeScreen();
+          break;
+        }
+        case 'setting:setup-alias': {
+          const { setupAlias } = require('../commands/setup');
+          await setupAlias();
+          console.log(chalk.gray('\nPress Enter to return to menu...'));
+          const inquirer = require('inquirer');
+          await inquirer.prompt([{
+            type: 'input',
+            name: 'continue',
+            message: ''
+          }]);
+          await showWelcomeScreen();
+          break;
+        }
+        case 'setting:requirements': {
+          // Show tree-style requirements navigator
+          await showRequirementsTree();
+          await showWelcomeScreen();
+          break;
+        }
+        case 'repo:init':
+          await repo.initRepo();
+          break;
+        case 'auto:start': {
+          const { ide, maxChats } = await inquirer.prompt([
+            {
+              type: 'list',
+              name: 'ide',
+              message: 'Select IDE:',
+              choices: [
+                { name: 'Claude Code CLI (recommended - Anthropic Claude)', value: 'claude-code' },
+                { name: 'Aider CLI (best for Ollama & Bedrock)', value: 'aider' },
+                { name: 'Continue CLI (Ollama support, but --auto mode doesn\'t execute code)', value: 'continue' },
+                { name: 'Cline CLI (local AI alternative, but has Ollama connection issues)', value: 'cline' },
+                { name: 'Cursor', value: 'cursor' },
+                { name: 'VS Code', value: 'vscode' },
+                { name: 'Windsurf', value: 'windsurf' }
+              ],
+              default: 'claude-code'
+            },
+            {
+              type: 'input',
+              name: 'maxChats',
+              message: 'Max chats (leave empty for never stop):',
+              default: ''
+            }
+          ]);
+          const options = { ide };
+          if (maxChats) {
+            options.maxChats = parseInt(maxChats);
+          } else {
+            options.neverStop = true;
+          }
+
+          // Use blessed UI for persistent header and status card
+          console.log('[DEBUG] Attempting to load blessed UI...');
+          try {
+            console.log('[DEBUG] Requiring simple UI components...');
+            const { createAutoModeUI } = require('./auto-mode-simple-ui');
+            const { StdoutInterceptor } = require('./stdout-interceptor');
+            const { getRepoPath } = require('./config');
+            const { getRequirementsPath } = require('@vibecodingmachine/core');
+
+            console.log('[DEBUG] Getting repo info...');
+            // Get current repo info for the header
+            const repoPath = await getRepoPath();
+            const hostname = getHostname();
+            console.log('[DEBUG] Repo:', repoPath, 'Hostname:', hostname);
+
+            // Build menu content for header
+            const menuContent = `╭───────────────────────────────────────────────────────╮
+│                                                        │
+│   VibeCodingMachine                                          │
+│   Auto Mode Running - Press Ctrl+C to stop           │
+│                                                        │
+╰───────────────────────────────────────────────────────╯
+
+Repo:                     ${repoPath || 'Not set'}
+Computer Name:            ${hostname}
+Current IDE:              ${formatIDEName(ide)}
+AI Provider:              ${getCurrentAIProvider(ide) || 'N/A'}
+Max Chats:                ${maxChats || 'Never stop'}`;
+
+            // Create blessed UI
+            const ui = createAutoModeUI({
+              menuContent,
+              onExit: async () => {
+                // Stop auto mode when user presses Ctrl+C or Q
+                interceptor.stop();
+                await auto.stop();
+                process.exit(0);
+              }
+            });
+
+            // Create stdout interceptor to capture console output
+            const interceptor = new StdoutInterceptor();
+            interceptor.addHandler((output) => {
+              // Route console output to the blessed UI log
+              ui.appendOutput(output);
+            });
+            interceptor.start(false); // Don't pass through to original stdout
+
+            // Monitor requirements file for status updates
+            const reqPath = await getRequirementsPath(repoPath);
+            const fs = require('fs-extra');
+            const chokidar = require('chokidar');
+
+            // Initial status - auto mode always starts from first TODO requirement
+            try {
+              ui.updateStatus({
+                requirement: 'Loading first TODO requirement...',
+                step: 'PREPARE',
+                chatCount: 0,
+                maxChats: maxChats ? parseInt(maxChats) : null,
+                progress: 0
+              });
+            } catch (error) {
+              ui.updateStatus({
+                requirement: 'Error loading requirements',
+                step: 'UNKNOWN',
+                chatCount: 0,
+                maxChats: maxChats ? parseInt(maxChats) : null,
+                progress: 0
+              });
+            }
+
+            // Watch requirements file for changes
+            const watcher = chokidar.watch(reqPath, { persistent: true });
+            watcher.on('change', async () => {
+              try {
+                const reqContent = await fs.readFile(reqPath, 'utf-8');
+                const parsed = parseRequirementsFile(reqContent);
+
+                // Calculate progress based on step
+                const stepProgress = {
+                  'PREPARE': 20,
+                  'ACT': 40,
+                  'CLEAN UP': 60,
+                  'VERIFY': 80,
+                  'DONE': 100
+                };
+
+                ui.updateStatus({
+                  requirement: parsed.currentRequirement || 'Unknown',
+                  step: parsed.currentStatus || 'UNKNOWN',
+                  chatCount: 0, // TODO: Track actual chat count
+                  maxChats: maxChats ? parseInt(maxChats) : null,
+                  progress: stepProgress[parsed.currentStatus] || 0
+                });
+              } catch (error) {
+                // Silently ignore parse errors
+              }
+            });
+
+            // Start auto mode (this will output to our interceptor)
+            try {
+              // Ensure stdin is NOT in raw mode before starting auto mode
+              // (otherwise Ctrl+C won't work)
+              if (process.stdin.isTTY && process.stdin.setRawMode) {
+                process.stdin.setRawMode(false);
+              }
+
+              await auto.start(options);
+            } catch (error) {
+              ui.appendOutput(`\n\nError: ${error.message}\n`);
+            } finally {
+              // Cleanup
+              watcher.close();
+              interceptor.stop();
+              ui.destroy();
+            }
+          } catch (blessedError) {
+            // Fallback to regular auto mode if blessed UI fails
+            console.log(chalk.red('\n✗ Failed to create blessed UI:'), blessedError.message);
+            console.log(chalk.gray('  Falling back to standard output mode...\n'));
+
+            // Ensure stdin is NOT in raw mode before starting auto mode
+            // (otherwise Ctrl+C won't work)
+            if (process.stdin.isTTY && process.stdin.setRawMode) {
+              process.stdin.setRawMode(false);
+            }
+
+            await auto.start(options);
+          }
+
+          break;
+        }
+        case 'auto:stop':
+          await auto.stop();
+          break;
+        case 'auto:status':
+          await auto.status();
+          break;
+        case 'logout': {
+          // Logout
+          const auth = require('./auth');
+          try {
+            await auth.logout();
+            console.log(chalk.green('\n✓ Logged out successfully!\n'));
+            console.log(chalk.gray('Run "vcm auth:login" or "ana" to login again.\n'));
+            process.exit(0);
+          } catch (error) {
+            console.error(chalk.red('\n✗ Logout failed:'), error.message);
+            console.log(chalk.yellow('\nPress any key to continue...'));
+            await new Promise((resolve) => {
+              process.stdin.once('keypress', () => resolve());
+            });
+          }
+          break;
+        }
+        case 'exit': {
+          // Confirm and exit
+          console.log(chalk.gray('[DEBUG] Exit case triggered, calling confirmAndExit'));
+          await confirmAndExit();
+          console.log(chalk.gray('[DEBUG] confirmAndExit returned (user cancelled)'));
+          // If user cancelled (didn't exit), refresh the screen
+          await showWelcomeScreen();
+          break;
+        }
+        default:
+          // Log unhandled actions for debugging
+          console.log(chalk.yellow(`\n⚠️  Unhandled action: "${actionStr}"\n`));
+          console.log(chalk.gray('  This action is not implemented. Please report this issue.\n'));
+          const inquirer = require('inquirer');
+          await inquirer.prompt([{
+            type: 'input',
+            name: 'continue',
+            message: 'Press Enter to return to menu...',
+          }]);
+          await showWelcomeScreen();
+          break;
+      }
+    } catch (error) {
+      // Catch any unexpected errors in the main loop
+      console.log(chalk.red(`\n✗ Unexpected error in menu: ${error.message}`));
+      if (error.stack) {
+        console.log(chalk.gray(error.stack));
+      }
+      const inquirer = require('inquirer');
+      await inquirer.prompt([{
+        type: 'input',
+        name: 'continue',
+        message: 'Press Enter to return to menu...',
+      }]);
+      await showWelcomeScreen();
+    }
+  }
+}
+
+module.exports = { startInteractive };
+
+
+